experimental-ash 0.18.1 → 0.18.2

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

@@ -1,5 +1,5 @@
 import { createLogger } from "#internal/logging.js";
-import { buildSlackBinding, encodeSlackContinuationToken, } from "#public/channels/slack/api.js";
+import { buildSlackBinding, slackContinuationToken, } from "#public/channels/slack/api.js";
 import { buildSlackTurnMessage, collectInboundFileParts, createSlackFetchFile, } from "#public/channels/slack/attachments.js";
 import { defaultEvents, defaultInputRequestedHandler, defaultOnAppMention, defaultOnDirectMessage, } from "#public/channels/slack/defaults.js";
 import { parseAppMentionEvent, parseDirectMessageEvent, prependSlackContext, } from "#public/channels/slack/inbound.js";
@@ -8,14 +8,26 @@ import { mergeUploadPolicy, } from "#public/channels/upload-policy.js";
 import { verifySlackRequest } from "#public/channels/slack/verify.js";
 import { defineChannel, POST, } from "#public/definitions/defineChannel.js";
 const log = createLogger("slack.channel");
-function rebuildSlackContext(state, credentials) {
+function rebuildSlackContext(state, session, credentials) {
     const { thread, slack } = buildSlackBinding({
         botToken: credentials?.botToken,
         channelId: state.channelId ?? "",
         threadTs: state.threadTs ?? "",
         teamId: state.teamId ?? undefined,
+        // First `ctx.thread.post(...)` in a session that started without a
+        // thread (programmatic start, schedule firing, etc.) becomes the
+        // thread root. We update durable adapter state so subsequent
+        // posts thread under it, and re-key the parked session so a
+        // follow-up `@mention` reply in the same thread resumes the same
+        // workflow.
+        onAnchor(ts) {
+            state.threadTs = ts;
+            if (state.channelId) {
+                session.setContinuationToken(slackContinuationToken(state.channelId, ts));
+            }
+        },
     });
-    return { thread, slack, state };
+    return { thread, slack, session, state };
 }
 /**
  * Slack channel factory. Wires up the Slack webhook route, mention
@@ -48,8 +60,8 @@ export function slackChannel(config = {}) {
             pendingAuthMessageTs: {},
         },
         fetchFile: slackFetchFile,
-        context(state) {
-            return rebuildSlackContext(state, config.credentials);
+        context(state, session) {
+            return rebuildSlackContext(state, session, config.credentials);
         },
         routes: [
             POST(config.route ?? "/ash/v1/slack", async (req, { send, waitUntil }) => {
@@ -78,12 +90,12 @@ export function slackChannel(config = {}) {
                 throw new Error("slackChannel().receive requires args.channelId.");
             }
             const requestedThreadTs = typeof receiveArgs.threadTs === "string" ? receiveArgs.threadTs : "";
-            const initialPost = receiveArgs.initialPost;
-            if (initialPost && requestedThreadTs.length > 0) {
-                throw new Error("slackChannel().receive: `threadTs` and `initialPost` are mutually exclusive.");
+            const initialMessage = receiveArgs.initialMessage;
+            if (initialMessage && requestedThreadTs.length > 0) {
+                throw new Error("slackChannel().receive: `threadTs` and `initialMessage` are mutually exclusive.");
             }
             let threadTs = requestedThreadTs;
-            if (initialPost) {
+            if (initialMessage) {
                 const { thread } = buildSlackBinding({
                     botToken: config.credentials?.botToken,
                     channelId,
@@ -91,17 +103,17 @@ export function slackChannel(config = {}) {
                     teamId: undefined,
                 });
                 const postInput = {
-                    card: initialPost.card,
+                    card: initialMessage.card,
                 };
-                if (initialPost.fallbackText !== undefined) {
-                    postInput.fallbackText = initialPost.fallbackText;
+                if (initialMessage.fallbackText !== undefined) {
+                    postInput.fallbackText = initialMessage.fallbackText;
                 }
                 const posted = await thread.post(postInput);
                 threadTs = posted.id;
             }
             return send(input.message, {
                 auth: input.auth,
-                continuationToken: encodeSlackContinuationToken(channelId, threadTs),
+                continuationToken: slackContinuationToken(channelId, threadTs),
                 state: {
                     channelId,
                     threadTs: threadTs || null,
@@ -206,7 +218,6 @@ async function dispatchInboundMessage(input) {
     }
     if (result === null || result === undefined)
         return;
-    const continuationToken = encodeSlackContinuationToken(message.channelId, message.threadTs);
     const fileParts = await collectInboundFileParts({
         mention: message,
         thread,
@@ -227,7 +238,7 @@ async function dispatchInboundMessage(input) {
     try {
         await input.send(turnMessage, {
             auth: result.auth,
-            continuationToken,
+            continuationToken: slackContinuationToken(message.channelId, message.threadTs),
             state: {
                 channelId: message.channelId,
                 threadTs: message.threadTs,

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

@@ -6,6 +6,15 @@
  * required or exposed through Ash public APIs.
  */
 import { type TwilioAuthToken } from "#public/channels/twilio/verify.js";
+/**
+ * Builds the Twilio channel-local continuation token
+ * (`<from>:<to>`). Route `send()` namespaces this with the channel
+ * name before handing it to the runtime (`twilio:<from>:<to>`), so
+ * Twilio routes should pass the raw channel-local form returned
+ * here. `to` may be empty for proactive sessions that don't yet know
+ * the Twilio sender number.
+ */
+export declare function twilioContinuationToken(from: string, to: string | undefined): string;
 /** Twilio Account SID, materialized directly or from an async secret provider. */
 export type TwilioAccountSid = string | (() => string | Promise<string>);
 /** Fetch implementation override used by tests or non-standard runtimes. */

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

@@ -6,6 +6,17 @@
  * required or exposed through Ash public APIs.
  */
 import { resolveTwilioAuthToken } from "#public/channels/twilio/verify.js";
+/**
+ * Builds the Twilio channel-local continuation token
+ * (`<from>:<to>`). Route `send()` namespaces this with the channel
+ * name before handing it to the runtime (`twilio:<from>:<to>`), so
+ * Twilio routes should pass the raw channel-local form returned
+ * here. `to` may be empty for proactive sessions that don't yet know
+ * the Twilio sender number.
+ */
+export function twilioContinuationToken(from, to) {
+    return `${from}:${to ?? ""}`;
+}
 /** Resolves a Twilio Account SID, falling back to `TWILIO_ACCOUNT_SID`. */
 export async function resolveTwilioAccountSid(accountSid) {
     const source = accountSid ?? process.env.TWILIO_ACCOUNT_SID;

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

@@ -1,5 +1,5 @@
 export { twilioChannel, type TwilioAllowFrom, type TwilioChannel, type TwilioChannelConfig, type TwilioChannelCredentials, type TwilioChannelEvents, type TwilioChannelState, type TwilioContext, type TwilioEventContext, type TwilioHandle, type TwilioInboundResult, type TwilioInboundResultOrPromise, type TwilioMessagingConfig, type TwilioReceiveArgs, type TwilioSendMessageOptions, type TwilioVoiceConfig, type TwilioVoiceResult, type TwilioVoiceResultOrPromise, } from "#public/channels/twilio/twilioChannel.js";
-export { callTwilioApi, resolveTwilioAccountSid, sendTwilioMessage, updateTwilioCall, type TwilioAccountSid, type TwilioApiOptions, type TwilioApiResponse, type TwilioCredentials, type TwilioFetch, type TwilioSendMessageInput, type TwilioUpdateCallInput, } from "#public/channels/twilio/api.js";
+export { callTwilioApi, resolveTwilioAccountSid, sendTwilioMessage, twilioContinuationToken, updateTwilioCall, type TwilioAccountSid, type TwilioApiOptions, type TwilioApiResponse, type TwilioCredentials, type TwilioFetch, type TwilioSendMessageInput, type TwilioUpdateCallInput, } from "#public/channels/twilio/api.js";
 export type { TwilioInboundContext, TwilioTextMessage, TwilioVoiceCall, TwilioVoiceTranscription, } from "#public/channels/twilio/inbound.js";
 export { emptyTwilioResponse, escapeXml, gatherSpeechTwilioResponse, sayTwilioResponse, twimlResponse, type TwilioGatherTwimlOptions, } from "#public/channels/twilio/twiml.js";
 export { buildTwilioSignatureBase, resolveTwilioAuthToken, signTwilioRequest, verifyTwilioRequest, type TwilioAuthToken, type TwilioVerifiedRequest, type TwilioVerifyOptions, type TwilioWebhookUrl, } from "#public/channels/twilio/verify.js";

package/dist/src/public/channels/twilio/index.js

@@ -1,4 +1,4 @@
 export { twilioChannel, } from "#public/channels/twilio/twilioChannel.js";
-export { callTwilioApi, resolveTwilioAccountSid, sendTwilioMessage, updateTwilioCall, } from "#public/channels/twilio/api.js";
+export { callTwilioApi, resolveTwilioAccountSid, sendTwilioMessage, twilioContinuationToken, updateTwilioCall, } from "#public/channels/twilio/api.js";
 export { emptyTwilioResponse, escapeXml, gatherSpeechTwilioResponse, sayTwilioResponse, twimlResponse, } from "#public/channels/twilio/twiml.js";
 export { buildTwilioSignatureBase, resolveTwilioAuthToken, signTwilioRequest, verifyTwilioRequest, } from "#public/channels/twilio/verify.js";

package/dist/src/public/channels/twilio/twilioChannel.d.ts

@@ -1,4 +1,5 @@
 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 TwilioApiOptions, type TwilioApiResponse, type TwilioCredentials } from "#public/channels/twilio/api.js";
@@ -16,6 +17,7 @@ export interface TwilioContext {
 }
 /** Event-handler Twilio context, including mutable per-phone channel state. */
 export interface TwilioEventContext extends TwilioContext {
+    readonly session: SessionHandle;
     state: TwilioChannelState;
 }
 /** JSON-serializable state for the phone-number conversation. */

package/dist/src/public/channels/twilio/twilioChannel.js

@@ -1,5 +1,5 @@
 import { createLogger } from "#internal/logging.js";
-import { callTwilioApi, sendTwilioMessage, updateTwilioCall, } from "#public/channels/twilio/api.js";
+import { callTwilioApi, sendTwilioMessage, twilioContinuationToken, updateTwilioCall, } from "#public/channels/twilio/api.js";
 import { defaultEvents, defaultOnText, defaultOnVoice, defaultOnVoiceTranscription, } from "#public/channels/twilio/defaults.js";
 import { parseTwilioTextMessage, parseTwilioVoiceCall, parseTwilioVoiceTranscription, prependTwilioContext, } from "#public/channels/twilio/inbound.js";
 import { emptyTwilioResponse, gatherSpeechTwilioResponse, sayTwilioResponse, } from "#public/channels/twilio/twiml.js";
@@ -22,8 +22,8 @@ export function twilioChannel(config) {
             lastCallSid: null,
             lastMessageSid: null,
         },
-        context(state) {
-            return rebuildTwilioContext(state, config);
+        context(state, session) {
+            return rebuildTwilioContext(state, session, config);
         },
         routes: [
             POST(routes.messages, async (req, { send, waitUntil }) => {
@@ -96,10 +96,9 @@ export function twilioChannel(config) {
                 throw new Error("twilioChannel().receive requires args.phoneNumber.");
             }
             const from = readString(input.args.from) ?? config.messaging?.from ?? null;
-            const continuationToken = encodeTwilioContinuationToken(phoneNumber, from);
             return send(input.message, {
                 auth: input.auth,
-                continuationToken,
+                continuationToken: twilioContinuationToken(phoneNumber, from ?? undefined),
                 state: {
                     from: phoneNumber,
                     lastCallSid: null,
@@ -111,8 +110,9 @@ export function twilioChannel(config) {
         events: mergedEvents,
     });
 }
-function rebuildTwilioContext(state, config) {
+function rebuildTwilioContext(state, session, config) {
     return {
+        session,
         state,
         twilio: buildTwilioHandle({
             callSid: state.lastCallSid ?? undefined,
@@ -218,7 +218,7 @@ async function dispatchText(input) {
     try {
         await input.send(turnMessage, {
             auth: result.auth,
-            continuationToken: encodeTwilioContinuationToken(message.from, message.to),
+            continuationToken: twilioContinuationToken(message.from, message.to),
             state: {
                 from: message.from,
                 lastCallSid: null,
@@ -278,7 +278,7 @@ async function dispatchVoiceTranscription(input) {
     try {
         await input.send(turnMessage, {
             auth: result.auth,
-            continuationToken: encodeTwilioContinuationToken(transcription.from, transcription.to),
+            continuationToken: twilioContinuationToken(transcription.from, transcription.to),
             state: {
                 from: transcription.from,
                 lastCallSid: transcription.callSid ?? null,
@@ -297,9 +297,6 @@ async function isAllowed(from, allowFrom) {
         return true;
     return typeof resolved === "string" ? resolved === from : resolved.includes(from);
 }
-function encodeTwilioContinuationToken(from, to) {
-    return `${from}:${to ?? ""}`;
-}
 async function buildActionUrl(request, config, route) {
     const base = typeof config.publicBaseUrl === "function"
         ? await config.publicBaseUrl(request)

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

@@ -33,7 +33,15 @@ export interface ChannelEvents<TCtx = void> {
 }
 export interface ChannelConfig<TState = undefined, TCtx = void> {
     readonly state?: TState;
-    context?(state: NonNullable<TState>): TCtx;
+    /**
+     * Builds the per-step channel context handed to `events` and
+     * `deliver`. Receives the live {@link SessionHandle} so factories
+     * that need to wire late-bound callbacks (e.g. Slack's auto-anchor
+     * `onAnchor` calling `session.setContinuationToken(...)`) can close
+     * over it. State mutations made inside the returned context flow
+     * back through `adapter.state` automatically.
+     */
+    context?(state: NonNullable<TState>, session: SessionHandle): TCtx;
     readonly routes: readonly RouteDefinition<TState>[];
     receive?(input: {
         readonly message: string;

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

@@ -48,26 +48,21 @@ function buildAdapter(config) {
     if (!hasBehavior && !hasEventHandlers && !hasFetchFile) {
         return { kind: config.kindHint ?? HTTP_ADAPTER_KIND };
     }
-    return {
+    const adapter = {
         kind: config.kindHint ?? "defineChannel",
         state: hasState ? { ...config.state } : {},
         fetchFile: config.fetchFile,
         createAdapterContext(base) {
             const state = base.state;
-            const channelCtx = hasContext ? config.context(state) : {};
+            const session = base.session;
+            const channelCtx = hasContext
+                ? config.context(state, session)
+                : {};
             return {
                 ...channelCtx,
                 state,
                 ctx: base.ctx,
-                session: {
-                    id: "",
-                    continuationToken: "",
-                    auth: null,
-                    initiatorAuth: null,
-                    setContinuationToken(_token) {
-                        // TODO: wire to runtime
-                    },
-                },
+                session,
             };
         },
         deliver(payload) {
@@ -75,4 +70,5 @@ function buildAdapter(config) {
         },
         ...eventHandlers,
     };
+    return adapter;
 }

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

@@ -1,10 +1,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, SandboxReadTextFileOptions, SandboxSession, SandboxWriteTextFileOptions, } from "#shared/sandbox-session.js";
 export type { SandboxBootstrapUseFn, SandboxSessionUseFn, SandboxBootstrapContext, SandboxSessionContext, } from "#shared/sandbox-definition.js";
-export type SandboxDefinition<S extends SandboxSession = SandboxSession, BO = Record<string, never>, SO = Record<string, never>> = Optional<SharedSandboxDefinition<S, BO, SO>, "backend">;
+export type SandboxDefinition<BO = Record<string, never>, SO = Record<string, never>> = Optional<SharedSandboxDefinition<BO, SO>, "backend">;
 /**
  * Defines a sandbox configuration.
  */
-export declare function defineSandbox<S extends SandboxSession = SandboxSession, BO = Record<string, never>, SO = Record<string, never>>(definition: SandboxDefinition<S, BO, SO>): SandboxDefinition<S, BO, SO>;
+export declare function defineSandbox<BO = Record<string, never>, SO = Record<string, never>>(definition: SandboxDefinition<BO, SO>): SandboxDefinition<BO, SO>;

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

@@ -1,11 +1,11 @@
 import type { SandboxBackend } from "#public/definitions/sandbox-backend.js";
-import type { VercelSandbox, VercelSandboxBootstrapUseOptions, VercelSandboxSessionUseOptions } from "#public/sandbox/vercel-sandbox.js";
+import type { VercelSandboxBootstrapUseOptions, VercelSandboxSessionUseOptions } from "#public/sandbox/vercel-sandbox.js";
 /**
  * Constructs the built-in Vercel sandbox backend.
  *
  * `bootstrap({ use })` applies its options to the template via
  * `sandbox.update(...)`; those settings persist into the snapshot.
- * `onSession({ use })` applies its options to the live session via
- * `VercelSandbox.update()`.
+ * `onSession({ use })` applies its options to the live session via the
+ * SDK's `update` under the hood.
  */
-export declare function vercelBackend(): SandboxBackend<VercelSandbox, VercelSandboxBootstrapUseOptions, VercelSandboxSessionUseOptions>;
+export declare function vercelBackend(): SandboxBackend<VercelSandboxBootstrapUseOptions, VercelSandboxSessionUseOptions>;

package/dist/src/public/sandbox/backends/vercel.js

@@ -4,8 +4,8 @@ import { createVercelSandboxBackend } from "#execution/sandbox/bindings/vercel.j
  *
  * `bootstrap({ use })` applies its options to the template via
  * `sandbox.update(...)`; those settings persist into the snapshot.
- * `onSession({ use })` applies its options to the live session via
- * `VercelSandbox.update()`.
+ * `onSession({ use })` applies its options to the live session via the
+ * SDK's `update` under the hood.
  */
 export function vercelBackend() {
     return createVercelSandboxBackend();

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

@@ -9,4 +9,4 @@ export { SandboxTemplateNotProvisionedError } from "#public/definitions/sandbox-
 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, VercelSandboxBootstrapUseOptions, VercelSandboxSessionUseOptions, } from "#public/sandbox/vercel-sandbox.js";
+export type { VercelSandboxBootstrapUseOptions, VercelSandboxSessionUseOptions, } from "#public/sandbox/vercel-sandbox.js";

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

@@ -1,5 +1,4 @@
 import type { SandboxUpdateParams } from "#compiled/@vercel/sandbox/index.js";
-import type { SandboxSession } from "#public/definitions/sandbox.js";
 /**
  * Options accepted by the Vercel backend's `bootstrap({ use })` hook.
  * Aliases the Vercel SDK's `SandboxUpdateParams` because bootstrap
@@ -14,32 +13,8 @@ import type { SandboxSession } from "#public/definitions/sandbox.js";
  */
 export type VercelSandboxBootstrapUseOptions = SandboxUpdateParams;
 /**
- * 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.
+ * Options accepted by the Vercel backend's `onSession({ use })` hook.
+ * Aliases the Vercel SDK's `SandboxUpdateParams`; passed values are
+ * applied to the live session via the SDK's `update` under the hood.
  */
 export type VercelSandboxSessionUseOptions = SandboxUpdateParams;
-/**
- * Ash-owned session type returned by the Vercel backend's
- * `onSession({ use })` hook. Extends the narrow
- * {@link SandboxSession} with Vercel-specific capabilities that only
- * make sense on a live session sandbox (not a bootstrap template).
- */
-export interface VercelSandbox extends SandboxSession {
-    readonly name: string;
-    readonly persistent: boolean;
-    readonly status: string;
-    readonly networkPolicy: SandboxUpdateParams["networkPolicy"];
-    readonly tags: Record<string, string> | undefined;
-    update(params: VercelSandboxSessionUseOptions): Promise<void>;
-    stop(opts?: {
-        blocking?: boolean;
-    }): Promise<void>;
-    snapshot(opts?: {
-        expiration?: number;
-    }): Promise<{
-        snapshotId: string;
-    }>;
-    domain(port: number): string;
-}

package/dist/src/runtime/types.d.ts

@@ -16,7 +16,6 @@ import type { InternalSkillDefinition } from "#shared/skill-definition.js";
 import type { InternalAgentDefinition } from "#shared/agent-definition.js";
 import type { InternalToolDefinitionWithExecuteFn } from "#shared/tool-definition.js";
 import type { SandboxDefinition } from "#shared/sandbox-definition.js";
-import type { SandboxSession } from "#shared/sandbox-session.js";
 /**
  * Runtime-owned source ref describing one additive config module import.
  */
@@ -83,7 +82,7 @@ export interface ResolvedConnectionDefinition extends ResolvedModuleSourceRef {
  * `vercelBackend()` and `localBackend()` based on the current
  * environment).
  */
-export type ResolvedSandboxDefinition = Readonly<SandboxDefinition<SandboxSession>> & ResolvedModuleSourceRef & {
+export type ResolvedSandboxDefinition = Readonly<SandboxDefinition> & ResolvedModuleSourceRef & {
     readonly description?: string;
 };
 /**

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, SO = Record<string, never>> {
+export interface SandboxBackendHandle<SO = Record<string, never>> {
     readonly session: SandboxSession;
-    readonly useSessionFn: SandboxSessionUseFn<S, SO>;
+    readonly useSessionFn: SandboxSessionUseFn<SO>;
     captureState(): Promise<SandboxBackendSessionState>;
     dispose(): Promise<void>;
 }
@@ -97,7 +97,7 @@ export interface SandboxBackendPrewarmInput<BO = Record<string, never>> {
  * Each backend owns the full template-then-session lifecycle internally;
  * callers only need a single `create` call.
  */
-export interface SandboxBackend<S extends SandboxSession = SandboxSession, BO = Record<string, never>, SO = Record<string, never>> {
+export interface SandboxBackend<BO = Record<string, never>, SO = Record<string, never>> {
     /**
      * Stable identifier for this backend implementation.
      *
@@ -113,7 +113,7 @@ export interface SandboxBackend<S extends SandboxSession = SandboxSession, BO =
      * {@link SandboxTemplateNotProvisionedError} when the requested
      * template is missing.
      */
-    create(input: SandboxBackendCreateInput): Promise<SandboxBackendHandle<S, SO>>;
+    create(input: SandboxBackendCreateInput): Promise<SandboxBackendHandle<SO>>;
     /**
      * Build-time prewarm hook. Ash invokes this for every authored
      * sandbox in the compiled graph before serving traffic so the backend

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

@@ -1,12 +1,12 @@
 import type { SandboxSession } from "#shared/sandbox-session.js";
 import type { SandboxBackend } from "#shared/sandbox-backend.js";
 export type SandboxBootstrapUseFn<O = Record<string, never>> = (options?: O) => Promise<SandboxSession>;
-export type SandboxSessionUseFn<S extends SandboxSession = SandboxSession, O = Record<string, never>> = (options?: O) => Promise<S>;
+export type SandboxSessionUseFn<O = Record<string, never>> = (options?: O) => Promise<SandboxSession>;
 export interface SandboxBootstrapContext<O = Record<string, never>> {
     readonly use: SandboxBootstrapUseFn<O>;
 }
-export interface SandboxSessionContext<S extends SandboxSession = SandboxSession, O = Record<string, never>> {
-    readonly use: SandboxSessionUseFn<S, O>;
+export interface SandboxSessionContext<O = Record<string, never>> {
+    readonly use: SandboxSessionUseFn<O>;
 }
 /**
  * Public sandbox definition authored in `agent/sandbox.ts` (shorthand)
@@ -21,7 +21,7 @@ export interface SandboxSessionContext<S extends SandboxSession = SandboxSession
  * `subagents/<name>/sandbox.ts` (or the folder form) and do not inherit
  * their parent's sandbox (skill seeds differ per agent).
  */
-export interface SandboxDefinition<S extends SandboxSession = SandboxSession, BO = Record<string, never>, SO = Record<string, never>> {
+export interface SandboxDefinition<BO = Record<string, never>, SO = Record<string, never>> {
     /**
      * Backend that runs this sandbox.
      *
@@ -31,7 +31,7 @@ export interface SandboxDefinition<S extends SandboxSession = SandboxSession, BO
      * everywhere else. Set `backend` explicitly to pin the sandbox to a
      * specific backend regardless of environment.
      */
-    backend: SandboxBackend<S, BO, SO>;
+    backend: SandboxBackend<BO, SO>;
     bootstrap?(input: SandboxBootstrapContext<BO>): Promise<void> | void;
-    onSession?(input: SandboxSessionContext<S, SO>): Promise<void> | void;
+    onSession?(input: SandboxSessionContext<SO>): Promise<void> | void;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "experimental-ash",
-  "version": "0.18.1",
+  "version": "0.18.2",
   "bin": {
     "ash": "./bin/ash.js",
     "experimental-ash": "./bin/ash.js"