experimental-ash 0.7.6 → 0.8.1

package/dist/src/protocol/routes.d.ts

@@ -8,9 +8,15 @@ export declare const ASH_ROUTE_PREFIX = "/ash/v1";
  */
 export declare const ASH_HEALTH_ROUTE_PATH = "/ash/v1/health";
 /**
- * Stable framework-owned route exposing home-page inspection JSON.
+ * Stable framework-owned route exposing the JSON inspection payload for
+ * the current agent (model id, instructions preview, skills, schedules,
+ * subagents, tools, sandbox, and the runtime's own endpoint catalog).
+ *
+ * Default auth on this route is `vercelOidc()` on Vercel deployments
+ * (with the same-project bypass for in-deployment callers) and `none()`
+ * off Vercel. See `routes/info.ts` for the handler.
  */
-export declare const ASH_HOME_ROUTE_PATH = "/ash/v1/home";
+export declare const ASH_INFO_ROUTE_PATH = "/ash/v1/info";
 /**
  * Stable framework-owned route for creating a new session.
  */
@@ -24,10 +30,6 @@ export declare const ASH_CONTINUE_SESSION_ROUTE_PATTERN = "/ash/v1/session/:sess
  * Stable framework-owned message stream route pattern.
  */
 export declare const ASH_MESSAGE_STREAM_ROUTE_PATTERN = "/ash/v1/session/:sessionId/stream";
-/**
- * Stable framework-owned route prefix for static home-page UI assets.
- */
-export declare const ASH_HOME_PAGE_UI_ROUTE_PREFIX = "/ash/v1/ui";
 /**
  * Stable framework-owned route pattern for receiving inbound IdP redirects
  * during in-turn interactive connection authorization.

package/dist/src/protocol/routes.js

@@ -8,9 +8,15 @@ export const ASH_ROUTE_PREFIX = "/ash/v1";
  */
 export const ASH_HEALTH_ROUTE_PATH = `${ASH_ROUTE_PREFIX}/health`;
 /**
- * Stable framework-owned route exposing home-page inspection JSON.
+ * Stable framework-owned route exposing the JSON inspection payload for
+ * the current agent (model id, instructions preview, skills, schedules,
+ * subagents, tools, sandbox, and the runtime's own endpoint catalog).
+ *
+ * Default auth on this route is `vercelOidc()` on Vercel deployments
+ * (with the same-project bypass for in-deployment callers) and `none()`
+ * off Vercel. See `routes/info.ts` for the handler.
  */
-export const ASH_HOME_ROUTE_PATH = `${ASH_ROUTE_PREFIX}/home`;
+export const ASH_INFO_ROUTE_PATH = `${ASH_ROUTE_PREFIX}/info`;
 /**
  * Stable framework-owned route for creating a new session.
  */
@@ -24,10 +30,6 @@ export const ASH_CONTINUE_SESSION_ROUTE_PATTERN = `${ASH_ROUTE_PREFIX}/session/:
  * Stable framework-owned message stream route pattern.
  */
 export const ASH_MESSAGE_STREAM_ROUTE_PATTERN = `${ASH_ROUTE_PREFIX}/session/:sessionId/stream`;
-/**
- * Stable framework-owned route prefix for static home-page UI assets.
- */
-export const ASH_HOME_PAGE_UI_ROUTE_PREFIX = `${ASH_ROUTE_PREFIX}/ui`;
 /**
  * Stable framework-owned route pattern for receiving inbound IdP redirects
  * during in-turn interactive connection authorization.

package/dist/src/public/channels/ash.d.ts

@@ -5,4 +5,11 @@ export interface AshChannelInput {
     readonly auth: AuthFn<Request>;
     readonly uploadPolicy?: Partial<UploadPolicy>;
 }
-export declare function ashChannel(input: AshChannelInput): Channel;
+/**
+ * Concrete return type of {@link ashChannel}. Named so consumers can
+ * default-export an `ashChannel(...)` call under `declaration: true`
+ * without TypeScript falling back to an internal path for `Channel`.
+ */
+export interface AshChannel extends Channel {
+}
+export declare function ashChannel(input: AshChannelInput): AshChannel;

package/dist/src/public/channels/ash.js

@@ -29,12 +29,7 @@ export function ashChannel(input) {
                 if (policyRejection !== null)
                     return policyRejection;
                 const token = `ash:${crypto.randomUUID()}`;
-                const messageText = typeof body.message === "string"
-                    ? body.message
-                    : body.message
-                        ? JSON.stringify(body.message)
-                        : "";
-                const session = await send(messageText, {
+                const session = await send(body.message, {
                     auth: sessionAuth,
                     continuationToken: token,
                 });

package/dist/src/public/channels/index.d.ts

@@ -1 +1 @@
-export { defineChannel, POST, GET, PUT, DELETE, type AttachmentResolver, type Channel, type ChannelConfig, type ChannelEvents, type Session, type SessionHandle, type RouteDefinition, type RouteHandlerArgs, type SendFn, type SendOptions, type SendPayload, type GetSessionFn, } from "#public/definitions/defineChannel.js";
+export { defineChannel, POST, GET, PUT, DELETE, type Channel, type ChannelConfig, type ChannelEvents, type Session, type SessionHandle, type RouteDefinition, type RouteHandlerArgs, type SendFn, type SendOptions, type SendPayload, type GetSessionFn, } from "#public/definitions/defineChannel.js";

package/dist/src/public/channels/slack/attachments.d.ts

@@ -1,21 +1,16 @@
 import type { FilePart, UserContent } from "ai";
 import type { SlackBotToken } from "#compiled/@chat-adapter/slack/index.js";
 import type { Message } from "#compiled/chat/index.js";
-import type { AttachmentResolver } from "#channel/adapter.js";
+import type { FetchFileResult } from "#channel/adapter.js";
 import type { UploadPolicy } from "#public/channels/upload-policy.js";
-/**
- * Payload an `ash-attachment:` ref carries for Slack file uploads.
- * The Slack resolver reads `params.url` and fetches it with the bot
- * token.
- */
-export interface SlackAttachmentParams {
-    readonly url: string;
-}
 /**
  * Emits one {@link FilePart} per supported attachment in the inbound
- * message, with `data` set to an `ash-attachment:` ref URL. Audio,
- * video, url-less, and policy-violating attachments are dropped so a
- * single bad upload never blocks the text portion of the mention.
+ * message, with `data` set to a `URL` object pointing at the Slack
+ * file. Audio, video, URL-less, and policy-violating attachments are
+ * dropped so a single bad upload never blocks the text portion.
+ *
+ * The `URL` object in `data` is resolved by the channel's `fetchFile`
+ * function at staging time inside the workflow step.
  */
 export declare function collectSlackFileParts(message: Pick<Message, "attachments">, policy: UploadPolicy): FilePart[];
 /**
@@ -25,11 +20,12 @@ export declare function collectSlackFileParts(message: Pick<Message, "attachment
  */
 export declare function buildSlackTurnMessage(text: string, fileParts: readonly FilePart[]): string | UserContent;
 /**
- * Slack-channel {@link AttachmentResolver}: fetches the upstream
- * Slack file URL with the bot token and returns the bytes plus any
- * advertised media-type. Staging writes bytes to the sandbox and
- * rewrites the file part as an `ash-sandbox:` ref.
+ * Creates a `fetchFile` function for the Slack channel.
+ *
+ * Returns `null` for URLs that don't belong to Slack so they pass
+ * through to the model provider unchanged. Fetches Slack file URLs
+ * with the bot token.
  */
-export declare function createSlackAttachmentResolver(input: {
+export declare function createSlackFetchFile(input: {
     readonly botToken?: SlackBotToken;
-}): AttachmentResolver<SlackAttachmentParams>;
+}): (url: string) => Promise<FetchFileResult | null>;

package/dist/src/public/channels/slack/attachments.js

@@ -1,13 +1,14 @@
-import { AshAttachmentError } from "#internal/attachments/errors.js";
-import { encodeAttachmentRef } from "#internal/attachments/refs.js";
 import { createLogger } from "#internal/logging.js";
 import { evaluateFilePart, formatUploadPolicyViolation } from "#public/channels/upload-policy.js";
 const log = createLogger("slack.attachments");
 /**
  * Emits one {@link FilePart} per supported attachment in the inbound
- * message, with `data` set to an `ash-attachment:` ref URL. Audio,
- * video, url-less, and policy-violating attachments are dropped so a
- * single bad upload never blocks the text portion of the mention.
+ * message, with `data` set to a `URL` object pointing at the Slack
+ * file. Audio, video, URL-less, and policy-violating attachments are
+ * dropped so a single bad upload never blocks the text portion.
+ *
+ * The `URL` object in `data` is resolved by the channel's `fetchFile`
+ * function at staging time inside the workflow step.
  */
 export function collectSlackFileParts(message, policy) {
     const parts = [];
@@ -31,7 +32,7 @@ function toSlackFilePart(attachment, index) {
         return null;
     }
     if (!attachment.url) {
-        log.warn("dropped attachment — no url available for ref construction", {
+        log.warn("dropped attachment — no url available", {
             name: attachment.name,
         });
         return null;
@@ -40,10 +41,7 @@ function toSlackFilePart(attachment, index) {
         type: "file",
         mediaType: attachment.mimeType ?? "application/octet-stream",
         filename: attachment.name ?? `attachment-${index}`,
-        data: encodeAttachmentRef({
-            params: { url: attachment.url },
-            size: attachment.size,
-        }),
+        data: new URL(attachment.url),
     };
 }
 /**
@@ -62,39 +60,35 @@ export function buildSlackTurnMessage(text, fileParts) {
     const textPart = { type: "text", text };
     return [textPart, ...fileParts];
 }
-/** Materializes a {@link SlackBotToken} to a string at fetch time
- *  so callers can rotate (function-shaped credentials) or read lazily. */
 async function resolveSlackBotToken(token) {
     const source = token ?? process.env.SLACK_BOT_TOKEN;
     if (!source) {
-        throw new Error("SLACK_BOT_TOKEN is required to resolve Slack attachment refs.");
+        throw new Error("SLACK_BOT_TOKEN is required to fetch Slack files.");
     }
     return typeof source === "function" ? await source() : source;
 }
 /**
- * Slack-channel {@link AttachmentResolver}: fetches the upstream
- * Slack file URL with the bot token and returns the bytes plus any
- * advertised media-type. Staging writes bytes to the sandbox and
- * rewrites the file part as an `ash-sandbox:` ref.
+ * Creates a `fetchFile` function for the Slack channel.
+ *
+ * Returns `null` for URLs that don't belong to Slack so they pass
+ * through to the model provider unchanged. Fetches Slack file URLs
+ * with the bot token.
  */
-export function createSlackAttachmentResolver(input) {
-    return {
-        async resolve(ref) {
-            const token = await resolveSlackBotToken(input.botToken);
-            const response = await fetch(ref.params.url, {
-                headers: { authorization: `Bearer ${token}` },
-            });
-            if (!response.ok) {
-                throw new AshAttachmentError({
-                    adapterKind: "slack",
-                    kind: "fetch-failed",
-                    message: `Slack attachment fetch returned HTTP ${response.status} for ${ref.params.url}.`,
-                });
-            }
-            return {
-                bytes: Buffer.from(await response.arrayBuffer()),
-                mediaType: response.headers.get("content-type") ?? undefined,
-            };
-        },
+export function createSlackFetchFile(input) {
+    return async (url) => {
+        if (!url.startsWith("https://files.slack.com/")) {
+            return null;
+        }
+        const token = await resolveSlackBotToken(input.botToken);
+        const response = await fetch(url, {
+            headers: { authorization: `Bearer ${token}` },
+        });
+        if (!response.ok) {
+            throw new Error(`Slack file fetch returned HTTP ${response.status} for ${url}.`);
+        }
+        return {
+            bytes: Buffer.from(await response.arrayBuffer()),
+            mediaType: response.headers.get("content-type") ?? undefined,
+        };
     };
 }

package/dist/src/public/channels/slack/index.d.ts

@@ -1,5 +1,4 @@
 export { slack, type SlackOptions } from "#public/channels/slack/slack.js";
-export { slackChannel, type SlackApiHandle, type SlackApiResponse, type SlackChannelConfig, type SlackChannelEvents, type SlackChannelCredentials, type SlackChannelState, type SlackContext, type SlackInteractionAction, type SlackReceiveArgs, } from "#public/channels/slack/slackChannel.js";
-export type { SlackAttachmentParams } from "#public/channels/slack/attachments.js";
+export { slackChannel, type SlackApiHandle, type SlackApiResponse, type SlackChannel, type SlackChannelConfig, type SlackChannelEvents, type SlackChannelCredentials, type SlackChannelState, type SlackContext, type SlackInteractionAction, type SlackReceiveArgs, } from "#public/channels/slack/slackChannel.js";
 export { Actions, Button, Card, CardText, Divider, Fields, Image, LinkButton, Modal, RadioSelect, Section, Select, SelectOption, Table, TextInput, } from "#compiled/chat/index.js";
 export type { AdapterPostableMessage, Attachment, Author, CardElement, FileUpload, Message, PostableMessage, SentMessage, Thread, } from "#compiled/chat/index.js";

package/dist/src/public/channels/slack/slackChannel.d.ts

@@ -72,6 +72,10 @@ export interface SlackChannelEvents {
 export interface SlackChannelConfig {
     readonly credentials?: SlackChannelCredentials;
     readonly botName?: string;
+    /**
+     * Override the default webhook route path (`/ash/v1/slack`).
+     */
+    readonly route?: string;
     /**
      * Inbound upload policy applied to file attachments before they
      * reach the harness. Violating attachments are dropped with a
@@ -83,5 +87,12 @@ export interface SlackChannelConfig {
     onInteraction?(action: SlackInteractionAction, ctx: SlackContext): void | Promise<void>;
     readonly events?: SlackChannelEvents;
 }
-export declare function slackChannel(config?: SlackChannelConfig): Channel<SlackChannelState>;
+/**
+ * Concrete return type of {@link slackChannel}. Named so consumers can
+ * default-export a `slackChannel(...)` call under `declaration: true`
+ * without TypeScript falling back to an internal path for `Channel`.
+ */
+export interface SlackChannel extends Channel<SlackChannelState> {
+}
+export declare function slackChannel(config?: SlackChannelConfig): SlackChannel;
 export {};

package/dist/src/public/channels/slack/slackChannel.js

@@ -1,8 +1,8 @@
 import { createLogger } from "#internal/logging.js";
-import { buildSlackTurnMessage, collectSlackFileParts, createSlackAttachmentResolver, } from "#public/channels/slack/attachments.js";
+import { buildSlackTurnMessage, collectSlackFileParts, createSlackFetchFile, } from "#public/channels/slack/attachments.js";
 import { deriveHitlResponse, isHitlAction, renderInputRequestBlocks, } from "#public/channels/slack/hitl.js";
 import { mergeUploadPolicy } from "#public/channels/upload-policy.js";
-import { defineChannel, POST, } from "#public/definitions/defineChannel.js";
+import { defineChannel, POST } from "#public/definitions/defineChannel.js";
 const log = createLogger("slack.channel");
 function decodeThreadId(id) {
     const parts = id.replace(/^slack:/u, "").split(":");
@@ -109,10 +109,9 @@ function defaultInputRequestedHandler() {
 }
 export function slackChannel(config = {}) {
     const uploadPolicy = mergeUploadPolicy(config.uploadPolicy);
-    const slackAttachments = createSlackAttachmentResolver({
+    const slackFetchFile = createSlackFetchFile({
         botToken: config.credentials?.botToken,
     });
-    let activeSend = null;
     let chatPromise = null;
     async function getChat() {
         if (chatPromise)
@@ -139,39 +138,6 @@ export function slackChannel(config = {}) {
                 userName: config.botName ?? "ash-agent",
             });
             await chat.initialize();
-            chat.onNewMention(async (thread, message) => {
-                // Slack sends both `app_mention` and `message.channels` for the same message.
-                // The Chat SDK dedup relies on in-memory state that doesn't survive across
-                // serverless invocations, so both events reach this handler. Only process
-                // `app_mention` to prevent duplicate runs.
-                const rawEvent = message.raw;
-                if (rawEvent?.type !== "app_mention")
-                    return;
-                const send = activeSend;
-                if (!send) {
-                    throw new Error("slackChannel: mention received but no request context is active.");
-                }
-                const teamId = rawEvent.team_id ?? rawEvent.team;
-                const slackCtx = {
-                    thread,
-                    slack: buildSlackApiHandle(thread, config.credentials?.botToken, teamId),
-                };
-                const runOpts = config.run ? config.run(slackCtx, message) : { auth: null };
-                if (runOpts === null)
-                    return;
-                const decoded = decodeThreadId(thread.id ?? "");
-                const continuationToken = `slack:${decoded.channelId}:${decoded.threadTs}`;
-                const fileParts = collectSlackFileParts(message, uploadPolicy);
-                const turnMessage = buildSlackTurnMessage(message.text, fileParts);
-                await send(turnMessage, {
-                    auth: runOpts.auth,
-                    continuationToken,
-                    state: {
-                        serializedThread: thread.toJSON(),
-                        teamId: teamId ?? null,
-                    },
-                });
-            });
             return { chat };
         })();
         chatPromise = promise;
@@ -183,12 +149,12 @@ export function slackChannel(config = {}) {
     const inputHandler = config.events?.["input.requested"] ?? defaultInputRequestedHandler();
     return defineChannel({
         state: { serializedThread: null, teamId: null },
-        attachments: slackAttachments,
+        fetchFile: slackFetchFile,
         context(state) {
             return rebuildSlackContext(state, config.credentials?.botToken);
         },
         routes: [
-            POST("/ash/v1/slack", async (req, { send, waitUntil }) => {
+            POST(config.route ?? "/ash/v1/slack", async (req, { send, waitUntil }) => {
                 const { chat } = await getChat();
                 const contentType = req.headers.get("content-type") ?? "";
                 if (contentType.includes("application/x-www-form-urlencoded")) {
@@ -249,16 +215,36 @@ export function slackChannel(config = {}) {
                     }
                     return new Response("ok", { status: 200 });
                 }
-                activeSend = send;
-                try {
-                    const webhookHandler = chat.webhooks.slack;
-                    return await webhookHandler(req, {
-                        waitUntil,
+                chat.onNewMention(async (thread, message) => {
+                    const rawEvent = message.raw;
+                    // Slack sends both `app_mention` and `message.channels` for the same
+                    // utterance. The Chat SDK dedup relies on in-memory state that doesn't
+                    // survive serverless invocations, so both events reach this handler.
+                    // Only process `app_mention` to prevent duplicate runs.
+                    if (rawEvent?.type !== "app_mention")
+                        return;
+                    const teamId = rawEvent.team_id ?? rawEvent.team;
+                    const slackCtx = {
+                        thread,
+                        slack: buildSlackApiHandle(thread, config.credentials?.botToken, teamId),
+                    };
+                    const runOpts = config.run ? config.run(slackCtx, message) : { auth: null };
+                    if (runOpts === null)
+                        return;
+                    const decoded = decodeThreadId(thread.id ?? "");
+                    const continuationToken = `slack:${decoded.channelId}:${decoded.threadTs}`;
+                    const fileParts = collectSlackFileParts(message, uploadPolicy);
+                    const turnMessage = buildSlackTurnMessage(message.text, fileParts);
+                    await send(turnMessage, {
+                        auth: runOpts.auth,
+                        continuationToken,
+                        state: {
+                            serializedThread: thread.toJSON(),
+                            teamId: teamId ?? null,
+                        },
                     });
-                }
-                finally {
-                    activeSend = null;
-                }
+                });
+                return await chat.webhooks.slack(req, { waitUntil });
             }),
         ],
         async receive(input, { send }) {

package/dist/src/public/definitions/defineChannel.d.ts

@@ -1,4 +1,4 @@
-import type { AttachmentResolver } from "#channel/adapter.js";
+import type { FetchFileResult } from "#channel/adapter.js";
 import { CHANNEL_SENTINEL } from "#channel/compiled-channel.js";
 import type { SessionAuthContext } from "#channel/types.js";
 import type { HandleMessageStreamEvent } from "#protocol/message.js";
@@ -7,7 +7,6 @@ import type { Session, SessionHandle } from "#channel/session.js";
 export type { Session, SessionHandle } from "#channel/session.js";
 export { POST, GET, PUT, DELETE } from "#channel/routes.js";
 export type { RouteDefinition, RouteHandlerArgs, SendFn, SendOptions, SendPayload, GetSessionFn, } from "#channel/routes.js";
-export type { AttachmentResolver } from "#channel/adapter.js";
 type EventData<T extends HandleMessageStreamEvent["type"]> = Extract<HandleMessageStreamEvent, {
     type: T;
 }> extends {
@@ -43,12 +42,15 @@ export interface ChannelConfig<TState = undefined, TCtx = void> {
     }): Promise<Session>;
     readonly events?: ChannelEvents<TCtx>;
     /**
-     * Resolver for `ash-attachment:` URLs this channel mints during
-     * inbound message handling. The framework's staging layer dispatches
-     * to `resolve(ref, ctx)` before each model call so the bytes can be
-     * written to the sandbox and rewritten as `ash-sandbox:` refs.
+     * Fetches bytes for a URL encountered in `FilePart.data`.
+     *
+     * Called by the staging pipeline when it encounters a `URL` object
+     * on a `FilePart` (e.g. a Slack file URL placed there by the route
+     * handler). Return `null` to let the URL pass through to the model
+     * provider unchanged. Return bytes or {@link FetchFileResult} to
+     * stage the file to the sandbox.
      */
-    readonly attachments?: AttachmentResolver;
+    readonly fetchFile?: (url: string) => Promise<Buffer | FetchFileResult | null>;
 }
 export interface Channel<TState = undefined> {
     readonly __kind: typeof CHANNEL_SENTINEL;

package/dist/src/public/definitions/defineChannel.js

@@ -1,5 +1,6 @@
 import { CHANNEL_SENTINEL } from "#channel/compiled-channel.js";
 import { defaultDeliverResult } from "#channel/adapter.js";
+import { HTTP_ADAPTER_KIND } from "#channel/http.js";
 export { POST, GET, PUT, DELETE } from "#channel/routes.js";
 export function defineChannel(config) {
     const adapter = buildAdapter(config);
@@ -14,7 +15,7 @@ export function defineChannel(config) {
 function buildAdapter(config) {
     const hasState = config.state != null;
     const hasContext = config.context != null;
-    const hasAttachments = config.attachments !== undefined;
+    const hasFetchFile = config.fetchFile !== undefined;
     const hasBehavior = hasState || hasContext;
     const eventHandlers = {};
     let hasEventHandlers = false;
@@ -42,20 +43,13 @@ function buildAdapter(config) {
             };
         }
     }
-    // When the channel carries no behavior at all, return a bare
-    // pass-through adapter with framework kind "http". This avoids the
-    // registry conflict when the adapter would otherwise reserve a
-    // framework kind with no behavior to register against it.
-    if (!hasBehavior && !hasEventHandlers && !hasAttachments) {
-        return { kind: "http" };
+    if (!hasBehavior && !hasEventHandlers && !hasFetchFile) {
+        return { kind: HTTP_ADAPTER_KIND };
     }
-    // Channels with any authored behavior use a dedicated adapter kind so
-    // the registry can rehydrate it across step boundaries without
-    // conflicting with framework-reserved kinds.
     return {
         kind: "defineChannel",
         state: hasState ? { ...config.state } : {},
-        attachments: config.attachments,
+        fetchFile: config.fetchFile,
         createAdapterContext(base) {
             const state = base.state;
             const channelCtx = hasContext ? config.context(state) : {};

package/dist/src/public/definitions/sandbox.d.ts

@@ -2,9 +2,9 @@ import type { Optional } from "#shared/optional.js";
 import type { SandboxSession } from "#shared/sandbox-session.js";
 import type { SandboxDefinition as SharedSandboxDefinition } from "#shared/sandbox-definition.js";
 export type { SandboxCommandOptions, SandboxCommandResult, SandboxReadFileOptions, SandboxSession, } from "#shared/sandbox-session.js";
-export type { SandboxNetworkPolicy, SandboxBootstrapUseOptions, SandboxSessionUseOptions, SandboxBootstrapUseFn, SandboxSessionUseFn, SandboxBootstrapContext, SandboxSessionContext, } from "#shared/sandbox-definition.js";
-export type SandboxDefinition<S extends SandboxSession = SandboxSession> = Optional<SharedSandboxDefinition<S>, "backend">;
+export type { SandboxBootstrapUseOptions, SandboxBootstrapUseFn, SandboxSessionUseFn, SandboxBootstrapContext, SandboxSessionContext, } from "#shared/sandbox-definition.js";
+export type SandboxDefinition<S extends SandboxSession = SandboxSession, O = Record<string, never>> = Optional<SharedSandboxDefinition<S, O>, "backend">;
 /**
  * Defines a sandbox configuration.
  */
-export declare function defineSandbox<S extends SandboxSession = SandboxSession>(definition: SandboxDefinition<S>): SandboxDefinition<S>;
+export declare function defineSandbox<S extends SandboxSession = SandboxSession, O = Record<string, never>>(definition: SandboxDefinition<S, O>): SandboxDefinition<S, O>;

package/dist/src/public/sandbox/backends/vercel.d.ts

@@ -1,5 +1,5 @@
 import type { SandboxBackend } from "#public/definitions/sandbox-backend.js";
-import type { VercelSandbox } from "#public/sandbox/vercel-sandbox.js";
+import type { VercelSandbox, VercelSandboxSessionUseOptions } from "#public/sandbox/vercel-sandbox.js";
 /**
  * Constructs the built-in Vercel sandbox backend.
  *
@@ -8,4 +8,4 @@ import type { VercelSandbox } from "#public/sandbox/vercel-sandbox.js";
  * timeout) lives in `onSession`'s `create()` call or
  * `VercelSandbox.update()`.
  */
-export declare function vercelBackend(): SandboxBackend<VercelSandbox>;
+export declare function vercelBackend(): SandboxBackend<VercelSandbox, VercelSandboxSessionUseOptions>;

package/dist/src/public/sandbox/index.d.ts

@@ -3,10 +3,10 @@
  * `agent/sandbox/sandbox.ts` when paired with a `workspace/` folder).
  */
 export { getSandbox } from "#context/accessors.js";
-export { defineSandbox, type SandboxBootstrapContext, type SandboxBootstrapUseFn, type SandboxBootstrapUseOptions, type SandboxCommandOptions, type SandboxCommandResult, type SandboxDefinition, type SandboxNetworkPolicy, type SandboxReadFileOptions, type SandboxSession, type SandboxSessionContext, type SandboxSessionUseFn, type SandboxSessionUseOptions, } from "#public/definitions/sandbox.js";
+export { defineSandbox, type SandboxBootstrapContext, type SandboxBootstrapUseFn, type SandboxBootstrapUseOptions, type SandboxCommandOptions, type SandboxCommandResult, type SandboxDefinition, type SandboxReadFileOptions, type SandboxSession, type SandboxSessionContext, type SandboxSessionUseFn, } from "#public/definitions/sandbox.js";
 export type { SandboxBackend, SandboxBackendCreateInput, SandboxBackendHandle, SandboxBackendPrewarmInput, SandboxBackendRuntimeContext, SandboxBackendSessionState, SandboxSeedFile, } from "#public/definitions/sandbox-backend.js";
 export { SandboxTemplateNotProvisionedError } from "#public/definitions/sandbox-backend.js";
 export { defaultBackend } from "#public/sandbox/backends/default.js";
 export { localBackend } from "#public/sandbox/backends/local.js";
 export { vercelBackend } from "#public/sandbox/backends/vercel.js";
-export type { VercelSandbox } from "#public/sandbox/vercel-sandbox.js";
+export type { VercelSandbox, VercelSandboxSessionUseOptions, } from "#public/sandbox/vercel-sandbox.js";

package/dist/src/public/sandbox/vercel-sandbox.d.ts

@@ -1,4 +1,12 @@
-import type { SandboxNetworkPolicy, SandboxSession } from "#public/definitions/sandbox.js";
+import type { SandboxUpdateParams } from "#compiled/@vercel/sandbox/index.js";
+import type { SandboxSession } from "#public/definitions/sandbox.js";
+/**
+ * Options accepted by the Vercel backend's `onSession({ use })` hook
+ * and `VercelSandbox.update()`. Aliases the Vercel SDK's
+ * `SandboxUpdateParams` so the full live-session configuration surface
+ * is available to authors.
+ */
+export type VercelSandboxSessionUseOptions = SandboxUpdateParams;
 /**
  * Ash-owned session type returned by the Vercel backend's
  * `onSession({ use })` hook. Extends the narrow
@@ -9,16 +17,9 @@ export interface VercelSandbox extends SandboxSession {
     readonly name: string;
     readonly persistent: boolean;
     readonly status: string;
-    readonly networkPolicy: SandboxNetworkPolicy | undefined;
+    readonly networkPolicy: SandboxUpdateParams["networkPolicy"];
     readonly tags: Record<string, string> | undefined;
-    update(params: {
-        networkPolicy?: SandboxNetworkPolicy;
-        resources?: {
-            vcpus?: number;
-        };
-        timeout?: number;
-        tags?: Record<string, string>;
-    }): Promise<void>;
+    update(params: VercelSandboxSessionUseOptions): Promise<void>;
     stop(opts?: {
         blocking?: boolean;
     }): Promise<void>;

package/dist/src/runtime/channels/registry.js

@@ -1,4 +1,6 @@
 import { getAdapterKind } from "#channel/adapter.js";
+import { HTTP_ADAPTER } from "#channel/http.js";
+import { SCHEDULE_ADAPTER } from "#channel/schedule.js";
 import { SUBAGENT_ADAPTER } from "#execution/subagent-adapter.js";
 import { RuntimeRegistryError } from "#internal/runtime-registry.js";
 /**
@@ -6,7 +8,11 @@ import { RuntimeRegistryError } from "#internal/runtime-registry.js";
  *
  * Framework kinds cannot be shadowed with route-authored behavior.
  */
-const FRAMEWORK_ADAPTERS = [{ kind: "http" }, SUBAGENT_ADAPTER];
+const FRAMEWORK_ADAPTERS = [
+    HTTP_ADAPTER,
+    SUBAGENT_ADAPTER,
+    SCHEDULE_ADAPTER,
+];
 /**
  * Non-event-handler fields on a {@link ChannelAdapter}. Any other
  * key on the adapter object corresponds to a stream event handler
@@ -20,7 +26,7 @@ const ADAPTER_NON_EVENT_FIELDS = new Set([
     "deliver",
     "contextProviders",
     "createAdapterContext",
-    "attachments",
+    "fetchFile",
 ]);
 /**
  * Builds the runtime-owned adapter registry from framework adapters plus any
@@ -109,7 +115,7 @@ function carriesAdapterBehavior(adapter) {
     if (adapter.deliver !== undefined) {
         return true;
     }
-    if (adapter.attachments !== undefined) {
+    if (adapter.fetchFile !== undefined) {
         return true;
     }
     if (adapter.createAdapterContext !== undefined) {

package/dist/src/runtime/resolve-channel.js

@@ -1,3 +1,4 @@
+import { HTTP_ADAPTER_KIND } from "#channel/http.js";
 import { normalizeChannelDefinition } from "#internal/authored-definition/channel.js";
 import { toErrorMessage } from "#shared/errors.js";
 import { createResolvedModuleSourceRef, loadResolvedModuleExport, ResolveAgentError, } from "#runtime/resolve-helpers.js";
@@ -30,7 +31,7 @@ export async function resolveChannelDefinition(definition, moduleMap, nodeId) {
         });
         const matchedRoute = channelDefinition.routes.find((r) => r.method.toUpperCase() === definition.method.toUpperCase() && r.path === definition.urlPath);
         const adapter = channelDefinition.adapter;
-        if (adapter && adapter.kind !== "http") {
+        if (adapter && adapter.kind !== HTTP_ADAPTER_KIND) {
             adapter.kind = `channel:${definition.name}`;
         }
         return {

package/dist/src/shared/sandbox-backend.d.ts

@@ -7,9 +7,9 @@ import type { SandboxSession } from "#shared/sandbox-session.js";
  * runtime orchestrator can persist reconnect metadata and release
  * resources.
  */
-export interface SandboxBackendHandle<S extends SandboxSession = SandboxSession> {
+export interface SandboxBackendHandle<S extends SandboxSession = SandboxSession, O = Record<string, never>> {
     readonly session: SandboxSession;
-    readonly useSessionFn: SandboxSessionUseFn<S>;
+    readonly useSessionFn: SandboxSessionUseFn<S, O>;
     captureState(): Promise<SandboxBackendSessionState>;
     dispose(): Promise<void>;
 }
@@ -97,7 +97,7 @@ export interface SandboxBackendPrewarmInput {
  * Each backend owns the full template-then-session lifecycle internally;
  * callers only need a single `create` call.
  */
-export interface SandboxBackend<S extends SandboxSession = SandboxSession> {
+export interface SandboxBackend<S extends SandboxSession = SandboxSession, O = Record<string, never>> {
     /**
      * Stable identifier for this backend implementation.
      *
@@ -113,7 +113,7 @@ export interface SandboxBackend<S extends SandboxSession = SandboxSession> {
      * {@link SandboxTemplateNotProvisionedError} when the requested
      * template is missing.
      */
-    create(input: SandboxBackendCreateInput): Promise<SandboxBackendHandle<S>>;
+    create(input: SandboxBackendCreateInput): Promise<SandboxBackendHandle<S, O>>;
     /**
      * Build-time prewarm hook. Ash invokes this for every authored
      * sandbox in the compiled graph before serving traffic so the backend