@fastagent-sh/fastagent 0.24.4 → 0.26.0

package/dist/channels/control.js

@@ -1,329 +0,0 @@
-import { INVALID_COMMAND_CODE, SESSIONS_UNAVAILABLE_CODE, UNSUPPORTED_CAPABILITY_CODE, UPDATE_FIELDS, } from "../session.js";
-import { parseRouteKey, withoutBody } from "./serve.js";
-import { log } from "../log.js";
-import { readBodyCapped } from "./body.js";
-import { MAX_BODY_BYTES } from "./http.js";
-import { sseResponse } from "./sse.js";
-import { text } from "./respond.js";
-/** The prefix this plane OWNS: everything under it is the plane's to answer. */
-export const CONTROL_PREFIX = "/control";
-/** The one variable segment in this plane's paths: a percent-encoded session id. */
-const SESSION_SEGMENT = "{session}";
-/**
- * What `.../image` may answer under the image's own type. `mimeType` is whatever the prompt's sender wrote, and served
- * as-is a `text/html` or `image/svg+xml` "image" would run script on whatever origin fronts this plane.
- */
-const RASTER_IMAGE_TYPES = new Set(["image/png", "image/jpeg", "image/gif", "image/webp"]);
-const json = (value, status = 200) => new Response(`${JSON.stringify(value)}\n`, { status, headers: { "content-type": "application/json" } });
-/** The plane as one mounted sub-application rather than routes sharing a prefix. */
-function planeApp(routes) {
-    /** A route key's path split into segments, with `{session}` marked. */
-    const compiled = Object.entries(routes).map(([key, handler]) => {
-        const { method, path } = parseRouteKey(key);
-        return { method, path, segments: path.split("/"), handler };
-    });
-    const match = (path) => {
-        const segments = path.split("/");
-        const hits = [];
-        for (const route of compiled) {
-            if (route.segments.length !== segments.length)
-                continue;
-            let session;
-            let ok = true;
-            for (const [i, expected] of route.segments.entries()) {
-                const actual = segments[i];
-                if (expected === SESSION_SEGMENT) {
-                    // The one place a path segment becomes a Caller id again.
-                    if (actual === "") {
-                        ok = false;
-                        break;
-                    }
-                    try {
-                        session = decodeURIComponent(actual);
-                    }
-                    catch {
-                        // `%zz` and friends: not an id any client could have produced, so this path matches nothing and falls
-                        // through to the plane's own 404.
-                        ok = false;
-                        break;
-                    }
-                }
-                else if (expected !== actual) {
-                    ok = false;
-                    break;
-                }
-            }
-            if (ok)
-                hits.push({ route, session });
-        }
-        return hits;
-    };
-    return async (req) => {
-        const url = new URL(req.url);
-        const path = url.pathname;
-        const hits = match(path);
-        const answer = async () => {
-            const hit = hits.find((h) => h.route.method === req.method) ??
-                (req.method === "HEAD" ? hits.find((h) => h.route.method === "GET") : undefined);
-            if (hit)
-                return await hit.route.handler(req, url, hit.session ?? "");
-            // 404 vs 405 as in the host router: a client reads 404 as "this serve predates the route".
-            if (hits.length > 0)
-                return text("method not allowed\n", 405);
-            return text("not found\n", 404);
-        };
-        let res;
-        try {
-            // HEAD carries no content, whichever branch answered — including this plane's own 404/405.
-            const answered = await answer();
-            res = req.method === "HEAD" ? withoutBody(answered) : answered;
-        }
-        catch (error) {
-            // The plane's own totality boundary: a rejecting handler (`commands()` on an unreadable definition) must still
-            // answer with the headers; the message stays internal.
-            log.error(`[control] ${req.method} ${path} failed: ${String(error)}`);
-            res = text("internal error\n", 500);
-        }
-        // CORS is NOT set here: the host router owns that verdict for every path it publishes, this prefix included
-        // (channels/serve.ts). A second writer of those headers is a second policy to keep in sync.
-        return res;
-    };
-}
-// ONE constant for every Prompt-bearing wire surface (imported from the invoke channel — the two caps cannot drift
-// apart).
-const ACTION_BODY_LIMIT = MAX_BODY_BYTES;
-/**
- * Parse-don't-validate at the wire: a remote client can send any JSON, and the hub's inner layers trust action shapes
- * (a malformed `steer` would surface as an ENGINE failure misclassified as `run_command_failed`).
- */
-function parseWireAction(raw) {
-    // COMPILE-TIME drift guard, variant level: this switch hand-mirrors the SessionAction union, and a new variant
-    // added in session.ts would otherwise compile clean while the wire answers it `invalid_command` — silently breaking
-    // local/remote isomorphism.
-    const _actionDriftGuard = {
-        steer: true,
-        follow_up: true,
-        abort: true,
-        compact: true,
-    };
-    void _actionDriftGuard;
-    if (typeof raw !== "object" || raw === null)
-        return undefined;
-    const c = raw;
-    const imageOk = (i) => typeof i === "object" &&
-        i !== null &&
-        typeof i.data === "string" &&
-        typeof i.mimeType === "string";
-    const promptOk = (p) => {
-        if (typeof p !== "object" || p === null)
-            return false;
-        if (typeof p.text !== "string")
-            return false;
-        const images = p.images;
-        // Element-level: `images: [42]` reaching the engine would resurface exactly the misclassified failure this parser
-        // exists to prevent (ImageRef shape from src/session.ts's Prompt).
-        return images === undefined || (Array.isArray(images) && images.every(imageOk));
-    };
-    // REBUILD, never pass raw through: "typed out" must be construction, not assertion — a passed-through object would
-    // carry arbitrary extra keys into the engine.
-    const rebuildPrompt = (p) => {
-        const images = p.images;
-        return {
-            text: p.text,
-            ...(images ? { images: images.map((i) => ({ data: i.data, mimeType: i.mimeType })) } : {}),
-        };
-    };
-    // COMPILE-TIME drift guard: whitelist reconstruction silently strips any field it does not know.
-    const _promptDriftGuard = {};
-    void _promptDriftGuard;
-    // Same guard one level down: the image whitelist ({data, mimeType}) must break when ImageRef grows a field.
-    const _imageDriftGuard = {};
-    void _imageDriftGuard;
-    switch (c.type) {
-        case "steer":
-        case "follow_up":
-            return promptOk(c.prompt) ? { type: c.type, prompt: rebuildPrompt(c.prompt) } : undefined;
-        case "abort":
-            return { type: "abort" };
-        case "compact":
-            return c.instructions === undefined || typeof c.instructions === "string"
-                ? { type: "compact", instructions: c.instructions }
-                : undefined;
-        default:
-            return undefined;
-    }
-}
-/**
- * Parse a PATCH body into a session update — or into the REASON it is not one, because the two reasons are different
- * answers to the client.
- */
-function parseWireUpdate(raw) {
-    if (typeof raw !== "object" || raw === null) {
-        return { code: INVALID_COMMAND_CODE, message: "expected an object of session properties" };
-    }
-    const c = raw;
-    const unknown = Object.keys(c).filter((key) => !UPDATE_FIELDS.includes(key));
-    if (unknown.length > 0) {
-        return {
-            code: UNSUPPORTED_CAPABILITY_CODE,
-            message: `update field(s) ${unknown.join(", ")} — capabilities().updatable lists what this serve sets`,
-        };
-    }
-    const patch = {};
-    // The field list is the CONTRACT's (`UPDATE_FIELDS`), not a copy: a field added to SessionUpdate travels here
-    // without anyone remembering to, and one removed cannot linger.
-    for (const field of UPDATE_FIELDS) {
-        const value = c[field];
-        if (value === undefined)
-            continue;
-        if (typeof value !== "string") {
-            return { code: INVALID_COMMAND_CODE, message: `${field} must be a string` };
-        }
-        patch[field] = value;
-    }
-    return { patch };
-}
-/** Create the control plane as a mountable prefix owner. */
-export function createControlPlane(control) {
-    return mountControlPlane(controlPlaneRoutes(control));
-}
-/**
- * Mount a plane route table as a {@link PrefixMount} — the plane owns a PREFIX, while a route table is a set of paths,
- * at most one segment of which is a session id.
- */
-export function mountControlPlane(routes) {
-    return { prefix: CONTROL_PREFIX, handler: planeApp(routes) };
-}
-export function controlPlaneRoutes(control) {
-    const epoch = crypto.randomUUID();
-    /**
-     * Read a JSON body under the shared cap.
-     *
-     * No content-type gate here: this plane only ever rides the host router, which applies it to every route that
-     * authenticates nobody — this whole prefix included (channels/serve.ts).
-     */
-    const readJson = async (req) => {
-        const body = await readBodyCapped(req, ACTION_BODY_LIMIT);
-        // The 413 names the ceiling: the docs promise images on this plane, and an unexplained rejection would send a
-        // client author hunting everywhere but the cap.
-        if ("tooLarge" in body) {
-            return {
-                error: text(`body too large (limit ${MAX_BODY_BYTES >> 20} MiB — images count base64-inflated)\n`, 413),
-            };
-        }
-        // An empty body is an empty object: `POST …/actions` always carries one, but `PATCH` with nothing to set is a
-        // legal no-op and a client should not have to send `{}` to say so.
-        if (body.text.trim() === "")
-            return { value: {} };
-        try {
-            return { value: JSON.parse(body.text) };
-        }
-        catch {
-            return { error: text("invalid JSON\n", 400) };
-        }
-    };
-    return {
-        "GET /control/capabilities": () => json(control.capabilities()),
-        "GET /control/commands": async () => json(await control.commands()),
-        // The DEPLOYMENT's conversation list — and the one read that may fail.
-        "GET /control/sessions": async () => {
-            try {
-                return json(await control.sessions.list());
-            }
-            catch (error) {
-                // ONLY a store fault becomes the retryable code.
-                const code = error?.code;
-                if (typeof code !== "string" || !/^E[A-Z]+$/.test(code))
-                    throw error;
-                // Logged as well as answered: the catch would otherwise be the one place a store fault is invisible on the
-                // server, since it preempts the boundary that does the logging.
-                log.error(`[control] GET /control/sessions failed: ${String(error)}`);
-                return json({ code: SESSIONS_UNAVAILABLE_CODE, message: String(error), retryable: true }, 503);
-            }
-        },
-        // PUT, because a fork is idempotent: this id, holding the history that was at `from`@`at`.
-        [`PUT /control/sessions/${SESSION_SEGMENT}`]: async (req, _url, session) => {
-            const read = await readJson(req);
-            if ("error" in read)
-                return read.error;
-            // `JSON.parse("null")` is null, and a body is whatever the client sent: reaching into it unguarded turns a
-            // malformed request into a 500 the client cannot act on.
-            const body = read.value;
-            if (typeof body?.from !== "string" || typeof body.at !== "string") {
-                return text("expected { from: string, at: string }\n", 400);
-            }
-            return json(await control.sessions.fork({ from: body.from, at: body.at, into: session }));
-        },
-        [`GET /control/sessions/${SESSION_SEGMENT}`]: async (_req, _url, session) => json(await control.sessions.get(session).state()),
-        // PATCH, because these are session PROPERTIES: last-wins, durable, applied by the next turn.
-        [`PATCH /control/sessions/${SESSION_SEGMENT}`]: async (req, _url, session) => {
-            const read = await readJson(req);
-            if ("error" in read)
-                return read.error;
-            const parsed = parseWireUpdate(read.value);
-            // A protocol-level answer carrying the SAME code the hub would have used.
-            if (!("patch" in parsed)) {
-                return json({ ok: false, error: { ...parsed, retryable: false } });
-            }
-            return json(await control.sessions.get(session).update(parsed.patch));
-        },
-        [`DELETE /control/sessions/${SESSION_SEGMENT}`]: async (_req, _url, session) => json(await control.sessions.get(session).delete()),
-        [`GET /control/sessions/${SESSION_SEGMENT}/entries`]: async (_req, url, session) => {
-            const since = url.searchParams.get("since") ?? undefined;
-            return json(await control.sessions.get(session).entries(since !== undefined ? { since } : undefined));
-        },
-        // Raw bytes, not JSON-wrapped base64: a client can hand the response straight to an <img>. The ref names a
-        // durable entry, so the answer never changes. `ref` rides the query because this router has one path variable.
-        [`GET /control/sessions/${SESSION_SEGMENT}/image`]: async (_req, url, session) => {
-            const ref = url.searchParams.get("ref");
-            if (ref === null)
-                return text("expected ?ref=, an images[].ref from entries()\n", 400);
-            const image = await control.sessions.get(session).image(ref);
-            // The local call RETURNS undefined, so this is a 2xx (§13); a 404 stays "this serve predates the route".
-            if (!image)
-                return new Response(null, { status: 204 });
-            return new Response(Buffer.from(image.data, "base64"), {
-                headers: {
-                    "content-type": RASTER_IMAGE_TYPES.has(image.mimeType) ? image.mimeType : "application/octet-stream",
-                    "x-content-type-options": "nosniff",
-                    "cache-control": "private, max-age=31536000, immutable",
-                },
-            });
-        },
-        // The run actions.
-        [`POST /control/sessions/${SESSION_SEGMENT}/actions`]: async (req, _url, session) => {
-            const read = await readJson(req);
-            if ("error" in read)
-                return read.error;
-            const action = parseWireAction(read.value);
-            if (!action) {
-                return json({
-                    ok: false,
-                    error: { code: INVALID_COMMAND_CODE, message: "malformed action", retryable: false },
-                });
-            }
-            const s = control.sessions.get(session);
-            // The result rides HTTP 200 either way: `ok: false` is a protocol-level answer (rejected before acceptance),
-            // not a transport failure.
-            switch (action.type) {
-                case "steer":
-                    return json(await s.steer(action.prompt));
-                case "follow_up":
-                    return json(await s.followUp(action.prompt));
-                case "abort":
-                    return json(await s.abort());
-                case "compact":
-                    return json(await s.compact(action.instructions !== undefined ? { instructions: action.instructions } : {}));
-            }
-        },
-        [`GET /control/sessions/${SESSION_SEGMENT}/events`]: (_req, _url, session) => {
-            let seq = 0;
-            return sseResponse(control.sessions.get(session).events(), (event) => ({
-                sessionId: session,
-                epoch,
-                seq: seq++,
-                event,
-            }));
-        },
-    };
-}

package/dist/channels/define-channel.d.ts

@@ -1,39 +0,0 @@
-/**
- * `defineChannel` — a channel file's authoring surface, and the third member of the `defineX` family
- * (with `defineTool` / `defineRoutine`). Its whole job is the secrets: a channel is the one code
- * input that is ALL credentials (a bot token, a signing secret), and before this it read them from
- * `process.env` at module scope, which meant a CUSTOM channel could not tell `deploy` what to carry —
- * the deploy could only guess from a table of first-party names.
- *
- * The declaration attaches to the module WITHOUT adding a third module form to the Channel contract
- * (channel.ts §7 fixes two: a function is a route channel, an object with `connect` is a long
- * connection). The builder runs at import and returns one of those two; the declared names ride along
- * as a property that the discovery reads and everything else ignores.
- *
- * Values are read at import, so a rotated credential needs a restart — the same lifetime an adapter
- * configured with a literal already has, and the reason there is no per-request accessor here.
- *
- * KNOWN GAP: every declared name is REQUIRED (the gate refuses an empty value), so an
- * OPTIONAL credential has no expression here — declare it and an agent that does not use it cannot
- * start; leave it out and `deploy` does not carry it. First-party channels have the third answer in
- * the scaffold table (`ChannelEnv.required`), which is why feishu/lark still read their optional
- * `*_ENCRYPT_KEY` from the environment. Closing it means a second entry shape here
- * (`{ name, required: false }`) carried through `DeclaredSecret`, `missingSecrets` and the deploy
- * runbook's required flag — a contract change, not a local one.
- */
-import type { ChannelModule, LongConnectionChannelModule } from "../channel.ts";
-/** A channel module carrying what it declared it needs. Read by discovery; ignored by the server. */
-type DeclaringChannelModule<M> = M & {
-    secrets?: readonly string[];
-};
-export interface DefineChannelOptions<S extends readonly string[], M> {
-    /**
-     * Env vars this channel needs (`["TELEGRAM_BOT_TOKEN"]`), typed into `channel`. `deploy` carries
-     * them to the host and `dev`/`start` refuse to serve while one is unset, naming this file.
-     */
-    secrets?: S;
-    /** Build the channel from those values — usually one call to an adapter (`telegramChannel({...})`). */
-    channel: (secrets: Record<S[number], string>) => M;
-}
-export declare function defineChannel<const S extends readonly string[] = readonly [], M extends ChannelModule | LongConnectionChannelModule = ChannelModule>(options: DefineChannelOptions<S, M>): DeclaringChannelModule<M>;
-export {};

package/dist/channels/define-channel.js

@@ -1,9 +0,0 @@
-import { secretValues } from "../declared-secrets.js";
-// `S` defaults to the EMPTY tuple for the same reason as `defineTool`: a channel that declares
-// nothing must not type-check `secrets.ANYTHING`.
-export function defineChannel(options) {
-    const built = options.channel(secretValues(options.secrets));
-    // Object.assign on a FUNCTION module keeps it a function (the route-channel form); on the
-    // long-connection object it adds one field. Either way the shape the server sees is unchanged.
-    return Object.assign(built, options.secrets ? { secrets: options.secrets } : {});
-}

package/dist/channels/feishu/context-buffer.d.ts

@@ -1,35 +0,0 @@
-/** Feishu/Lark's half of the shared context buffer (mechanics + consume protocol: ../kit/context-buffer.ts). */
-import { type ContextBuffer } from "../kit/context-buffer.ts";
-import type { NormalizedFeishuMessage } from "./model.ts";
-export interface FeishuBufferedResource {
-    messageId: string;
-    key: string;
-    name?: string;
-}
-export interface FeishuBufferEntry {
-    sender: string;
-    body: string;
-    messageId: string;
-    replyTo?: string;
-    files?: FeishuBufferedResource[];
-    images?: FeishuBufferedResource[];
-}
-/** A background resource carried into a later turn, with attribution for its prompt manifest. */
-export interface FeishuBufferedRef extends FeishuBufferedResource {
-    from: string;
-}
-/** The place a message belongs to: the main chat, or a thread within it. */
-export declare function feishuBufferPlaceKey(conversation: Pick<NormalizedFeishuMessage["conversation"], "chatId" | "threadId">): string;
-/** One-line, bounded background text. */
-export declare function feishuBufferText(text: string): string;
-/** Select the most recent background resources, excluding resources already primary on this turn. */
-export declare function collectFeishuBufferedAttachments(consumed: FeishuBufferEntry[], primary: {
-    files: FeishuBufferedResource[];
-    images: FeishuBufferedResource[];
-}): {
-    files: FeishuBufferedRef[];
-    images: FeishuBufferedRef[];
-    skipped: number;
-};
-export type FeishuContextBuffer = ContextBuffer<FeishuBufferEntry>;
-export declare function createFeishuContextBuffer(path: string, label: string): FeishuContextBuffer;

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

@@ -1,65 +0,0 @@
-/** Feishu/Lark's half of the shared context buffer (mechanics + consume protocol: ../kit/context-buffer.ts). */
-import { capBufferedRefs, BUFFER_LINE_MAX_CHARS, createContextBuffer as createGenericContextBuffer, } from "../kit/context-buffer.js";
-import { truncateCodePointPrefix } from "../kit/text.js";
-function bufferLine(entry) {
-    const meta = [`msg ${entry.messageId}`, entry.replyTo ? `reply to msg ${entry.replyTo}` : undefined]
-        .filter(Boolean)
-        .join(", ");
-    return `${entry.sender} (${meta}): ${entry.body}`;
-}
-/** The place a message belongs to: the main chat, or a thread within it. */
-export function feishuBufferPlaceKey(conversation) {
-    return conversation.threadId ? `${conversation.chatId}:thread:${conversation.threadId}` : conversation.chatId;
-}
-/** One-line, bounded background text. */
-export function feishuBufferText(text) {
-    return truncateCodePointPrefix(text.replace(/\s+/g, " ").trim(), BUFFER_LINE_MAX_CHARS);
-}
-function resourceIdentity(resource) {
-    return `${resource.messageId}\u0000${resource.key}`;
-}
-/** Select the most recent background resources, excluding resources already primary on this turn. */
-export function collectFeishuBufferedAttachments(consumed, primary) {
-    const refs = (pick, primaryRefs) => {
-        const excluded = new Set(primaryRefs.map(resourceIdentity));
-        const seen = new Set();
-        const out = [];
-        for (const entry of consumed) {
-            for (const resource of pick(entry) ?? []) {
-                const identity = resourceIdentity(resource);
-                if (excluded.has(identity) || seen.has(identity))
-                    continue;
-                seen.add(identity);
-                out.push({ ...resource, from: entry.sender });
-            }
-        }
-        return out;
-    };
-    const files = capBufferedRefs(refs((entry) => entry.files, primary.files));
-    const images = capBufferedRefs(refs((entry) => entry.images, primary.images));
-    return { files: files.kept, images: images.kept, skipped: files.skipped + images.skipped };
-}
-function isResource(value) {
-    const resource = value;
-    return (typeof resource?.messageId === "string" &&
-        typeof resource.key === "string" &&
-        (resource.name === undefined || typeof resource.name === "string"));
-}
-function isEntry(value) {
-    const entry = value;
-    const resources = (candidate) => candidate === undefined || (Array.isArray(candidate) && candidate.every(isResource));
-    return (typeof entry?.sender === "string" &&
-        typeof entry.body === "string" &&
-        typeof entry.messageId === "string" &&
-        (entry.replyTo === undefined || typeof entry.replyTo === "string") &&
-        resources(entry.files) &&
-        resources(entry.images));
-}
-export function createFeishuContextBuffer(path, label) {
-    return createGenericContextBuffer({
-        path,
-        label,
-        isEntry,
-        line: bufferLine,
-    });
-}

package/dist/channels/feishu/scaffold/channel.websocket.ts

@@ -1,31 +0,0 @@
-import { feishuWebSocketChannel } from "@fastagent-sh/fastagent/feishu";
-import { defineChannel } from "@fastagent-sh/fastagent";
-
-// Feishu WebSocket long connection: the process connects OUT to the platform, so no public URL,
-// Verification Token, Encrypt Key, or --tunnel is needed. In Events & Callbacks choose long
-// connection, subscribe im.message.receive_v1, then publish the app version. Keep one process
-// running in production: scale-to-zero/App Sleeping would disconnect ingress.
-export default defineChannel({
-  // The env vars this channel needs. fastagent carries them to a deployed box and refuses to serve
-  // while one is unset — a bare process.env read gets neither guarantee.
-  secrets: ["FEISHU_APP_ID", "FEISHU_APP_SECRET"],
-  channel: (secrets) =>
-    feishuWebSocketChannel({
-      appId: secrets.FEISHU_APP_ID,
-      appSecret: secrets.FEISHU_APP_SECRET,
-      // No session modes: a chat is one session and a thread is another, and where the answer goes follows
-      // from that (docs/design/participant-model.md).
-      // Dev/personal bot: surface raw errors to the chat so you (and your AI agent) can act on them. The
-      // chat is customer-facing by default — for a public bot, drop this or return a neutral string;
-      // full details always go to the server log regardless.
-      onError: (failed) => `⚠️ ${failed.details}`,
-      // The channel owns transport + format (markdown card) + attachments (image→vision, file→disk) +
-      // the live streaming preview. `route` (POLICY) is OPTIONAL — omitted, it uses defaultFeishuRoute:
-      // p2p chats always answer; groups answer on @this-bot, plus bare messages in a thread where the
-      // Agent takes part and exactly ONE human does. Other human group/thread discussion buffers until
-      // that place's next answered turn; @other-only messages buffer rather than triggering the Agent.
-      // Override to customise explicit routing, reusing the export:
-      //   route: (e) => defaultFeishuRoute(e, { botOpenId: "ou_xxx" }) && { session: `user:${e.sender?.sender_id?.open_id}` },
-      //   route: (e) => defaultFeishuRoute(e, { botOpenId: "ou_xxx" }) && { text: `${feishuEnvelope(e)}\n[extra]` },
-    }),
-});

package/dist/channels/http.d.ts

@@ -1,23 +0,0 @@
-/**
- * HTTP/SSE channel: fan one invoke stream out to Server-Sent Events. The web stream primitives supply cancellation
- * natively (consumer disconnect → `cancel()` → `iterator.return()` → invoke cancellation, SPEC MUST 3), backpressure,
- * and the body cap.
- */
-import type { Agent } from "../agent.ts";
-/**
- * Request body cap (1 MiB) — shared by every Prompt-bearing wire surface (the control plane's dispatch imports it), so
- * the two caps cannot drift apart.
- */
-export declare const MAX_BODY_BYTES: number;
-/**
- * A valid example request body for the invoke handler — lives HERE, next to the shape check it must satisfy, so the
- * CLI's "try it" hint can't drift from the protocol.
- */
-export declare const INVOKE_EXAMPLE_BODY = "{\"session\":\"dev\",\"text\":\"hello\"}";
-/**
- * Fetch-shaped invoke handler.
- *
- * No CORS here: who may call this from a browser is decided once, before dispatch, in `channels/serve.ts`'s router
- * — which is also the only layer that can answer the `OPTIONS` preflight, since this route registers only `POST`.
- */
-export declare function createInvokeHandler(agent: Agent): (req: Request) => Promise<Response>;

package/dist/channels/http.js

@@ -1,57 +0,0 @@
-import { readBodyCapped, refuseNonJsonBody } from "./body.js";
-import { text } from "./respond.js";
-import { sseResponse } from "./sse.js";
-/**
- * Request body cap (1 MiB) — shared by every Prompt-bearing wire surface (the control plane's dispatch imports it), so
- * the two caps cannot drift apart.
- */
-export const MAX_BODY_BYTES = 1 << 20;
-/**
- * A valid example request body for the invoke handler — lives HERE, next to the shape check it must satisfy, so the
- * CLI's "try it" hint can't drift from the protocol.
- */
-export const INVOKE_EXAMPLE_BODY = '{"session":"dev","text":"hello"}';
-/**
- * Fetch-shaped invoke handler.
- *
- * No CORS here: who may call this from a browser is decided once, before dispatch, in `channels/serve.ts`'s router
- * — which is also the only layer that can answer the `OPTIONS` preflight, since this route registers only `POST`.
- */
-export function createInvokeHandler(agent) {
-    return async (req) => {
-        if (req.method !== "POST")
-            return text("POST only\n", 405);
-        // Also applied by the host router over every unguarded route — kept HERE too because this handler is a
-        // PUBLIC standalone artifact (docs/overview.md mounts it as a Next.js route), and a handler you can mount
-        // anywhere has to be safe anywhere. The router's copy is what stops a route added later from forgetting.
-        const wrongType = refuseNonJsonBody(req);
-        if (wrongType)
-            return wrongType;
-        const body = await readBodyCapped(req, MAX_BODY_BYTES);
-        if ("tooLarge" in body)
-            return text("body too large\n", 413);
-        let payload;
-        try {
-            payload = JSON.parse(body.text);
-        }
-        catch {
-            return text("invalid json\n", 400);
-        }
-        const { session, text: promptText, parentSession, branchHints, } = (payload ?? {});
-        if (typeof session !== "string" || typeof promptText !== "string") {
-            return text('need { "session": string, "text": string }\n', 400);
-        }
-        // INVOKE_EXAMPLE_BODY must keep satisfying this request shape.
-        if (parentSession !== undefined && typeof parentSession !== "string") {
-            return text('"parentSession" must be a string\n', 400);
-        }
-        if (branchHints !== undefined && !(Array.isArray(branchHints) && branchHints.every((h) => typeof h === "string"))) {
-            return text('"branchHints" must be an array of strings\n', 400);
-        }
-        return sseResponse(agent.invoke({
-            session,
-            ...(parentSession !== undefined ? { parentSession } : {}),
-            ...(branchHints !== undefined ? { branchHints } : {}),
-        }, { text: promptText }));
-    };
-}

package/dist/channels/lark/scaffold/channel.websocket.ts

@@ -1,31 +0,0 @@
-import { larkWebSocketChannel } from "@fastagent-sh/fastagent/lark";
-import { defineChannel } from "@fastagent-sh/fastagent";
-
-// Lark WebSocket long connection: the process connects OUT to the platform, so no public URL,
-// Verification Token, Encrypt Key, or --tunnel is needed. In Events & Callbacks choose long
-// connection, subscribe im.message.receive_v1, then publish the app version. Keep one process
-// running in production: scale-to-zero/App Sleeping would disconnect ingress.
-export default defineChannel({
-  // The env vars this channel needs. fastagent carries them to a deployed box and refuses to serve
-  // while one is unset — a bare process.env read gets neither guarantee.
-  secrets: ["LARK_APP_ID", "LARK_APP_SECRET"],
-  channel: (secrets) =>
-    larkWebSocketChannel({
-      appId: secrets.LARK_APP_ID,
-      appSecret: secrets.LARK_APP_SECRET,
-      // No session modes: a chat is one session and a thread is another, and where the answer goes follows
-      // from that (docs/design/participant-model.md).
-      // Dev/personal bot: surface raw errors to the chat so you (and your AI agent) can act on them. The
-      // chat is customer-facing by default — for a public bot, drop this or return a neutral string;
-      // full details always go to the server log regardless.
-      onError: (failed) => `⚠️ ${failed.details}`,
-      // The channel owns transport + format (markdown card) + attachments (image→vision, file→disk) +
-      // the live streaming preview. `route` (POLICY) is OPTIONAL — omitted, it uses defaultLarkRoute:
-      // p2p chats always answer; groups answer on @this-bot, plus bare messages in a thread where the
-      // Agent takes part and exactly ONE human does. Other human group/thread discussion buffers until
-      // that place's next answered turn; @other-only messages buffer rather than triggering the Agent.
-      // Override to customise explicit routing, reusing the export:
-      //   route: (e) => defaultLarkRoute(e, { botOpenId: "ou_xxx" }) && { session: `user:${e.sender?.sender_id?.open_id}` },
-      //   route: (e) => defaultLarkRoute(e, { botOpenId: "ou_xxx" }) && { text: `${larkEnvelope(e)}\n[extra]` },
-    }),
-});

package/dist/channels/slack/context-buffer.d.ts

@@ -1,23 +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 { type ContextBuffer } from "../kit/context-buffer.ts";
-export interface SlackBufferEntry {
-    sender: string;
-    body: string;
-    messageId: string;
-    replyTo?: string;
-    fileIds?: string[];
-}
-export interface SlackBufferedFileRef {
-    id: string;
-    from: string;
-    messageId: string;
-}
-export declare function collectSlackBufferedFiles(consumed: SlackBufferEntry[], primaryIds: Set<string>): {
-    files: SlackBufferedFileRef[];
-    skipped: number;
-};
-export type SlackContextBuffer = ContextBuffer<SlackBufferEntry>;
-export declare function createSlackContextBuffer(path: string, label: string): SlackContextBuffer;