experimental-ash 0.25.2 → 0.26.0

package/dist/src/cli/run.js

@@ -1,3 +1,3 @@
-import{D as e,n as t}from"../chunks/paths-DnlVBqHu.js";import{createCliTheme as n,renderCliTaggedLine as r}from"./ui/output.js";import{i,n as a,r as o,t as s}from"../chunks/url-JdCGA634.js";async function c(){return(await import(`../chunks/host-F-DkwYJK.js`).then(e=>e.t)).buildApplication}async function l(){return(await import(`./commands/info.js`)).printApplicationInfo}async function u(){return(await import(`./dev/repl.js`)).runDevelopmentRepl}async function d(){return(await import(`../evals/cli/eval.js`)).runEvalCommand}async function f(){return(await import(`../chunks/host-F-DkwYJK.js`).then(e=>e.t)).startDevelopmentServer}function p(e){return e.name()===`info`||e.name()===`dev`}async function m(e){await new Promise((t,n)=>{let r=!1,i=()=>{process.off(`SIGINT`,a),process.off(`SIGTERM`,a)},a=()=>{r||(r=!0,i(),e.close().then(t,n))};process.once(`SIGINT`,a),process.once(`SIGTERM`,a)})}function h(e){if(!/^-?\d+$/.test(e))throw new i(`Expected a numeric port, received "${e}".`);let t=Number(e);if(t<0||t>65535)throw new i(`Expected a port between 0 and 65535, received "${e}".`);return t}function g(){return!!(process.stdin.isTTY&&process.stdout.isTTY)}function _(e){let t=e[1];return e[0]!==`dev`||e.length!==2||t===void 0||t.startsWith(`-`)?[...e]:[`dev`,`--url`,t]}function v(e){if(e.url){if(e.host!==void 0)throw new i(`The --host option cannot be used with --url.`);if(e.port!==void 0)throw new i(`The --port option cannot be used with --url.`);if(e.repl===!1)throw new i(`The --no-repl option cannot be used with --url.`);return e.url}}function y(i,o){let _=t(),y=e().version,b=new a,x=n();return b.name(`ash`).description(`Build and run an Ash application.`).version(y).showHelpAfterError().exitOverride().hook(`preAction`,(e,t)=>{p(t)&&i.log(`Ash (v${y})`)}).configureOutput({writeErr:e=>{i.error(e.trimEnd())},writeOut:e=>{i.log(e.trimEnd())}}),b.command(`build`).description(`Build the current Ash application.`).action(async()=>{let{loadDevelopmentEnvironmentFiles:e}=await import(`./dev/environment.js`);e(_);let t=await(o.buildHost??await c())(_);i.log(r(x,{message:`built output at ${t}`,tag:`build`,tone:`success`}))}),b.command(`dev`).description(`Start the Ash development server or connect the REPL to an existing URL.`).option(`--host <host>`,`Host interface to bind`).option(`--no-repl`,`Start the server without the interactive REPL`).option(`--port <port>`,`Port to listen on (defaults to $PORT, then 3000)`,h).option(`--schedules`,`Run scheduled tasks during development (off by default)`).option(`-u, --url <url>`,`Connect the REPL to an existing server URL`,s).addHelpText(`after`,`
+import{D as e,n as t}from"../chunks/paths-CWZN-XRX.js";import{createCliTheme as n,renderCliTaggedLine as r}from"./ui/output.js";import{i,n as a,r as o,t as s}from"../chunks/url-JdCGA634.js";async function c(){return(await import(`../chunks/host-CwAcCrg7.js`).then(e=>e.t)).buildApplication}async function l(){return(await import(`./commands/info.js`)).printApplicationInfo}async function u(){return(await import(`./dev/repl.js`)).runDevelopmentRepl}async function d(){return(await import(`../evals/cli/eval.js`)).runEvalCommand}async function f(){return(await import(`../chunks/host-CwAcCrg7.js`).then(e=>e.t)).startDevelopmentServer}function p(e){return e.name()===`info`||e.name()===`dev`}async function m(e){await new Promise((t,n)=>{let r=!1,i=()=>{process.off(`SIGINT`,a),process.off(`SIGTERM`,a)},a=()=>{r||(r=!0,i(),e.close().then(t,n))};process.once(`SIGINT`,a),process.once(`SIGTERM`,a)})}function h(e){if(!/^-?\d+$/.test(e))throw new i(`Expected a numeric port, received "${e}".`);let t=Number(e);if(t<0||t>65535)throw new i(`Expected a port between 0 and 65535, received "${e}".`);return t}function g(){return!!(process.stdin.isTTY&&process.stdout.isTTY)}function _(e){let t=e[1];return e[0]!==`dev`||e.length!==2||t===void 0||t.startsWith(`-`)?[...e]:[`dev`,`--url`,t]}function v(e){if(e.url){if(e.host!==void 0)throw new i(`The --host option cannot be used with --url.`);if(e.port!==void 0)throw new i(`The --port option cannot be used with --url.`);if(e.repl===!1)throw new i(`The --no-repl option cannot be used with --url.`);return e.url}}function y(i,o){let _=t(),y=e().version,b=new a,x=n();b.name(`ash`).description(`Build and run an Ash application.`).version(y).showHelpAfterError().exitOverride().hook(`preAction`,(e,t)=>{p(t)&&i.log(`Ash (v${y})`)}).configureOutput({writeErr:e=>{i.error(e.trimEnd())},writeOut:e=>{i.log(e.trimEnd())}});let S=b.command(`channels`).description(`Manage user-authored channels in the current project.`);return S.command(`add [kind]`).description(`Scaffold a channel (slack) into the current project.`).option(`-f, --force`,`Overwrite existing channel files`).action(async(e,t)=>{let{runChannelsAddCommand:n}=await import(`./commands/channels.js`);await n(i,_,{kind:e,options:t})}),S.command(`list`).description(`List user-authored channels in the current project.`).option(`--json`,`Output as JSON`).action(async e=>{let{runChannelsListCommand:t}=await import(`./commands/channels.js`);await t(i,_,e)}),b.command(`build`).description(`Build the current Ash application.`).action(async()=>{let{loadDevelopmentEnvironmentFiles:e}=await import(`./dev/environment.js`);e(_);let t=await(o.buildHost??await c())(_);i.log(r(x,{message:`built output at ${t}`,tag:`build`,tone:`success`}))}),b.command(`dev`).description(`Start the Ash development server or connect the REPL to an existing URL.`).option(`--host <host>`,`Host interface to bind`).option(`--no-repl`,`Start the server without the interactive REPL`).option(`--port <port>`,`Port to listen on (defaults to $PORT, then 3000)`,h).option(`--schedules`,`Run scheduled tasks during development (off by default)`).option(`-u, --url <url>`,`Connect the REPL to an existing server URL`,s).addHelpText(`after`,`
 You can also pass a bare URL as the only argument, for example: ash dev https://example.com
 `).action(async e=>{let t=v(e),{loadDevelopmentEnvironmentFiles:n}=await import(`./dev/environment.js`);if(n(_),t){if(i.log(r(x,{message:`REPL connecting to ${t}`,tag:`dev`,tone:`info`})),!g()){i.log(r(x,{message:`Interactive REPL disabled because the current terminal is not a TTY.`,tag:`dev`,tone:`warning`}));return}i.log(``),await(o.runDevelopmentRepl??await u())({serverUrl:t});return}let a=await(o.startHost??await f())(_,{host:e.host,port:e.port,schedules:e.schedules===!0}),s=!1,c=async()=>{s||(s=!0,await a.close())};try{if(i.log(r(x,{message:`server listening at ${a.url}`,tag:`dev`,tone:`success`})),e.repl===!1)return await m({close:c});if(!g())return i.log(r(x,{message:`Interactive REPL disabled because the current terminal is not a TTY.`,tag:`dev`,tone:`warning`})),await m({close:c});i.log(``),await(o.runDevelopmentRepl??await u())({serverUrl:a.url})}finally{await c()}}),b.command(`info`).description(`Print resolved application information.`).action(async()=>{await(o.printApplicationInfo??await l())(i,_)}),b.command(`eval`).description(`Run eval suites against an Ash agent.`).option(`--suite <id...>`,`Suite IDs to run (repeatable)`).option(`--all`,`Run all discovered suites`).option(`--url <url>`,`Remote agent URL (skip local host startup)`).option(`--timeout <ms>`,`Per-case timeout in milliseconds`).option(`--max-concurrency <n>`,`Max concurrent case executions per suite`).option(`--json`,`Output results as JSON`).option(`--skip-report`,`Skip suite-defined reporters (e.g. Braintrust)`).action(async e=>{await(o.runEvalCommand??await d())(e,i)}),b}async function b(e=process.argv.slice(2),t=console,n={}){let r=y(t,n),i=e.length===0?[`info`]:_(e);try{await r.parseAsync(i,{from:`user`})}catch(e){if(e instanceof o){if(e.exitCode===0)return;throw Error(e.message)}throw e}}export{b as runCli};

package/dist/src/evals/cli/eval.js

@@ -1 +1 @@
-import{n as e}from"../../chunks/paths-DnlVBqHu.js";import{loadDevelopmentEnvironmentFiles as t}from"../../cli/dev/environment.js";import{n,s as r,t as i}from"../../chunks/client-ZqNLLMZB.js";import{n as a}from"../../chunks/host-F-DkwYJK.js";import{discoverAndImportSuites as o}from"../runner/discover.js";import{executeSuite as s}from"../runner/execute-suite.js";import{ConsoleReporter as c}from"../runner/reporters/console.js";var l=r();async function u(n,r){let i=e();t(i);let c=n.suite,l=await o(i,c);if(l.length===0){c&&c.length>0?r.error(`No suites found matching: ${c.join(`, `)}`):r.error(`No eval suites found. Create suite files under evals/ with the *.eval.ts extension.`),process.exitCode=1;return}let u,f;n.url?f={kind:`remote`,url:n.url}:(u=await a(i,{host:`127.0.0.1`,port:0}),f={kind:`local`,url:u.url});let p=d(f);try{let e=[];for(let t of l){let r=m(t,n),a=h(r,{json:n.json===!0,skipReport:n.skipReport===!0}),o=await s({suite:r,target:f,reporters:a,appRoot:i,client:p});e.push(o)}n.json&&r.log(JSON.stringify(e,null,2)),e.some(e=>e.errored>0)&&(process.exitCode=1)}finally{u&&await u.close()}process.exit(process.exitCode??0)}function d(e){if(e.kind===`local`)return new i({host:e.url});let t={},r=process.env.VERCEL_AUTOMATION_BYPASS_SECRET?.trim();return r&&(t[n]=r),new i({auth:f(),headers:Object.keys(t).length>0?t:void 0,host:e.url})}function f(){let e=process.env.ASH_EVAL_AUTH_TOKEN?.trim();return e?{bearer:e}:{bearer:p}}async function p(){try{let e=(await(0,l.getVercelOidcToken)()).trim();if(e.length>0)return e}catch{}return process.env.VERCEL_OIDC_TOKEN?.trim()??``}function m(e,t){let n=t.maxConcurrency?Number.parseInt(t.maxConcurrency,10):void 0,r=t.timeout?Number.parseInt(t.timeout,10):void 0;if(n===void 0&&r===void 0)return e;let i={...e};return n!==void 0&&(i.maxConcurrency=n),r!==void 0&&(i.timeoutMs=r),i}function h(e,t){let n=t.json?[]:[new c];return!t.skipReport&&e.reporters&&n.push(...e.reporters),n}export{u as runEvalCommand};
+import{n as e}from"../../chunks/paths-CWZN-XRX.js";import{loadDevelopmentEnvironmentFiles as t}from"../../cli/dev/environment.js";import{n,s as r,t as i}from"../../chunks/client-ZqNLLMZB.js";import{n as a}from"../../chunks/host-CwAcCrg7.js";import{discoverAndImportSuites as o}from"../runner/discover.js";import{executeSuite as s}from"../runner/execute-suite.js";import{ConsoleReporter as c}from"../runner/reporters/console.js";var l=r();async function u(n,r){let i=e();t(i);let c=n.suite,l=await o(i,c);if(l.length===0){c&&c.length>0?r.error(`No suites found matching: ${c.join(`, `)}`):r.error(`No eval suites found. Create suite files under evals/ with the *.eval.ts extension.`),process.exitCode=1;return}let u,f;n.url?f={kind:`remote`,url:n.url}:(u=await a(i,{host:`127.0.0.1`,port:0}),f={kind:`local`,url:u.url});let p=d(f);try{let e=[];for(let t of l){let r=m(t,n),a=h(r,{json:n.json===!0,skipReport:n.skipReport===!0}),o=await s({suite:r,target:f,reporters:a,appRoot:i,client:p});e.push(o)}n.json&&r.log(JSON.stringify(e,null,2)),e.some(e=>e.errored>0)&&(process.exitCode=1)}finally{u&&await u.close()}process.exit(process.exitCode??0)}function d(e){if(e.kind===`local`)return new i({host:e.url});let t={},r=process.env.VERCEL_AUTOMATION_BYPASS_SECRET?.trim();return r&&(t[n]=r),new i({auth:f(),headers:Object.keys(t).length>0?t:void 0,host:e.url})}function f(){let e=process.env.ASH_EVAL_AUTH_TOKEN?.trim();return e?{bearer:e}:{bearer:p}}async function p(){try{let e=(await(0,l.getVercelOidcToken)()).trim();if(e.length>0)return e}catch{}return process.env.VERCEL_OIDC_TOKEN?.trim()??``}function m(e,t){let n=t.maxConcurrency?Number.parseInt(t.maxConcurrency,10):void 0,r=t.timeout?Number.parseInt(t.timeout,10):void 0;if(n===void 0&&r===void 0)return e;let i={...e};return n!==void 0&&(i.maxConcurrency=n),r!==void 0&&(i.timeoutMs=r),i}function h(e,t){let n=t.json?[]:[new c];return!t.skipReport&&e.reporters&&n.push(...e.reporters),n}export{u as runEvalCommand};

package/dist/src/internal/application/package.js

@@ -6,7 +6,7 @@ import { ASH_PACKAGE_NAME } from "#internal/package-name.js";
 let cachedPackageInfo;
 // The package build stamps the published version into `dist` so bundled
 // deployments can still report package metadata without resolving package.json.
-const BUNDLED_FALLBACK_PACKAGE_VERSION = "0.25.2";
+const BUNDLED_FALLBACK_PACKAGE_VERSION = "0.26.0";
 const BUNDLED_FALLBACK_PACKAGE_VERSION_PLACEHOLDER = "__ASH_PACKAGE_VERSION_PLACEHOLDER__";
 const WORKFLOW_MODULE_ALIASES = {
     "workflow/api": "src/compiled/@workflow/core/runtime.js",

package/dist/src/internal/process/pnpm.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Resolved invocation for the host's pnpm executable. The shape carries
+ * everything `child_process.spawn` and `execFile` need to dispatch to the
+ * right binary across macOS/Linux PATH installs, Corepack-managed shims,
+ * and Windows runners that surface pnpm only through `PNPM_HOME`.
+ */
+export interface PnpmInvocation {
+    readonly args: readonly string[];
+    readonly command: string;
+    readonly shell?: boolean;
+}
+/**
+ * Picks the right pnpm executable for the current host. Resolution order:
+ *
+ *  1. `PNPM_HOME` — the standard install location used by Corepack and the
+ *     pnpm installers. On Windows, points at `pnpm.CMD` because the bare
+ *     `pnpm` shim is not directly invokable from a non-shell spawn.
+ *  2. `npm_execpath` — set when the current process was launched by an
+ *     npm-compatible package manager. Pointing at a `.cjs`/`.js` entry
+ *     means we have to run it through `node` (typical for Corepack
+ *     shims); otherwise treat it as a bare executable path.
+ *  3. Bare `pnpm` on PATH — the macOS/Linux happy path.
+ *
+ * Pure: no side effects, returns the invocation shape; the caller picks
+ * `spawn` vs. `execFile`. The test harness uses this to keep platform
+ * handling in one place.
+ */
+export declare function resolvePnpmInvocation(args: readonly string[]): PnpmInvocation;

package/dist/src/internal/process/pnpm.js

@@ -0,0 +1,50 @@
+import { existsSync } from "node:fs";
+import { extname, join } from "node:path";
+/**
+ * Picks the right pnpm executable for the current host. Resolution order:
+ *
+ *  1. `PNPM_HOME` — the standard install location used by Corepack and the
+ *     pnpm installers. On Windows, points at `pnpm.CMD` because the bare
+ *     `pnpm` shim is not directly invokable from a non-shell spawn.
+ *  2. `npm_execpath` — set when the current process was launched by an
+ *     npm-compatible package manager. Pointing at a `.cjs`/`.js` entry
+ *     means we have to run it through `node` (typical for Corepack
+ *     shims); otherwise treat it as a bare executable path.
+ *  3. Bare `pnpm` on PATH — the macOS/Linux happy path.
+ *
+ * Pure: no side effects, returns the invocation shape; the caller picks
+ * `spawn` vs. `execFile`. The test harness uses this to keep platform
+ * handling in one place.
+ */
+export function resolvePnpmInvocation(args) {
+    const pnpmHome = process.env.PNPM_HOME;
+    if (pnpmHome !== undefined) {
+        const command = join(pnpmHome, process.platform === "win32" ? "pnpm.CMD" : "pnpm");
+        if (existsSync(command)) {
+            return {
+                args,
+                command,
+                shell: process.platform === "win32",
+            };
+        }
+    }
+    const npmExecPath = process.env.npm_execpath;
+    if (npmExecPath !== undefined && npmExecPath.toLowerCase().includes("pnpm")) {
+        const extension = extname(npmExecPath).toLowerCase();
+        if (extension === ".cjs" || extension === ".js") {
+            return {
+                args: [npmExecPath, ...args],
+                command: process.execPath,
+            };
+        }
+        return {
+            args,
+            command: npmExecPath,
+            shell: process.platform === "win32",
+        };
+    }
+    return {
+        args,
+        command: "pnpm",
+    };
+}

package/dist/src/public/channels/discord/api.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Minimal Discord REST API wrapper used by the Discord channel.
+ *
+ * The channel talks directly to Discord's JSON HTTP API instead of
+ * exposing a third-party SDK through Ash public surfaces.
+ */
+import { type JsonObject } from "#shared/json.js";
+import { resolveDiscordPublicKey, type DiscordPublicKey } from "#public/channels/discord/verify.js";
+/** Discord application id, materialized directly or from an async secret provider. */
+export type DiscordApplicationId = string | (() => string | Promise<string>);
+/** Discord bot token, materialized directly or from an async secret provider. */
+export type DiscordBotToken = string | (() => string | Promise<string>);
+/** Fetch implementation override used by tests or non-standard runtimes. */
+export type DiscordFetch = typeof fetch;
+/** Credentials used by the native Discord channel. */
+export interface DiscordCredentials {
+    readonly applicationId?: DiscordApplicationId;
+    readonly botToken?: DiscordBotToken;
+    readonly publicKey?: DiscordPublicKey;
+}
+/** Shared Discord API options. */
+export interface DiscordApiOptions {
+    readonly apiBaseUrl?: string;
+    readonly credentials?: DiscordCredentials;
+    readonly fetch?: DiscordFetch;
+}
+/** Raw Discord API response body. */
+export interface DiscordApiResponse {
+    readonly status: number;
+    readonly ok: boolean;
+    readonly body: unknown;
+}
+/** Minimal Discord message object returned by channel write operations. */
+export interface DiscordPostedMessage {
+    /** Discord message id, when Discord returned one. */
+    readonly id: string;
+    /** Channel id associated with the message, when Discord returned one. */
+    readonly channelId?: string;
+    /** Discord's raw JSON response. */
+    readonly raw: unknown;
+}
+/** Allowed mentions payload that suppresses all generated pings. */
+export declare const DISCORD_NO_MENTIONS: JsonObject;
+/** Discord's documented message-content cap. */
+export declare const DISCORD_MESSAGE_CONTENT_MAX_LENGTH = 2000;
+/** Builds the channel-local continuation token (`<channelId>:<conversationId>`). */
+export declare function discordContinuationToken(channelId: string, conversationId: string | undefined): string;
+/** Resolves a Discord application id, falling back to `DISCORD_APPLICATION_ID`. */
+export declare function resolveDiscordApplicationId(applicationId?: DiscordApplicationId): Promise<string>;
+/** Resolves a Discord bot token, falling back to `DISCORD_BOT_TOKEN`. */
+export declare function resolveDiscordBotToken(botToken?: DiscordBotToken): Promise<string>;
+/** Resolves a Discord public key, falling back to `DISCORD_PUBLIC_KEY`. */
+export { resolveDiscordPublicKey };
+/**
+ * Low-level Discord JSON API call. Bot-token auth is included only when
+ * a token is supplied; interaction webhook endpoints intentionally run
+ * without bot auth.
+ */
+export declare function callDiscordApi(input: {
+    readonly apiBaseUrl?: string;
+    readonly body?: JsonObject;
+    readonly botToken?: DiscordBotToken;
+    readonly fetch?: DiscordFetch;
+    readonly method?: "DELETE" | "GET" | "PATCH" | "POST" | "PUT";
+    readonly path: string;
+}): Promise<DiscordApiResponse>;
+/** Sends a bot-authenticated message to one Discord channel. */
+export declare function sendDiscordChannelMessage(input: DiscordApiOptions & {
+    readonly body: DiscordMessageBody;
+    readonly channelId: string;
+}): Promise<DiscordPostedMessage>;
+/** Triggers Discord's short-lived channel typing indicator with bot auth. */
+export declare function triggerDiscordTypingIndicator(input: DiscordApiOptions & {
+    readonly channelId: string;
+}): Promise<void>;
+/** Edits the original response for a deferred Discord interaction. */
+export declare function editDiscordOriginalResponse(input: DiscordApiOptions & {
+    readonly body: DiscordMessageBody;
+    readonly interactionToken: string;
+}): Promise<DiscordPostedMessage>;
+/** Creates a Discord interaction followup message. */
+export declare function createDiscordFollowupMessage(input: DiscordApiOptions & {
+    readonly body: DiscordMessageBody;
+    readonly interactionToken: string;
+}): Promise<DiscordPostedMessage>;
+/** JSON body supported by Discord message endpoints used by Ash. */
+export interface DiscordMessageBody {
+    readonly allowed_mentions?: Readonly<Record<string, unknown>>;
+    readonly components?: readonly Readonly<Record<string, unknown>>[];
+    readonly content?: string;
+    readonly flags?: number;
+    readonly tts?: boolean;
+}
+/**
+ * Splits text into chunks Discord will accept as individual message
+ * contents. Empty strings produce one empty chunk so callers can still
+ * decide how to handle a no-content message.
+ */
+export declare function splitDiscordMessageContent(content: string): readonly string[];

package/dist/src/public/channels/discord/api.js

@@ -0,0 +1,167 @@
+/**
+ * Minimal Discord REST API wrapper used by the Discord channel.
+ *
+ * The channel talks directly to Discord's JSON HTTP API instead of
+ * exposing a third-party SDK through Ash public surfaces.
+ */
+import { parseJsonObject } from "#shared/json.js";
+import { isObject } from "#shared/guards.js";
+import { resolveDiscordPublicKey } from "#public/channels/discord/verify.js";
+/** Allowed mentions payload that suppresses all generated pings. */
+export const DISCORD_NO_MENTIONS = { parse: [] };
+/** Discord's documented message-content cap. */
+export const DISCORD_MESSAGE_CONTENT_MAX_LENGTH = 2000;
+/** Builds the channel-local continuation token (`<channelId>:<conversationId>`). */
+export function discordContinuationToken(channelId, conversationId) {
+    return `${channelId}:${conversationId ?? ""}`;
+}
+/** Resolves a Discord application id, falling back to `DISCORD_APPLICATION_ID`. */
+export async function resolveDiscordApplicationId(applicationId) {
+    const source = applicationId ?? process.env.DISCORD_APPLICATION_ID;
+    if (!source)
+        throw new Error("DISCORD_APPLICATION_ID is required.");
+    return typeof source === "function" ? await source() : source;
+}
+/** Resolves a Discord bot token, falling back to `DISCORD_BOT_TOKEN`. */
+export async function resolveDiscordBotToken(botToken) {
+    const source = botToken ?? process.env.DISCORD_BOT_TOKEN;
+    if (!source)
+        throw new Error("DISCORD_BOT_TOKEN is required.");
+    return typeof source === "function" ? await source() : source;
+}
+/** Resolves a Discord public key, falling back to `DISCORD_PUBLIC_KEY`. */
+export { resolveDiscordPublicKey };
+/**
+ * Low-level Discord JSON API call. Bot-token auth is included only when
+ * a token is supplied; interaction webhook endpoints intentionally run
+ * without bot auth.
+ */
+export async function callDiscordApi(input) {
+    const apiFetch = input.fetch ?? fetch;
+    const headers = new Headers();
+    headers.set("content-type", "application/json; charset=utf-8");
+    if (input.botToken !== undefined) {
+        const token = await resolveDiscordBotToken(input.botToken);
+        headers.set("authorization", `Bot ${token}`);
+    }
+    const init = {
+        headers,
+        method: input.method ?? "POST",
+    };
+    if (input.body !== undefined) {
+        init.body = JSON.stringify(parseJsonObject(input.body));
+    }
+    const response = await apiFetch(`${input.apiBaseUrl ?? "https://discord.com/api/v10"}${input.path}`, init);
+    return {
+        body: await parseResponseBody(response),
+        ok: response.ok,
+        status: response.status,
+    };
+}
+/** Sends a bot-authenticated message to one Discord channel. */
+export async function sendDiscordChannelMessage(input) {
+    const response = await callDiscordApi({
+        apiBaseUrl: input.apiBaseUrl,
+        body: normalizeMessageBody(input.body),
+        botToken: input.credentials?.botToken,
+        fetch: input.fetch,
+        path: `/channels/${encodeURIComponent(input.channelId)}/messages`,
+    });
+    if (!response.ok) {
+        throw new Error(`Discord create message failed with HTTP ${response.status}.`);
+    }
+    return toPostedMessage(response.body);
+}
+/** Triggers Discord's short-lived channel typing indicator with bot auth. */
+export async function triggerDiscordTypingIndicator(input) {
+    const response = await callDiscordApi({
+        apiBaseUrl: input.apiBaseUrl,
+        botToken: input.credentials?.botToken,
+        fetch: input.fetch,
+        path: `/channels/${encodeURIComponent(input.channelId)}/typing`,
+    });
+    if (!response.ok) {
+        throw new Error(`Discord typing indicator failed with HTTP ${response.status}.`);
+    }
+}
+/** Edits the original response for a deferred Discord interaction. */
+export async function editDiscordOriginalResponse(input) {
+    const applicationId = await resolveDiscordApplicationId(input.credentials?.applicationId);
+    const response = await callDiscordApi({
+        apiBaseUrl: input.apiBaseUrl,
+        body: normalizeMessageBody(input.body),
+        fetch: input.fetch,
+        method: "PATCH",
+        path: `/webhooks/${encodeURIComponent(applicationId)}/${encodeURIComponent(input.interactionToken)}/messages/@original`,
+    });
+    if (!response.ok) {
+        throw new Error(`Discord edit original response failed with HTTP ${response.status}.`);
+    }
+    return toPostedMessage(response.body);
+}
+/** Creates a Discord interaction followup message. */
+export async function createDiscordFollowupMessage(input) {
+    const applicationId = await resolveDiscordApplicationId(input.credentials?.applicationId);
+    const response = await callDiscordApi({
+        apiBaseUrl: input.apiBaseUrl,
+        body: normalizeMessageBody(input.body),
+        fetch: input.fetch,
+        path: `/webhooks/${encodeURIComponent(applicationId)}/${encodeURIComponent(input.interactionToken)}`,
+    });
+    if (!response.ok) {
+        throw new Error(`Discord followup message failed with HTTP ${response.status}.`);
+    }
+    return toPostedMessage(response.body);
+}
+/**
+ * Splits text into chunks Discord will accept as individual message
+ * contents. Empty strings produce one empty chunk so callers can still
+ * decide how to handle a no-content message.
+ */
+export function splitDiscordMessageContent(content) {
+    if (content.length <= DISCORD_MESSAGE_CONTENT_MAX_LENGTH)
+        return [content];
+    const chunks = [];
+    let rest = content;
+    while (rest.length > DISCORD_MESSAGE_CONTENT_MAX_LENGTH) {
+        let cut = rest.lastIndexOf("\n", DISCORD_MESSAGE_CONTENT_MAX_LENGTH);
+        if (cut <= 0) {
+            cut = rest.lastIndexOf(" ", DISCORD_MESSAGE_CONTENT_MAX_LENGTH);
+        }
+        if (cut <= 0)
+            cut = DISCORD_MESSAGE_CONTENT_MAX_LENGTH;
+        chunks.push(rest.slice(0, cut).trimEnd());
+        rest = rest.slice(cut).trimStart();
+    }
+    chunks.push(rest);
+    return chunks;
+}
+function normalizeMessageBody(body) {
+    const normalized = { ...body };
+    if (normalized.allowed_mentions === undefined) {
+        normalized.allowed_mentions = DISCORD_NO_MENTIONS;
+    }
+    return parseJsonObject(normalized);
+}
+function toPostedMessage(body) {
+    const raw = parseMaybeObject(body);
+    return {
+        channelId: typeof raw.channel_id === "string" ? raw.channel_id : undefined,
+        id: typeof raw.id === "string" ? raw.id : "",
+        raw: body,
+    };
+}
+function parseMaybeObject(value) {
+    return isObject(value) ? value : {};
+}
+async function parseResponseBody(response) {
+    const text = await response.text();
+    if (!text)
+        return null;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}

package/dist/src/public/channels/discord/defaults.d.ts

@@ -0,0 +1,9 @@
+import type { SessionAuthContext } from "#channel/types.js";
+import type { DiscordCommandInteraction } from "#public/channels/discord/inbound.js";
+import type { DiscordChannelEvents, DiscordCommandResult, DiscordContext } from "#public/channels/discord/discordChannel.js";
+/** Default auth projection for Discord interaction actors. */
+export declare function defaultDiscordAuth(interaction: DiscordCommandInteraction): SessionAuthContext;
+/** Default command hook: dispatch with Discord user auth. */
+export declare function defaultOnCommand(_ctx: DiscordContext, interaction: DiscordCommandInteraction): DiscordCommandResult;
+/** Built-in Discord event handlers for typing, replies, HITL, and terminal errors. */
+export declare const defaultEvents: DiscordChannelEvents;

package/dist/src/public/channels/discord/defaults.js

@@ -0,0 +1,74 @@
+import { extractErrorId, formatErrorHint } from "#internal/logging.js";
+import { splitDiscordMessageContent } from "#public/channels/discord/api.js";
+import { renderInputRequestComponents } from "#public/channels/discord/hitl.js";
+/** Default auth projection for Discord interaction actors. */
+export function defaultDiscordAuth(interaction) {
+    const attributes = {
+        channel_id: interaction.channelId,
+        interaction_id: interaction.id,
+        user_id: interaction.user.id,
+        username: interaction.user.username,
+    };
+    if (interaction.guildId !== undefined)
+        attributes.guild_id = interaction.guildId;
+    if (interaction.member?.nick !== undefined)
+        attributes.member_nick = interaction.member.nick;
+    const issuer = interaction.guildId ? `discord:${interaction.guildId}` : "discord";
+    const principalId = interaction.guildId
+        ? `discord:${interaction.guildId}:${interaction.user.id}`
+        : `discord:${interaction.user.id}`;
+    return {
+        attributes,
+        authenticator: "discord-interaction",
+        issuer,
+        principalId,
+        principalType: interaction.user.isBot ? "service" : "user",
+    };
+}
+/** Default command hook: dispatch with Discord user auth. */
+export function defaultOnCommand(_ctx, interaction) {
+    return { auth: defaultDiscordAuth(interaction) };
+}
+/** Built-in Discord event handlers for typing, replies, HITL, and terminal errors. */
+export const defaultEvents = {
+    async "turn.started"(_event, ctx) {
+        await ctx.discord.startTyping();
+    },
+    async "actions.requested"(_event, ctx) {
+        await ctx.discord.startTyping();
+    },
+    async "input.requested"(event, ctx) {
+        for (const request of event.requests) {
+            const content = splitDiscordMessageContent(request.prompt)[0] ?? request.prompt;
+            await ctx.discord.post({
+                components: renderInputRequestComponents(request),
+                content,
+            });
+        }
+    },
+    async "message.completed"(event, ctx) {
+        if (event.finishReason === "tool-calls" || !event.message)
+            return;
+        await ctx.discord.post(event.message);
+    },
+    async "session.failed"(event, ctx) {
+        const hint = formatErrorHint(event);
+        const errorId = extractErrorId(event.details);
+        await ctx.discord.post([
+            `This session could not recover from an error${hint}.`,
+            "",
+            "Start a new command to continue.",
+            ...(errorId ? ["", `Error id: ${errorId}`] : []),
+        ].join("\n"));
+    },
+    async "turn.failed"(event, ctx) {
+        const hint = formatErrorHint(event);
+        const errorId = extractErrorId(event.details);
+        await ctx.discord.post([
+            `I hit an error while handling your request${hint}.`,
+            "",
+            "Please try again, rephrase, or reach out if it keeps failing.",
+            ...(errorId ? ["", `Error id: ${errorId}`] : []),
+        ].join("\n"));
+    },
+};

package/dist/src/public/channels/discord/discordChannel.d.ts

@@ -0,0 +1,132 @@
+import type { ModelMessage } from "ai";
+import type { TypedReceiveRoute } from "#channel/receive-args.js";
+import type { SessionHandle } from "#channel/session.js";
+import type { SessionAuthContext } from "#channel/types.js";
+import type { HandleMessageStreamEvent } from "#protocol/message.js";
+import { type DiscordApiOptions, type DiscordApiResponse, type DiscordCredentials, type DiscordMessageBody, type DiscordPostedMessage } from "#public/channels/discord/api.js";
+import { type DiscordCommandInteraction } from "#public/channels/discord/inbound.js";
+import { type DiscordWebhookVerifier } from "#public/channels/discord/verify.js";
+import { type JsonObject } from "#shared/json.js";
+import { type Channel } from "#public/definitions/defineChannel.js";
+type EventData<T extends HandleMessageStreamEvent["type"]> = Extract<HandleMessageStreamEvent, {
+    type: T;
+}> extends {
+    data: infer D;
+} ? D : undefined;
+/** Pre-dispatch Discord context passed to inbound command hooks. */
+export interface DiscordContext {
+    readonly discord: DiscordHandle;
+}
+/** Event-handler Discord context, including mutable per-conversation state. */
+export interface DiscordEventContext extends DiscordContext {
+    readonly session: SessionHandle;
+    state: DiscordChannelState;
+}
+/** JSON-serializable Discord channel state. */
+export interface DiscordChannelState {
+    /** Discord channel id. */
+    channelId: string | null;
+    /** Discord message id once anchored, or an interaction placeholder before the first reply. */
+    conversationId: string | null;
+    /** Discord guild id, when the interaction was invoked in a guild. */
+    guildId: string | null;
+    /** Discord application id from the inbound interaction. */
+    applicationId: string | null;
+    /** Latest interaction token available to the channel. */
+    interactionToken: string | null;
+    /** Whether the deferred original interaction response has already been edited. */
+    initialResponseSent: boolean;
+    /** Whether `conversationId` is a real Discord message id. */
+    hasMessageAnchor: boolean;
+}
+/** Discord channel credentials. */
+export interface DiscordChannelCredentials extends DiscordCredentials {
+    /**
+     * Custom inbound webhook verifier. When supplied, Ash skips the
+     * `DISCORD_PUBLIC_KEY` fallback and delegates verification to this
+     * function.
+     */
+    readonly webhookVerifier?: DiscordWebhookVerifier;
+}
+/** Arguments accepted by `receive(discord, args)` for proactive sessions. */
+export interface DiscordReceiveArgs {
+    readonly channelId: string;
+    readonly conversationId?: string;
+    readonly initialMessage?: string | DiscordMessageBody;
+}
+/** Result of an inbound Discord command hook. Return `null` to acknowledge without dispatching. */
+export type DiscordCommandResult = {
+    readonly auth: SessionAuthContext | null;
+    readonly ephemeral?: boolean;
+    readonly modelContext?: readonly ModelMessage[];
+} | null;
+/** Sync or async {@link DiscordCommandResult}. */
+export type DiscordCommandResultOrPromise = DiscordCommandResult | Promise<DiscordCommandResult>;
+type DiscordEventHandler<T extends HandleMessageStreamEvent["type"]> = (data: EventData<T>, ctx: DiscordEventContext) => void | Promise<void>;
+/** Event handlers supported by `discordChannel({ events })`. */
+export interface DiscordChannelEvents {
+    readonly "turn.started"?: DiscordEventHandler<"turn.started">;
+    readonly "actions.requested"?: DiscordEventHandler<"actions.requested">;
+    readonly "action.result"?: DiscordEventHandler<"action.result">;
+    readonly "message.completed"?: DiscordEventHandler<"message.completed">;
+    readonly "message.appended"?: DiscordEventHandler<"message.appended">;
+    readonly "input.requested"?: DiscordEventHandler<"input.requested">;
+    readonly "turn.failed"?: DiscordEventHandler<"turn.failed">;
+    readonly "turn.completed"?: DiscordEventHandler<"turn.completed">;
+    readonly "session.failed"?: DiscordEventHandler<"session.failed">;
+    readonly "session.completed"?: DiscordEventHandler<"session.completed">;
+    readonly "session.waiting"?: DiscordEventHandler<"session.waiting">;
+    readonly "connection.authorization_required"?: DiscordEventHandler<"connection.authorization_required">;
+    readonly "connection.authorization_pending"?: DiscordEventHandler<"connection.authorization_pending">;
+    readonly "connection.authorization_completed"?: DiscordEventHandler<"connection.authorization_completed">;
+}
+/** Configuration for {@link discordChannel}. */
+export interface DiscordChannelConfig {
+    readonly api?: Omit<DiscordApiOptions, "credentials">;
+    readonly credentials?: DiscordChannelCredentials;
+    /** Override the default interaction route path (`/ash/v1/discord`). */
+    readonly route?: string;
+    /**
+     * Inbound command hook. Defaults to user-scoped Discord auth and dispatch.
+     * Return `{ auth }` to dispatch, or `null` to acknowledge without running
+     * the agent.
+     */
+    onCommand?(ctx: DiscordContext, interaction: DiscordCommandInteraction): DiscordCommandResultOrPromise;
+    readonly events?: DiscordChannelEvents;
+}
+/** Low-level Discord handle exposed to hooks and event handlers. */
+export interface DiscordHandle {
+    /** Discord application id when known. */
+    readonly applicationId: string | undefined;
+    /** Discord channel id. */
+    readonly channelId: string;
+    /** Current Ash conversation id, usually the Discord anchor message id. */
+    readonly conversationId: string;
+    /** Discord guild id when known. */
+    readonly guildId: string | undefined;
+    /** Latest Discord interaction token when known. */
+    readonly interactionToken: string | undefined;
+    /** Raw Discord API escape hatch. */
+    request(path: string, body: JsonObject, options?: DiscordRequestOptions): Promise<DiscordApiResponse>;
+    /** Posts a message to the current Discord conversation. */
+    post(message: string | DiscordMessageBody): Promise<DiscordPostedMessage>;
+    /** Sends a bot-authenticated message to this Discord channel. */
+    sendChannelMessage(message: string | DiscordMessageBody): Promise<DiscordPostedMessage>;
+    /** Edits the deferred original interaction response. */
+    editOriginalResponse(message: string | DiscordMessageBody): Promise<DiscordPostedMessage>;
+    /** Creates an interaction followup message. */
+    followup(message: string | DiscordMessageBody): Promise<DiscordPostedMessage>;
+    /** Triggers Discord's short-lived typing indicator. Failures are swallowed. */
+    startTyping(): Promise<void>;
+}
+/** Options for {@link DiscordHandle.request}. */
+export interface DiscordRequestOptions {
+    readonly botAuth?: boolean;
+    readonly method?: "DELETE" | "GET" | "PATCH" | "POST" | "PUT";
+}
+/** Concrete return type of {@link discordChannel}. */
+export interface DiscordChannel extends Channel<DiscordChannelState>, TypedReceiveRoute<DiscordReceiveArgs> {
+}
+/** Discord channel factory for HTTP Interactions and proactive channel messages. */
+export declare function discordChannel(config?: DiscordChannelConfig): DiscordChannel;
+export {};