@fastagent-sh/fastagent 0.18.0 → 0.20.0

package/dist/channels/serve.js

@@ -0,0 +1,243 @@
+/**
+ * How a {@link Routes} table becomes a running server: the path rule, dispatch, the totality
+ * boundary, and the node:http binding.
+ *
+ * Shared ground, not a deployment target — every host in `src/deploy/` runs this same process; what
+ * differs between them is process, storage, credentials and deployment (core.md §1), none of it
+ * here.
+ *
+ * Dispatch is a Map lookup rather than a router because a deployment mounts a handful of LITERAL
+ * paths. A routing library would answer through a pattern language we do not use, and its extra
+ * semantics (decode-before-match, HEAD fallback, wildcard precedence) would have to be predicted by
+ * every collision check.
+ *
+ * The types a channel author or an embedder writes stay pure Fetch — SPEC §11 fixes the gateway
+ * contract as `(Request) => Response`, and an embedding app may already run its own framework.
+ * `overrideGlobalObjects: false` is part of that: the adapter otherwise swaps
+ * `globalThis.Request`/`Response` process-wide, which breaks a channel holding a `Response`
+ * captured before mount (it fails `instanceof` in {@link totalFetch} and is answered 500).
+ *
+ * Post-ACK work (a webhook channel's fire-and-forget turns) runs on this event loop and is lost on
+ * shutdown — the accepted tradeoff until durable execution (the K axis) exists.
+ */
+import { serve, getRequestListener } from "@hono/node-server";
+import { log } from "../log.js";
+import { text } from "./respond.js";
+/** Parse a route key: `"METHOD /path"` → `{ method, path }`, or `"/path"` → `{ path }` (any method).
+ *  An empty method (`" /x"`) parses as `""`, which {@link assertRouteKey} refuses — see there. */
+export function parseRouteKey(key) {
+    const sp = key.indexOf(" ");
+    return sp === -1 ? { path: key } : { method: key.slice(0, sp).toUpperCase(), path: key.slice(sp + 1) };
+}
+/**
+ * A route key is `"METHOD /path"` or `"/path"`, with a literal path.
+ *
+ * Every rule here exists because breaking it costs SOMEONE ELSE. Two keys naming one route, a route
+ * under a mount, a path a URL rewrites (`/a/../x` and `/x` are one route spelled two ways, while
+ * the conflict check compares strings) — in each case a channel goes dark and its author did
+ * nothing wrong.
+ *
+ * Mistakes that only cost their own author a debugging session are NOT policed: `:id` and `*` are
+ * literal path characters here, so such a key simply never matches, and an unusual method is the
+ * same. Refusing those would trade a working capability for a lecture.
+ */
+export function assertRouteKey(key, describe) {
+    const { method, path } = parseRouteKey(key);
+    if (method === "")
+        throw new Error(describe('a leading space is not a method — write "/path" for any method'));
+    if (!path.startsWith("/"))
+        throw new Error(describe('must start with "/"'));
+    // Asked of `URL` rather than by listing what it rewrites (`?`/`#`, `.`/`..`, `\`, `%2e`). A key it
+    // rewrites is unreachable AND compares as a different string, hiding that `/a/../x` and `/x` are
+    // one route.
+    const arrives = new URL(path, "http://x").pathname;
+    if (arrives !== path) {
+        throw new Error(describe(`is not the path a request would carry — that request arrives as "${arrives}"`));
+    }
+}
+/** Do these two keys fight over the same request? Equal paths, and a method each answers; a key
+ *  with no method answers all of them. */
+export function routeKeysConflict(a, b) {
+    const ka = parseRouteKey(a);
+    const kb = parseRouteKey(b);
+    if (ka.path !== kb.path)
+        return false;
+    return ka.method === undefined || kb.method === undefined || ka.method === kb.method;
+}
+/** Same status and headers, no content (RFC 9110's HEAD). The discarded body is cancelled, or a
+ *  streaming producer keeps running with no reader. Shared with the control plane, which answers
+ *  HEAD too. */
+export function withoutBody(res) {
+    void res.body?.cancel().catch(() => { });
+    return new Response(null, { status: res.status, statusText: res.statusText, headers: res.headers });
+}
+/** Is `path` inside `prefix`? Segment-wise, so `/controlled` is not inside `/control`. */
+export function pathUnderPrefix(path, prefix) {
+    return path === prefix || path.startsWith(`${prefix}/`);
+}
+/**
+ * Compose a {@link Routes} table and its {@link PrefixMount}s into one handler.
+ *
+ * Refuses at assembly anything that could not receive a request: a key naming the same route as
+ * another (`"/x"` and `"GET /x"`), a route inside a mount, two mounts claiming the same ground. A
+ * channel must never go dark unannounced.
+ *
+ * 404 and 405 stay distinct: a remote client reads 404 as "this serve predates the route" (version
+ * skew) rather than as a fault.
+ */
+export function router(routes, mounts = []) {
+    for (const [i, mount] of mounts.entries()) {
+        assertRouteKey(mount.prefix, (problem) => `mount prefix "${mount.prefix}" is invalid — ${problem}`);
+        if (mount.prefix === "/") {
+            throw new Error(`mount prefix "/" is invalid — a handler owning every path IS that handler; serve it directly`);
+        }
+        if (mount.prefix.endsWith("/")) {
+            throw new Error(`mount prefix "${mount.prefix}" is invalid — no trailing slash (write "/control")`);
+        }
+        const clash = mounts
+            .slice(0, i)
+            .find((other) => pathUnderPrefix(mount.prefix, other.prefix) || pathUnderPrefix(other.prefix, mount.prefix));
+        if (clash) {
+            throw new Error(`mount "${mount.prefix}" overlaps "${clash.prefix}" — one of them would never receive a request`);
+        }
+    }
+    const byKey = new Map();
+    const paths = new Set();
+    for (const [key, handler] of Object.entries(routes)) {
+        assertRouteKey(key, (problem) => `route "${key}" is not a valid route key — ${problem}`);
+        const { path } = parseRouteKey(key);
+        for (const mount of mounts) {
+            if (pathUnderPrefix(path, mount.prefix)) {
+                throw new Error(`route "${key}" is inside the mount "${mount.prefix}" — it would never receive a request`);
+            }
+        }
+        const shadowed = [...byKey.keys()].find((other) => routeKeysConflict(other, key));
+        if (shadowed) {
+            throw new Error(`route "${key}" conflicts with "${shadowed}" — one of them would never receive a request`);
+        }
+        // Stored normalised: `parseRouteKey` upper-cases the method, so `"get /x"` validates under
+        // `GET` and would otherwise be looked up under a name nothing stores.
+        const { method } = parseRouteKey(key);
+        byKey.set(method ? `${method} ${path}` : path, handler);
+        paths.add(path);
+    }
+    return (req) => {
+        // `URL` normalises the path (`/a/../x` → `/x`) and drops query/fragment.
+        const path = new URL(req.url).pathname;
+        const answer = () => {
+            for (const mount of mounts)
+                if (pathUnderPrefix(path, mount.prefix))
+                    return mount.handler(req);
+            const exact = byKey.get(`${req.method} ${path}`) ?? byKey.get(path);
+            if (exact)
+                return exact(req);
+            if (req.method === "HEAD") {
+                const get = byKey.get(`GET ${path}`);
+                if (get)
+                    return get(req);
+            }
+            return paths.has(path) ? text("method not allowed\n", 405) : text("not found\n", 404);
+        };
+        // ONE exit, so the HEAD rule holds for every reply — a mount's, a route's, the GET fallback's,
+        // and the 404/405 this router writes itself. RFC 9110: HEAD is GET without the content.
+        const res = answer();
+        if (req.method !== "HEAD")
+            return res;
+        return res instanceof Promise ? res.then(withoutBody) : withoutBody(res);
+    };
+}
+/**
+ * The totality boundary every serving path shares. `loadChannels` imports arbitrary author code, so
+ * a channel that throws — or forgets to return — must become a logged 500 rather than escape as an
+ * unhandled rejection. Both `nodeListener` and `serveNode` route through it.
+ *
+ * The message stays internal: an adapter's default error page would echo exception text (a stack, a
+ * path, a key inside an error string) to whoever made the request. Visibility is the LOG's job.
+ */
+function totalFetch(handler) {
+    return async (req) => {
+        try {
+            const response = await handler(req);
+            if (!(response instanceof Response))
+                throw new TypeError("handler did not return a Response");
+            return response;
+        }
+        catch (error) {
+            log.error(`[serve] request failed: ${String(error)}`);
+            return text("internal error\n", 500);
+        }
+    };
+}
+/**
+ * Has upstream middleware already drained the request body?
+ *
+ * Node's `req` is one-shot, so a body parser mounted ahead of this route consumes it — a property of
+ * the Node/Fetch seam, not of this adapter. What is avoidable is the diagnosis: undici answers
+ * `TypeError: Body is unusable`, naming neither the cause nor the fix, and for a webhook channel
+ * that reads as "the integration is broken and the platform keeps retrying".
+ *
+ * Answers only when CERTAIN — a positive `content-length`. `readableEnded` alone is true for any
+ * request something upstream merely touched, and an empty chunked body is legal, arrives drained,
+ * and is indistinguishable from an eaten one. Guessing there rejects valid requests, making this
+ * guard the outage it explains.
+ */
+function bodyAlreadyRead(req) {
+    const length = Number(req.headers["content-length"]);
+    return Number.isFinite(length) && length > 0 && req.readableEnded;
+}
+/** The node:http adapter for a Fetch handler — the embedded server uses it, and an embedder mounting
+ *  fastagent on its OWN node:http server can too.
+ *
+ *  Takes the same {@link ChannelHandler} `serveNode` does, so both doors accept the same thing: a
+ *  handler may answer synchronously, and `router()` returns exactly that. Requiring a Promise here
+ *  made the most natural mount — `nodeListener(router(routes))`, the whole agent on the app's own
+ *  server — a type error. */
+export function nodeListener(handler) {
+    const listener = getRequestListener(totalFetch(handler), { overrideGlobalObjects: false });
+    return (req, res) => {
+        if (bodyAlreadyRead(req)) {
+            log.error(`[serve] ${req.method} ${req.url}: the request body was already read by upstream middleware ` +
+                `(e.g. express.json()) — mount fastagent BEFORE the body parser, or scope the parser away ` +
+                `from this route. Channels that verify webhook signatures need the RAW body.`);
+            res.writeHead(500, { "content-type": "text/plain" });
+            res.end("internal error\n");
+            return;
+        }
+        listener(req, res);
+    };
+}
+/**
+ * Serve `handler` on a Node HTTP server. Thin mechanism: bind, report the port, let the caller stop
+ * accepting or force-close active connections — no logging/signals/exit (the CLI owns those).
+ * `listening` resolves with the bound port (useful for port 0) or rejects on a bind error.
+ * `host` is the bind address; unset means all interfaces (what containers need).
+ */
+export function serveNode(handler, options) {
+    let onListening;
+    let onBindError;
+    const listening = new Promise((resolve, reject) => {
+        onListening = resolve;
+        onBindError = reject;
+    });
+    // serve() types its return as the union of every server it CAN build (incl. http2). We never pass
+    // a createServer/http2 option, so it is always node:http's Server — the one carrying
+    // closeAllConnections, which the caller-owned force-close depends on.
+    const server = serve({
+        fetch: totalFetch(handler),
+        overrideGlobalObjects: false,
+        port: options.port,
+        ...(options.host !== undefined ? { hostname: options.host } : {}),
+    }, (info) => {
+        // Detach before resolving: this listener answers the BIND, and leaving it attached would let
+        // a later runtime error call reject() on a settled promise — swallowed, with nothing raised
+        // anywhere. Detached, an error after bind is an unhandled 'error' event, which is loud.
+        // (Not reachable from a test without forging an event on a server this function does not
+        // expose; the bind-failure half below is covered.)
+        server.off("error", onBindError);
+        onListening(info.port);
+    });
+    server.once("error", onBindError); // a bind failure surfaces here, before "listening"
+    const close = () => new Promise((resolve, reject) => server.close((e) => (e ? reject(e) : resolve())));
+    const closeAllConnections = () => server.closeAllConnections();
+    return { listening, close, closeAllConnections };
+}

package/dist/channels/slack/bot-auth.js

@@ -1,6 +1,6 @@
 /** Rotating Slack bot-token provider backed by owner-only channel state. */
-import { chmodSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
-import { dirname } from "node:path";
+import { readFileSync } from "node:fs";
+import { writeFileAtomic } from "../../atomic-write.js";
 const REFRESH_EARLY_MS = 5 * 60_000;
 const REQUEST_TIMEOUT_MS = 30_000;
 function isState(value) {
@@ -35,18 +35,7 @@ function load(path) {
     }
 }
 function save(path, state) {
-    mkdirSync(dirname(path), { recursive: true });
-    const temp = `${path}.${process.pid}.${Date.now()}.tmp`;
-    try {
-        writeFileSync(temp, JSON.stringify(state), { mode: 0o600 });
-        chmodSync(temp, 0o600);
-        renameSync(temp, path);
-        chmodSync(path, 0o600);
-    }
-    catch (error) {
-        rmSync(temp, { force: true });
-        throw error;
-    }
+    writeFileAtomic(path, JSON.stringify(state), 0o600);
 }
 async function refreshSlackBotToken(input) {
     const authorization = Buffer.from(`${input.clientId}:${input.clientSecret}`, "utf8").toString("base64");

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

@@ -1,9 +1,9 @@
 /**
- * Slack's half of the shared context buffer (mechanics + consume protocol: ../context-buffer.ts):
+ * 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. Durable, bounded
  * unsummoned Slack discussion folded into the next answered turn in the same place.
  */
-import { type ContextBuffer } from "../context-buffer.ts";
+import { type ContextBuffer } from "../kit/context-buffer.ts";
 export interface SlackBufferEntry {
     sender: string;
     body: string;

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

@@ -1,9 +1,9 @@
 /**
- * Slack's half of the shared context buffer (mechanics + consume protocol: ../context-buffer.ts):
+ * 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. Durable, bounded
  * unsummoned Slack discussion folded into the next answered turn in the same place.
  */
-import { BUFFER_ATTACH_MAX, createContextBuffer as createGenericContextBuffer, } from "../context-buffer.js";
+import { BUFFER_ATTACH_MAX, 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)

package/dist/channels/slack/invoke-turn.d.ts

@@ -1,8 +1,8 @@
 /** Resolve Slack file IDs at dequeue, then stream one engine-neutral Agent turn. */
 import type { Agent, AgentEvent } from "../../agent.ts";
-import { type BusyRetry } from "../invoke-turn-kit.ts";
+import { type BusyRetry } from "../kit/invoke-turn-kit.ts";
 import type { SlackBufferedFileRef } from "./context-buffer.ts";
-import type { SlackApi } from "./slack-api.ts";
+import { type SlackApi } from "./slack-api.ts";
 export interface SlackTurnTransport {
     api: SlackApi;
     channelId: string;

package/dist/channels/slack/invoke-turn.js

@@ -1,11 +1,12 @@
 import { log } from "../../log.js";
-import { DEFAULT_BUSY_RETRY, attachedFilesManifest, attributedFileName, backgroundImagesManifest, missingAttachmentsNote, streamTurnWithBusyRetry, } from "../invoke-turn-kit.js";
+import { DEFAULT_BUSY_RETRY, attachedFilesManifest, attributedFileName, backgroundImagesManifest, missingAttachmentsNote, streamTurnWithBusyRetry, } from "../kit/invoke-turn-kit.js";
+import { SlackApiError } from "./slack-api.js";
 const MARKDOWN_INSTRUCTION = "\n\n(Format your reply as standard Markdown. Slack renders it natively. Do not use HTML or Slack control-mention syntax such as <!here>, <!channel>, or <!everyone>.)";
 async function resolveFile(transport, fileId) {
     const info = await transport.api.fileInfo(fileId);
-    return info.mimetype?.toLowerCase().startsWith("image/")
-        ? { image: await transport.api.fetchImage(info) }
-        : { file: await transport.api.fetchFile(info, transport.channelId, transport.filesDir) };
+    if (info.mimetype?.toLowerCase().startsWith("image/"))
+        return { image: await transport.api.fetchImage(info) };
+    return { file: await transport.api.fetchFile(info, transport.channelId, transport.filesDir) };
 }
 async function resolveInputs(transport, attachments) {
     const images = [];
@@ -20,7 +21,10 @@ async function resolveInputs(transport, attachments) {
     const backgroundImages = [];
     const backgroundFiles = [];
     let lost = 0;
-    const results = await Promise.allSettled(attachments.buffered.files.map(async (ref) => ({ ref, resolved: await resolveFile(transport, ref.id) })));
+    const results = await Promise.allSettled(attachments.buffered.files.map(async (ref) => ({
+        ref,
+        resolved: await resolveFile(transport, ref.id),
+    })));
     for (const result of results) {
         if (result.status === "fulfilled") {
             const { ref, resolved } = result.value;
@@ -55,7 +59,10 @@ export async function* invokeSlackTurn(agent, session, text, transport, attachme
         resolved = await resolveInputs(transport, attachments);
     }
     catch (error) {
-        yield { type: "failed", details: `could not load Slack attachment: ${String(error)}`, retryable: true };
+        // transient (network, exhausted 429 retries, Slack 5xx) is worth re-sending; an access or shape
+        // error reads the same every time, and "try again in a moment" is the wrong thing to tell the user
+        const retryable = error instanceof SlackApiError && (error.status === 0 || error.status === 429 || error.status >= 500);
+        yield { type: "failed", details: `could not load Slack attachment: ${String(error)}`, retryable };
         return;
     }
     const prompt = { text: `${text}${resolved.promptSuffix}${MARKDOWN_INSTRUCTION}`, images: resolved.images };

package/dist/channels/slack/onboard.js

@@ -22,7 +22,7 @@ export async function onboardSlackApp(input, io, deps = {}) {
         // Record BEFORE the non-idempotent API call. A transport/internal failure may have created the app;
         // refusing a blind retry is safer than silently producing duplicates.
         state = { ...state, createAttemptedAt: new Date().toISOString() };
-        await writeSlackOnboardingState(input.stateRoot, state);
+        writeSlackOnboardingState(input.stateRoot, state);
         let created;
         try {
             created = await (deps.createApp ?? createSlackApp)(current.token, manifest);
@@ -32,7 +32,7 @@ export async function onboardSlackApp(input, io, deps = {}) {
                 ["fatal_error", "internal_error", "request_timeout", "service_unavailable", "failed_creating_app"].includes(error.code);
             if (!ambiguous) {
                 state = { ...state, createAttemptedAt: undefined };
-                await writeSlackOnboardingState(input.stateRoot, state);
+                writeSlackOnboardingState(input.stateRoot, state);
             }
             throw error;
         }
@@ -45,7 +45,7 @@ export async function onboardSlackApp(input, io, deps = {}) {
             signingSecret: created.signingSecret,
         };
         // Irreversible boundary first: a cancellation or .env write failure can resume without creating a duplicate.
-        await writeSlackOnboardingState(input.stateRoot, state);
+        writeSlackOnboardingState(input.stateRoot, state);
         io.note(`Created Slack app ${created.appId}; credentials captured locally.`);
     }
     else {
@@ -59,7 +59,7 @@ export async function onboardSlackApp(input, io, deps = {}) {
     if (state.signingSecret) {
         await io.writeRuntimeSecrets({ signingSecret: state.signingSecret });
         state = { ...state, signingSecret: undefined };
-        await writeSlackOnboardingState(input.stateRoot, state);
+        writeSlackOnboardingState(input.stateRoot, state);
     }
     if (!state.appId || !state.clientId || !state.clientSecret) {
         throw new Error("Slack onboarding state lost app OAuth credentials before installation");
@@ -104,7 +104,7 @@ export async function onboardSlackApp(input, io, deps = {}) {
         teamName: oauth.teamName,
         installedAt: new Date().toISOString(),
     };
-    await writeSlackOnboardingState(input.stateRoot, state);
+    writeSlackOnboardingState(input.stateRoot, state);
     return state;
 }
 export function newSlackOnboardingState(input) {

package/dist/channels/slack/onboarding-state.d.ts

@@ -18,9 +18,13 @@ export interface SlackOnboardingState {
     teamName?: string;
     installedAt?: string;
 }
-export declare function readSlackOnboardingState(stateRoot: string): Promise<SlackOnboardingState | undefined>;
-/** Atomic replacement with owner-only permissions: this file carries a workspace-wide config refresh token. */
-export declare function writeSlackOnboardingState(stateRoot: string, state: SlackOnboardingState): Promise<void>;
+export declare function readSlackOnboardingState(stateRoot: string): SlackOnboardingState | undefined;
+/** Atomic replacement with owner-only permissions: this file carries a workspace-wide config refresh
+ *  token. Synchronous, through the shared writer, like every other piece of state this repo keeps
+ *  (kit/state.ts): the file is ~1 KB and its writers are `fastagent add slack` and one config-token
+ *  rotation at tunnel startup, so the async spelling bought nothing and cost a fifth set of temp-name
+ *  and permission rules to keep true. */
+export declare function writeSlackOnboardingState(stateRoot: string, state: SlackOnboardingState): void;
 export declare function currentSlackConfigToken(stateRoot: string, state: SlackOnboardingState, options?: {
     now?: number;
     apiBaseUrl?: string;

package/dist/channels/slack/onboarding-state.js

@@ -1,5 +1,6 @@
-import { chmod, mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
-import { dirname, join } from "node:path";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { writeFileAtomic } from "../../atomic-write.js";
 import { rotateSlackConfigToken } from "./config-api.js";
 function slackOnboardingStatePath(stateRoot) {
     return join(stateRoot, "channels", "slack", "onboarding.json");
@@ -15,11 +16,11 @@ function validState(value) {
         typeof state.configRefreshToken === "string" &&
         typeof state.configTokenExpiresAt === "number");
 }
-export async function readSlackOnboardingState(stateRoot) {
+export function readSlackOnboardingState(stateRoot) {
     const file = slackOnboardingStatePath(stateRoot);
     let raw;
     try {
-        raw = await readFile(file, "utf8");
+        raw = readFileSync(file, "utf8");
     }
     catch (error) {
         if (error.code === "ENOENT")
@@ -36,21 +37,13 @@ export async function readSlackOnboardingState(stateRoot) {
         throw new Error(`invalid Slack onboarding state ${file}: ${error.message}`);
     }
 }
-/** Atomic replacement with owner-only permissions: this file carries a workspace-wide config refresh token. */
-export async function writeSlackOnboardingState(stateRoot, state) {
-    const file = slackOnboardingStatePath(stateRoot);
-    await mkdir(dirname(file), { recursive: true });
-    const temp = `${file}.${process.pid}.${Date.now()}.tmp`;
-    try {
-        await writeFile(temp, `${JSON.stringify(state, null, 2)}\n`, { mode: 0o600 });
-        await chmod(temp, 0o600);
-        await rename(temp, file);
-        await chmod(file, 0o600);
-    }
-    catch (error) {
-        await rm(temp, { force: true }).catch(() => { });
-        throw error;
-    }
+/** Atomic replacement with owner-only permissions: this file carries a workspace-wide config refresh
+ *  token. Synchronous, through the shared writer, like every other piece of state this repo keeps
+ *  (kit/state.ts): the file is ~1 KB and its writers are `fastagent add slack` and one config-token
+ *  rotation at tunnel startup, so the async spelling bought nothing and cost a fifth set of temp-name
+ *  and permission rules to keep true. */
+export function writeSlackOnboardingState(stateRoot, state) {
+    writeFileAtomic(slackOnboardingStatePath(stateRoot), `${JSON.stringify(state, null, 2)}\n`, 0o600);
 }
 export async function currentSlackConfigToken(stateRoot, state, options = {}) {
     const now = options.now ?? Date.now();
@@ -64,6 +57,6 @@ export async function currentSlackConfigToken(stateRoot, state, options = {}) {
         configTokenExpiresAt: rotated.expiresAt,
         teamId: state.teamId ?? rotated.teamId,
     };
-    await writeSlackOnboardingState(stateRoot, next);
+    writeSlackOnboardingState(stateRoot, next);
     return { token: next.configToken, state: next };
 }

package/dist/channels/slack/parse.js

@@ -1,5 +1,5 @@
-import { BUFFER_LINE_MAX_CHARS } from "../context-buffer.js";
-import { codePointPrefix, truncateCodePointPrefix } from "../text.js";
+import { BUFFER_LINE_MAX_CHARS } from "../kit/context-buffer.js";
+import { codePointPrefix, truncateCodePointPrefix } from "../kit/text.js";
 const HUMAN_MESSAGE_SUBTYPES = new Set(["file_share", "thread_broadcast"]);
 /**
  * Both forms Slack writes a mention in: `<@U123>` and the labelled `<@U123|name>`. ONE definition,

package/dist/channels/slack/preview.d.ts

@@ -1,6 +1,6 @@
 /** Slack reply rendering: native Agent streams first, rate-safe edited-message compatibility second. */
 import type { AgentEvent } from "../../agent.ts";
-import { type ChannelFailure, defaultErrorMessage } from "../preview-kit.ts";
+import { type ChannelFailure, defaultErrorMessage } from "../kit/preview-kit.ts";
 import { type SlackApi, type SlackTarget } from "./slack-api.ts";
 export type SlackFailure = ChannelFailure;
 export type SlackRendering = "native" | "classic";

package/dist/channels/slack/preview.js

@@ -1,5 +1,5 @@
 import { log } from "../../log.js";
-import { RETRY_NOTICE, THINKING_PLACEHOLDER, applyTurnEvent, composeTurnBody, createTurnView, defaultErrorMessage, humanizeToolName, revealedAnswer, summarizeToolArgs, toolLines, } from "../preview-kit.js";
+import { RETRY_NOTICE, THINKING_PLACEHOLDER, applyTurnEvent, composeTurnBody, createTurnView, defaultErrorMessage, humanizeToolName, revealedAnswer, summarizeToolArgs, toolLines, } from "../kit/preview-kit.js";
 import { chunkSlackMarkdown, chunkSlackText, isSlackNativeUnavailable, } from "./slack-api.js";
 export { defaultErrorMessage };
 const CLASSIC_UPDATE_INTERVAL_MS = 3_000;
@@ -175,7 +175,11 @@ async function streamClassicSlackReply(events, api, target, formatError, initial
             if (event.type === "failed") {
                 await finishPump();
                 finalized = true;
-                const notice = formatError({ details: event.details, retryable: event.retryable }) ?? "";
+                const notice = formatError({
+                    details: event.details,
+                    retryable: event.retryable,
+                    ...(event.code !== undefined ? { code: event.code } : {}),
+                }) ?? "";
                 await finalize(notice).catch((error) => log.error(`${label} failed to deliver the agent-failure notice: ${String(error)}`));
                 throw new Error(`agent failed: ${event.details} (retryable=${event.retryable})`);
             }
@@ -367,7 +371,11 @@ async function streamNativeSlackReply(events, api, target, formatError, initialP
             }
             else if (event.type === "failed") {
                 finalized = true;
-                const notice = formatError({ details: event.details, retryable: event.retryable }) ?? "";
+                const notice = formatError({
+                    details: event.details,
+                    retryable: event.retryable,
+                    ...(event.code !== undefined ? { code: event.code } : {}),
+                }) ?? "";
                 if (notice) {
                     pendingText += `${fullAnswer.trim() ? "\n\n" : ""}${notice}`;
                     fullAnswer += `${fullAnswer.trim() ? "\n\n" : ""}${notice}`;

package/dist/channels/slack/register-webhook.js

@@ -8,7 +8,7 @@ export async function registerSlackWebhook(baseUrl, options) {
     const publicBaseUrl = baseUrl.replace(/\/$/, "");
     let state;
     try {
-        state = await readSlackOnboardingState(options.stateRoot);
+        state = readSlackOnboardingState(options.stateRoot);
     }
     catch (error) {
         note(`[fastagent] slack: cannot read local onboarding state: ${String(error)}`);

package/dist/channels/slack/scaffold/slack-send.ts

@@ -71,22 +71,6 @@ async function callSlack<T extends { ok?: boolean; error?: string }>(
   }
 }
 
-function trustedUploadUrl(value: string): URL {
-  const url = new URL(value);
-  const host = url.hostname.toLowerCase();
-  const slackHost =
-    host === "slack-files.com" ||
-    host.endsWith(".slack-files.com") ||
-    host === "slack.com" ||
-    host.endsWith(".slack.com") ||
-    host === "slack-edge.com" ||
-    host.endsWith(".slack-edge.com");
-  if (url.protocol !== "https:" || !slackHost) {
-    throw new Error(`Slack returned an untrusted upload URL host: ${host}`);
-  }
-  return url;
-}
-
 export default defineTool({
   description:
     "Upload one local file to Slack (`path`), or send a message (`text`) for a turn NO channel is " +
@@ -140,7 +124,8 @@ export default defineTool({
     let byteResponse: Response;
     const handle = await open(filePath, "r");
     try {
-      byteResponse = await fetch(trustedUploadUrl(upload.upload_url), {
+      // where getUploadURLExternal points is Slack's call: these bytes are on their way to Slack either way
+      byteResponse = await fetch(upload.upload_url, {
         method: "POST",
         headers: { "content-type": "application/octet-stream" },
         body: handle.readableWebStream(),