experimental-ash 0.25.2 → 0.27.0

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # experimental-ash
 
+## 0.27.0
+
+### Minor Changes
+
+- df26312: Rebuilt the published package with a single rolldown asset pipeline (oxc-minify under the hood). All shipped JS is now minified and comment-stripped. `picocolors`, `commander`, `chokidar`, `gray-matter`, and `@vercel/oidc` are now vendored under `#compiled/*` rather than relied on as devDependencies. Public API and dist file layout are unchanged; tarball is smaller.
+- 7edf12e: Add remote Ash subagents through `defineRemoteAgent({ url, description, auth, headers, path })`. Remote subagents are authored under `agent/subagents/`, lower to the same `{ message: string }` tool shape as local subagents, start task-mode sessions on another Ash deployment, and resume the caller through the framework callback route. The smoke suite now covers happy-path remote delegation, non-destructive remote start failures, and callee terminal callback retry.
+
+## 0.26.0
+
+### Minor Changes
+
+- 3553354: Add a native Discord channel for HTTP Interactions. The channel verifies Discord Ed25519 signatures, dispatches application commands, supports HITL buttons/selects/modals, sends deferred replies and followups, falls back to bot-token channel messages, supports proactive `receive(...)` sessions, and exposes a best-effort `ctx.discord.startTyping()` helper.
+
 ## 0.25.2
 
 ### Patch Changes

package/bin/ash.d.ts

@@ -5,14 +5,14 @@ export interface BootstrapOptions {
   cliEntrypointPath?: string;
 
   /**
-   * Absolute path to the script that copies static assets after compilation.
+   * Absolute path to the ash package root.
    */
-  copyAssetsScriptPath?: string;
+  packageRoot?: string;
 
   /**
-   * Absolute path to the ash package root.
+   * Absolute paths to scripts that run after workspace bootstrap compilation.
    */
-  packageRoot?: string;
+  postBuildScriptPaths?: readonly string[];
 
   /**
    * Absolute path to the tsgo CLI entrypoint used for bootstrap builds.

package/bin/ash.js

@@ -16,9 +16,11 @@ function createBootstrapOptions(overrides = {}) {
   return {
     cliEntrypointPath:
       overrides.cliEntrypointPath ?? resolve(packageRoot, "dist", "src", "cli", "run.js"),
-    copyAssetsScriptPath:
-      overrides.copyAssetsScriptPath ?? resolve(packageRoot, "scripts", "copy-static-assets.mjs"),
     packageRoot,
+    postBuildScriptPaths: overrides.postBuildScriptPaths ?? [
+      resolve(packageRoot, "scripts", "copy-docs.mjs"),
+      resolve(packageRoot, "scripts", "stamp-version-tokens.mjs"),
+    ],
     tsgoCliPath: overrides.tsgoCliPath,
   };
 }
@@ -85,14 +87,14 @@ async function getLatestBuildInputMtimeMs({ packageRoot }) {
   return latestMtimeMs;
 }
 
-async function canBuildWorkspaceCli({ copyAssetsScriptPath, exists, packageRoot }) {
+async function canBuildWorkspaceCli({ exists, packageRoot, postBuildScriptPaths }) {
   for (const requiredPath of [
     resolve(packageRoot, "bin"),
     inputTsconfigPath({
       packageRoot,
     }),
     resolve(packageRoot, "src"),
-    copyAssetsScriptPath,
+    ...postBuildScriptPaths,
   ]) {
     if (!(await exists(requiredPath))) {
       return false;
@@ -175,9 +177,9 @@ export async function ensureBuiltCli(overrides = {}, dependencies = {}) {
   const getEntrypointMtimeMs = dependencies.getPathMtimeMs ?? getPathMtimeMs;
   const executeCommand = dependencies.runCommand ?? runCommand;
   const packageCanBuildCli = await canBuildWorkspaceCli({
-    copyAssetsScriptPath: options.copyAssetsScriptPath,
     exists,
     packageRoot: options.packageRoot,
+    postBuildScriptPaths: options.postBuildScriptPaths,
   });
 
   if (await exists(options.cliEntrypointPath)) {
@@ -210,9 +212,11 @@ export async function ensureBuiltCli(overrides = {}, dependencies = {}) {
       cwd: options.packageRoot,
     },
   );
-  await executeCommand(process.execPath, [options.copyAssetsScriptPath], {
-    cwd: options.packageRoot,
-  });
+  for (const scriptPath of options.postBuildScriptPaths) {
+    await executeCommand(process.execPath, [scriptPath], {
+      cwd: options.packageRoot,
+    });
+  }
 
   if (await exists(options.cliEntrypointPath)) {
     return options.cliEntrypointPath;

package/dist/docs/public/channels/README.md

@@ -1,6 +1,6 @@
 ---
 title: "Channels"
-description: "Deliver your agent over HTTP, Slack, and custom transports."
+description: "Deliver your agent over HTTP, Slack, Discord, Twilio, and custom transports."
 url: /channels
 ---
 
@@ -23,7 +23,7 @@ Ash ships the public HTTP protocol as channels:
 - `ashChannel({ auth })` for the built-in Ash protocol channel
 
 Ash also supports authored channels under `agent/channels/` for platform-specific integrations such
-as Slack or custom webhooks.
+as Slack, Discord, Twilio, or custom webhooks.
 
 ## Filesystem Shape
 
@@ -232,6 +232,30 @@ dispatch for app mentions, direct messages, and interactions.
 For a Slack app backed by Vercel Connect, see [Slack channel setup](./slack.md) to create the Connect client
 and channel file.
 
+## Discord Channels
+
+Discord channels are authored with `discordChannel()`:
+
+```ts
+import { discordChannel } from "experimental-ash/channels/discord";
+
+export default discordChannel();
+```
+
+The channel verifies Discord's Ed25519 interaction signature headers, accepts HTTP Interactions at
+`/ash/v1/discord`, responds to `PING`, dispatches application commands, and resolves HITL button,
+select, and modal submissions back into Ash input responses. The default command parser uses a
+string option named `message` as the agent prompt and derives auth from the invoking Discord user.
+
+Default delivery edits the original deferred interaction response for the first agent reply, sends
+followups after that, and falls back to bot-token channel messages when the interaction token can no
+longer be used. Proactive `receive(discord, { channelId })` sessions also use bot-token channel
+messages. Default progress handlers trigger Discord's short-lived typing indicator when bot auth is
+available.
+
+See [Discord channel setup](./discord.md) for endpoint setup, environment variables, command
+registration, and overrides.
+
 ## Twilio Channels
 
 Twilio channels are authored with `twilioChannel()`:

package/dist/docs/public/channels/discord.md

@@ -0,0 +1,159 @@
+---
+title: "Discord channel setup"
+description: "Create a Discord-backed Ash channel for HTTP Interactions."
+---
+
+# Discord Channel Setup
+
+The Discord channel accepts HTTP Interactions: slash/application commands, message components, and
+modal submissions. It verifies Discord's Ed25519 signature headers before parsing the request,
+acknowledges commands immediately, and continues Ash work in the background.
+
+## Add The Channel
+
+Create `agent/channels/discord.ts`:
+
+```ts
+import { discordChannel } from "experimental-ash/channels/discord";
+
+export default discordChannel();
+```
+
+Set the credentials Ash needs for inbound verification and outbound replies:
+
+```bash
+DISCORD_PUBLIC_KEY=...
+DISCORD_APPLICATION_ID=...
+DISCORD_BOT_TOKEN=...
+```
+
+- `DISCORD_PUBLIC_KEY` verifies `X-Signature-Ed25519` and `X-Signature-Timestamp`.
+- `DISCORD_APPLICATION_ID` lets Ash edit the original deferred interaction response and send
+  followups.
+- `DISCORD_BOT_TOKEN` lets Ash send proactive channel messages and fall back after an interaction
+  token expires. It also powers best-effort channel typing indicators.
+
+You can also pass the same values in config:
+
+```ts
+export default discordChannel({
+  credentials: {
+    applicationId: "123456789012345678",
+    botToken: process.env.DISCORD_BOT_TOKEN,
+    publicKey: process.env.DISCORD_PUBLIC_KEY,
+  },
+});
+```
+
+By default, the channel mounts `POST /ash/v1/discord`. Paste that public URL into your Discord
+application's **Interactions Endpoint URL**.
+
+## Register A Command
+
+The channel does not register commands for you. Create a command with Discord's application command
+API or the Developer Portal. A simple command with a string option named `message` maps cleanly to
+the default Ash prompt extraction:
+
+```bash
+curl -X PUT \
+  "https://discord.com/api/v10/applications/$DISCORD_APPLICATION_ID/commands" \
+  -H "Authorization: Bot $DISCORD_BOT_TOKEN" \
+  -H "Content-Type: application/json" \
+  -d '[
+    {
+      "name": "ask",
+      "description": "Ask the Ash agent",
+      "type": 1,
+      "options": [
+        {
+          "name": "message",
+          "description": "What should the agent do?",
+          "type": 3,
+          "required": true
+        }
+      ]
+    }
+  ]'
+```
+
+Discord may take time to propagate global command changes. Use guild commands during development if
+you need faster iteration.
+
+## Hooks And Delivery
+
+`onCommand(ctx, interaction)` decides whether to dispatch a command and what auth to use. Return
+`{ auth }` to dispatch or `null` to acknowledge without running the agent. The default derives auth
+from the invoking Discord user.
+
+```ts
+import { discordChannel } from "experimental-ash/channels/discord";
+
+export default discordChannel({
+  onCommand(ctx, interaction) {
+    return {
+      auth: {
+        principalId: interaction.user.id,
+        principalType: "user",
+        authenticator: "discord",
+        attributes: {
+          channel_id: interaction.channelId,
+          guild_id: interaction.guildId ?? "",
+        },
+      },
+    };
+  },
+  events: {
+    "message.completed"(event, ctx) {
+      if (event.finishReason === "tool-calls") return;
+      if (event.message) ctx.discord.post(event.message);
+    },
+  },
+});
+```
+
+The default `"message.completed"` handler edits the original deferred response for the first reply,
+then sends followups. If Discord rejects the interaction-token write, Ash falls back to a
+bot-authenticated channel message. Outbound text is split to Discord's 2000-character content limit,
+and generated messages default to `allowed_mentions: { parse: [] }`.
+
+The default `"turn.started"` and `"actions.requested"` handlers trigger Discord's short-lived
+channel typing indicator when a bot token is available. You can call `ctx.discord.startTyping()` in
+custom hooks or event handlers; failures are logged and swallowed because typing is only a UX hint.
+
+## Human Input
+
+Pending Ash input requests render as Discord components:
+
+- confirmation/options render as buttons;
+- `display: "select"` renders as a string select;
+- freeform questions render a button that opens a Discord modal.
+
+Component and modal submissions resume the parked Ash session automatically.
+
+## Proactive Sessions
+
+Use `receive(discord, args)` from schedules or another channel to start a Discord session:
+
+```ts
+import { defineSchedule, receive } from "experimental-ash/schedules";
+import discord from "../channels/discord.js";
+
+export default defineSchedule({
+  cron: "0 9 * * 1-5",
+  markdown: "Post the daily summary.",
+  channel: receive(discord, {
+    channelId: "123456789012345678",
+    initialMessage: "Daily summary",
+  }),
+});
+```
+
+Proactive delivery requires `DISCORD_BOT_TOKEN` or `credentials.botToken`.
+
+## Discord References
+
+- [Interactions overview](https://docs.discord.com/developers/interactions/overview)
+- [Receiving and responding to interactions](https://docs.discord.com/developers/interactions/receiving-and-responding)
+- [Application commands](https://docs.discord.com/developers/interactions/application-commands)
+- [Create message](https://docs.discord.com/developers/resources/message#create-message)
+- [Trigger typing indicator](https://docs.discord.com/developers/resources/channel#trigger-typing-indicator)

package/dist/docs/public/channels/slack.md

@@ -71,12 +71,24 @@ If you are using an AI coding agent, install the Connect skill first:
 npx skills add https://github.com/vercel/connect --skill vercel-connect
 ```
 
-Then create the Slack client from the project or agent folder that will use it:
+Then create the Slack client from the project or agent folder that will use it, and attach this
+project as the trigger destination so Slack events are forwarded to your deployment:
 
 ```bash
-vercel connect create slack
+vercel connect create slack --triggers
+vercel connect detach <uid> --yes
+vercel connect attach <uid> --triggers --trigger-path /ash/v1/slack --yes
 ```
 
+`--triggers` on `create` is what turns on Slack Event Subscriptions — without it the bot installs
+but Slack never delivers `app_mention` or `message.im` events to the Connect webhook. The create
+step also auto-attaches the linked project at Connect's default trigger path, so detach it before
+attaching the Ash path. `attach --triggers` then registers the currently-linked Vercel project as
+the destination Connect forwards verified webhooks to. The `--trigger-path /ash/v1/slack` value
+must match Ash's Slack channel route; the default Connect trigger path is not served by Ash. These
+commands target your project's production deployment, so make sure you have run
+`vercel deploy --prod` before attaching.
+
 Run Connect commands from the directory containing the agent's `package.json` or `vercel.json`.
 Connect uses that project context to configure project access, webhooks, and triggers. The command
 may open a browser for Slack installation or OAuth consent; finish that flow before continuing.

package/dist/docs/public/subagents.md

@@ -46,6 +46,44 @@ export default defineAgent({
 not declare one — without it, the parent agent has nothing to read when deciding whether to
 delegate.
 
+## Remote Ash Subagents
+
+Use `defineRemoteAgent` when the child agent is another Ash deployment instead of a local directory.
+The file still lives under `agent/subagents/`, so its tool name is still derived from the path.
+
+`agent/subagents/weather.ts`
+
+```ts
+import { defineRemoteAgent } from "experimental-ash";
+import { vercelOidc } from "experimental-ash/agents/auth";
+
+export default defineRemoteAgent({
+  url: "https://weather-agent.example.com",
+  description: "Answers weather, temperature, forecast, wind, rain, and snow questions.",
+  auth: vercelOidc(),
+});
+```
+
+Remote agents use the same lowered `{ message: string }` tool shape as local subagents. The
+difference is dispatch: the parent starts a task-mode session on the remote agent's
+`POST /ash/v1/session`, passes a framework callback URL, parks the parent turn, and resumes when
+the remote agent posts a terminal callback back to the parent. The parent sees the same
+`subagent.called`, `action.result`, and successful `subagent.completed` stream events used by local
+delegation. For remote calls, `subagent.called.data.remote.url` records the target URL.
+
+`defineRemoteAgent` accepts:
+
+- `url` — remote Ash deployment root.
+- `description` — model-visible delegation description.
+- `auth` — optional outbound auth helper from `experimental-ash/agents/auth`.
+- `headers` — optional static or lazy request headers.
+- `path` — optional session-create path; defaults to `/ash/v1/session`.
+
+Remote start failures are returned to the parent as failed tool results, so the caller agent can
+explain or recover from the failure in the same session. Terminal callback delivery runs as a
+durable Workflow step on the callee; callback POST failures are rethrown so Workflow retry policy
+owns redelivery instead of marking the remote task complete.
+
 ## What The Parent Sees
 
 Ash lowers every subagent into a model-visible tool on the parent agent.

package/dist/src/_virtual/_rolldown/runtime.js

@@ -0,0 +1 @@
+import"node:module";var __create=Object.create,__defProp=Object.defineProperty,__getOwnPropDesc=Object.getOwnPropertyDescriptor,__getOwnPropNames=Object.getOwnPropertyNames,__getProtoOf=Object.getPrototypeOf,__hasOwnProp=Object.prototype.hasOwnProperty,__commonJSMin=(e,t)=>()=>(t||(e((t={exports:{}}).exports,t),e=null),t.exports),__exportAll=(e,n)=>{let r={};for(var i in e)__defProp(r,i,{get:e[i],enumerable:!0});return n||__defProp(r,Symbol.toStringTag,{value:`Module`}),r},__copyProps=(e,i,o,s)=>{if(i&&typeof i==`object`||typeof i==`function`)for(var c=__getOwnPropNames(i),l=0,u=c.length,d;l<u;l++)d=c[l],!__hasOwnProp.call(e,d)&&d!==o&&__defProp(e,d,{get:(e=>i[e]).bind(null,d),enumerable:!(s=__getOwnPropDesc(i,d))||s.enumerable});return e},__toESM=(n,r,a)=>(a=n==null?{}:__create(__getProtoOf(n)),__copyProps(r||!n||!n.__esModule?__defProp(a,`default`,{value:n,enumerable:!0}):a,n));import.meta.url;export{__commonJSMin,__exportAll,__toESM};

package/dist/src/channel/adapter-context.js

@@ -1,24 +1 @@
-import { buildSessionHandle } from "#channel/session.js";
-/**
- * Builds the {@link ChannelAdapterContext} the runtime hands to an
- * adapter's `deliver` hook, event handlers, and attachment resolver.
- *
- * Populates `session` with a live {@link SessionHandle} backed by the
- * supplied accessor so handlers can read identity / auth and call
- * `setContinuationToken(...)` to re-key the parked session.
- */
-export function buildAdapterContext(adapter, accessor) {
-    // `adapter.state` is stored loosely (`Record<string, unknown>`)
-    // because it round-trips through JSON at step boundaries. The
-    // adapter is responsible for seeding state in the shape its
-    // `createAdapterContext` / handlers expect, so the cast to the
-    // narrower `TCtx`-derived state is safe at this seam.
-    const baseCtx = {
-        ctx: accessor,
-        state: adapter.state ?? {},
-        session: buildSessionHandle(accessor),
-    };
-    return adapter.createAdapterContext
-        ? adapter.createAdapterContext(baseCtx)
-        : baseCtx;
-}
+import{buildSessionHandle}from"#channel/session.js";function buildAdapterContext(e,t){let n={ctx:t,state:e.state??{},session:buildSessionHandle(t)};return e.createAdapterContext?e.createAdapterContext(n):n}export{buildAdapterContext};

package/dist/src/channel/adapter.js

@@ -1,62 +1 @@
-import { createLogger } from "#internal/logging.js";
-const log = createLogger("channel.adapter");
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-/**
- * Produces the default {@link StepInput} when no custom adapter `deliver`
- * hook is defined.
- *
- * Passes through both `message` and `inputResponses` from the delivery
- * payload so tool-approval responses (and other HITL replies) reach the
- * harness even when the channel has no bespoke deliver logic.
- */
-export function defaultDeliverResult(payload) {
-    if (payload.message !== undefined) {
-        return {
-            inputResponses: payload.inputResponses,
-            message: payload.message,
-            modelContext: payload.modelContext,
-        };
-    }
-    if (payload.inputResponses !== undefined && payload.inputResponses.length > 0) {
-        return {
-            inputResponses: payload.inputResponses,
-            modelContext: payload.modelContext,
-        };
-    }
-    if (payload.modelContext !== undefined && payload.modelContext.length > 0) {
-        return { modelContext: payload.modelContext };
-    }
-    return undefined;
-}
-/**
- * Returns the durable kind for an adapter.
- */
-export function getAdapterKind(adapter) {
-    return adapter.kind;
-}
-/**
- * Calls an adapter's event handler for a given event. Returns the event
- * unchanged (adapters don't transform events — they perform side effects).
- *
- * Throwing handlers are logged and swallowed so a downstream delivery
- * failure does not corrupt the event stream write path.
- */
-export async function callAdapterEventHandler(adapter, event, ctx) {
-    const handler = adapter[event.type];
-    if (handler === undefined) {
-        return event;
-    }
-    try {
-        await handler("data" in event ? event.data : undefined, ctx);
-    }
-    catch (error) {
-        log.error("adapter event handler threw — event swallowed", {
-            adapterKind: getAdapterKind(adapter),
-            eventType: event.type,
-            error,
-        });
-    }
-    return event;
-}
+import{createLogger}from"#internal/logging.js";var log=createLogger(`channel.adapter`);function defaultDeliverResult(e){if(e.message!==void 0)return{inputResponses:e.inputResponses,message:e.message,modelContext:e.modelContext};if(e.inputResponses!==void 0&&e.inputResponses.length>0)return{inputResponses:e.inputResponses,modelContext:e.modelContext};if(e.modelContext!==void 0&&e.modelContext.length>0)return{modelContext:e.modelContext}}function getAdapterKind(e){return e.kind}async function callAdapterEventHandler(e,t,n){let r=e[t.type];if(r===void 0)return t;try{await r(`data`in t?t.data:void 0,n)}catch(n){log.error(`adapter event handler threw — event swallowed`,{adapterKind:getAdapterKind(e),eventType:t.type,error:n})}return t}export{callAdapterEventHandler,defaultDeliverResult,getAdapterKind};

package/dist/src/channel/compiled-channel.js

@@ -1,6 +1 @@
-export const CHANNEL_SENTINEL = "ash:channel";
-export function isCompiledChannel(value) {
-    return (typeof value === "object" &&
-        value !== null &&
-        value.__kind === "ash:channel");
-}
+var CHANNEL_SENTINEL=`ash:channel`;function isCompiledChannel(e){return typeof e==`object`&&!!e&&e.__kind===`ash:channel`}export{CHANNEL_SENTINEL,isCompiledChannel};

package/dist/src/channel/cross-channel-receive.js

@@ -1,108 +1,2 @@
-import { isCompiledChannel } from "#channel/compiled-channel.js";
-import { createSendFn } from "#channel/send.js";
-/**
- * Projects an agent's resolved channels into the receiver-input shape.
- *
- * Framework-internal fetch-only channels carry no `definition` reference
- * and are filtered out at this boundary — only authored channels backed
- * by a `defineChannel` value can be receive targets.
- */
-export function toCrossChannelTargets(channels) {
-    return channels.flatMap((channel) => channel.definition === undefined
-        ? []
-        : [
-            {
-                name: channel.name,
-                definition: channel.definition,
-                receive: channel.receive,
-                adapter: channel.adapter,
-            },
-        ]);
-}
-/**
- * Builds the `args.receive` closure used by every route handler. The
- * closure resolves the target channel by reference identity against
- * the request-scoped channel bundle, then delegates to the target's
- * authored `receive` hook with a per-target `send` factory.
- */
-export function createCrossChannelReceiveFn(runtime, channels) {
-    return async (channel, options) => {
-        const target = resolveTargetByReference(channel, channels);
-        return await invokeChannelReceive({
-            runtime,
-            target,
-            input: {
-                message: options.message,
-                args: (options.args ?? {}),
-                auth: options.auth,
-            },
-            describeMissingReceive: () => `args.receive(): channel "${target.name}" does not implement receive(). ` +
-                `Declare a receive hook on the channel to accept cross-channel sessions.`,
-            describeMissingAdapter: () => `args.receive(): channel "${target.name}" has no adapter — cannot build send().`,
-        });
-    };
-}
-/**
- * Shared `receive(input, { send })` invocation used by both the route-
- * handler cross-channel surface and the schedule dispatcher. Owns the
- * receive/adapter precondition checks and the per-target `send`
- * factory so both call sites stay byte-identical.
- */
-export async function invokeChannelReceive(args) {
-    if (!args.target.receive) {
-        throw new Error(args.describeMissingReceive());
-    }
-    if (!args.target.adapter) {
-        throw new Error(args.describeMissingAdapter());
-    }
-    const send = createSendFn(args.runtime, args.target.adapter, args.target.name);
-    return await args.target.receive(args.input, { send });
-}
-function resolveTargetByReference(ref, channels) {
-    for (const channel of channels) {
-        if (channel.definition === ref) {
-            return channel;
-        }
-    }
-    const structurallyMatchedTarget = resolveTargetByRouteFingerprint(ref, channels);
-    if (structurallyMatchedTarget !== null) {
-        return structurallyMatchedTarget;
-    }
-    throw new Error("args.receive(): the channel passed as the first argument is not registered " +
-        "in this agent's channels/. Import the channel module's default export from " +
-        "agent/channels/<name>.ts and pass that value.");
-}
-function resolveTargetByRouteFingerprint(ref, channels) {
-    if (!isCompiledChannel(ref)) {
-        return null;
-    }
-    const refFingerprint = createRouteFingerprint(ref);
-    if (refFingerprint === null) {
-        return null;
-    }
-    const matches = new Map();
-    for (const channel of channels) {
-        if (createRouteFingerprint(channel.definition) !== refFingerprint) {
-            continue;
-        }
-        matches.set(channel.name, channel);
-    }
-    if (matches.size === 1) {
-        return [...matches.values()][0];
-    }
-    if (matches.size > 1) {
-        throw new Error("args.receive(): the channel passed as the first argument matches multiple " +
-            "registered channels by route shape. Import a channel with a unique route set " +
-            "from agent/channels/<name>.ts before passing it to args.receive().");
-    }
-    return null;
-}
-function createRouteFingerprint(channel) {
-    if (channel.routes.length === 0) {
-        return null;
-    }
-    const routes = channel.routes
-        .map((route) => `${route.method.toUpperCase()} ${route.path}`)
-        .sort();
-    return routes.join("\n");
-}
+import{isCompiledChannel}from"#channel/compiled-channel.js";import{createSendFn}from"#channel/send.js";function toCrossChannelTargets(e){return e.flatMap(e=>e.definition===void 0?[]:[{name:e.name,definition:e.definition,receive:e.receive,adapter:e.adapter}])}function createCrossChannelReceiveFn(e,t){return async(n,r)=>{let i=resolveTargetByReference(n,t);return await invokeChannelReceive({runtime:e,target:i,input:{message:r.message,args:r.args??{},auth:r.auth},describeMissingReceive:()=>`args.receive(): channel "${i.name}" does not implement receive(). Declare a receive hook on the channel to accept cross-channel sessions.`,describeMissingAdapter:()=>`args.receive(): channel "${i.name}" has no adapter — cannot build send().`})}}async function invokeChannelReceive(e){if(!e.target.receive)throw Error(e.describeMissingReceive());if(!e.target.adapter)throw Error(e.describeMissingAdapter());let n=createSendFn(e.runtime,e.target.adapter,e.target.name);return await e.target.receive(e.input,{send:n})}function resolveTargetByReference(e,t){for(let n of t)if(n.definition===e)return n;let n=resolveTargetByRouteFingerprint(e,t);if(n!==null)return n;throw Error(`args.receive(): the channel passed as the first argument is not registered in this agent's channels/. Import the channel module's default export from agent/channels/<name>.ts and pass that value.`)}function resolveTargetByRouteFingerprint(t,n){if(!isCompiledChannel(t))return null;let r=createRouteFingerprint(t);if(r===null)return null;let i=new Map;for(let e of n)createRouteFingerprint(e.definition)===r&&i.set(e.name,e);if(i.size===1)return[...i.values()][0];if(i.size>1)throw Error(`args.receive(): the channel passed as the first argument matches multiple registered channels by route shape. Import a channel with a unique route set from agent/channels/<name>.ts before passing it to args.receive().`);return null}function createRouteFingerprint(e){return e.routes.length===0?null:e.routes.map(e=>`${e.method.toUpperCase()} ${e.path}`).sort().join(`
+`)}export{createCrossChannelReceiveFn,invokeChannelReceive,toCrossChannelTargets};

package/dist/src/channel/http.js

@@ -1,30 +1 @@
-/**
- * Durable adapter kind for the canonical session channel and for every
- * behaviorless user-authored channel returned by the `defineChannel`
- * fast-path (no state, no `context()`, no event handlers, no `fetchFile`).
- *
- * The value is locked at `"http"` because it is persisted into durable
- * workflow state under `serializedContext["ash.channel"].kind` and into
- * sandbox telemetry tags as `channel: "http"`. Renaming the value would
- * break rehydration for every in-flight session started under any prior
- * build with "Unknown adapter kind: \"http\"". The `httpChannel` →
- * `ashChannel` rename (commit `bd3d1b43`) intentionally renamed the
- * channel identifier (file name, function name, framework constant) but
- * deliberately left this adapter kind alone — the kind labels the
- * adapter's transport class, not the channel's name, and the same slot
- * is the rehydration target for every behaviorless authored channel
- * regardless of which protocol it speaks.
- */
-export const HTTP_ADAPTER_KIND = "http";
-/**
- * Framework adapter installed for the canonical session channel and
- * for every behaviorless user-authored channel.
- *
- * Carries no behavior — it is a bare discriminator that the runtime
- * adapter registry uses to rehydrate `{ kind: "http" }` at every
- * workflow step boundary. Registered in `FRAMEWORK_ADAPTERS`
- * (`runtime/channels/registry.ts`).
- */
-export const HTTP_ADAPTER = {
-    kind: HTTP_ADAPTER_KIND,
-};
+var HTTP_ADAPTER_KIND=`http`,HTTP_ADAPTER={kind:HTTP_ADAPTER_KIND};export{HTTP_ADAPTER,HTTP_ADAPTER_KIND};

package/dist/src/channel/receive-args.js

@@ -1 +1 @@
-export {};
+export{};