eve 0.30.8 → 0.31.0

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

@@ -1,44 +1,33 @@
 import type { UserContent } from "ai";
-import type { CrossChannelReceiveFn } from "#channel/cross-channel-receive.js";
-import type { CancelTurnResult, ClearSessionResult, CompactSessionResult, SessionAuthContext, SessionCallback, SessionCapabilities, TurnCaller } from "#channel/types.js";
+import type { CrossChannelToFn } from "#channel/cross-channel-receive.js";
+import type { ChannelFrom, ChannelResolveSession } from "#channel/channel-operations.js";
 import type { InputResponse } from "#runtime/input/types.js";
 import type { Session } from "#channel/session.js";
-import type { RunMode } from "#shared/run-mode.js";
 import type { JsonObject } from "#shared/json.js";
 import type { ChannelMethod } from "#public/definitions/channel.js";
 type WebSocketHeaders = Headers | readonly (readonly [string, string])[] | Record<string, string>;
 /**
- * Second argument passed to every route handler. `send` starts or continues a
- * session on this channel; `cancel` stops the active turn on a session
- * addressed by continuation token; `clear` removes its model-message history;
- * `compact` summarizes its context without sending model input; `reset` retires
- * a session so its token can start a fresh session; `getSession` looks one up by
- * id; `receive` hands inbound work to a different channel; `params` contains
- * the matched path parameters; `waitUntil` keeps background work alive past
- * the response; `requestIp` is the client IP, or `null` when the host cannot
- * provide it.
+ * Second argument passed to every route handler. `from` binds local operations,
+ * `resolveSession` snapshots the current owner, `to` selects a proactive target
+ * on another channel, and `attachSession` binds an immutable-ID handle.
  */
 export interface RouteHandlerArgs<TState = undefined> {
-    send: SendFn<TState>;
+    /** Binds a raw channel-local address to its current-owner operations. */
+    readonly from: ChannelFrom<TState>;
+    /** Snapshots the session currently owning a raw channel-local address. */
+    readonly resolveSession: ChannelResolveSession;
+    /** Attaches a fixed operation handle to one exact durable session ID without performing I/O. */
+    attachSession: AttachSessionFn;
     /**
-     * Resolves the session currently owning a channel-local continuation token.
-     * This point-in-time lookup does not reserve the continuation.
+     * Selects a proactive target on another channel. Call `.send(message, options)`
+     * on the returned handle; the target channel owns its address and initial state.
      */
-    resolveActiveSession: ResolveActiveSessionFn;
-    cancel: CancelFn;
-    clear: ClearFn;
-    compact: CompactFn;
-    reset: ResetFn;
-    getSession: GetSessionFn;
-    /**
-     * Starts a session on a different channel to hand off inbound work (e.g. an
-     * HTTP webhook routing the conversation onto Slack). The target's authored
-     * `receive` hook owns continuation-token format and initial state; the caller
-     * supplies the payload, channel-specific args, and auth.
-     */
-    receive: CrossChannelReceiveFn;
+    readonly to: CrossChannelToFn;
+    /** Path parameters matched for the current route. */
     params: Readonly<Record<string, string>>;
+    /** Keeps background work alive after the route returns its response. */
     waitUntil: (task: Promise<unknown>) => void;
+    /** Best-effort client IP reported by the host, or `null` when unavailable. */
     requestIp: string | null;
 }
 export interface SendPayload {
@@ -51,130 +40,13 @@ export interface SendPayload {
      */
     readonly context?: readonly string[];
     /**
-     * Run-scoped JSON schema the turn's result must match. Orthogonal to
-     * {@link BaseSendOptions.mode}: eve enforces the schema in either mode; mode
-     * only decides the failure behavior. A conversation run parks recoverably and
-     * waits for more input; a task run (which cannot wait) finishes as an error.
+     * Run-scoped JSON schema the turn's result must match. eve enforces the
+     * schema in conversation and task mode; mode only decides failure behavior.
      */
     readonly outputSchema?: JsonObject;
 }
-/**
- * Starts or continues a session on this channel. Accepts a plain string,
- * `UserContent`, or a {@link SendPayload}, plus {@link SendOptions}. Resolves
- * to the resulting {@link Session}.
- */
-export type SendFn<TState = undefined> = (input: string | UserContent | SendPayload, options: SendOptions<TState>) => Promise<Session>;
-/** Resolves the active owner of a channel-local continuation token. */
-export type ResolveActiveSessionFn = (options: {
-    readonly continuationToken: string;
-}) => Promise<{
-    readonly sessionId: string;
-} | undefined>;
-type BaseSendOptions = {
-    auth: SessionAuthContext | null;
-    callback?: SessionCallback;
-    /** Framework-internal delegated caller waiting on this turn's settled result. */
-    caller?: TurnCaller;
-    capabilities?: SessionCapabilities;
-    continuationToken: string;
-    /**
-     * `"resume"` requires an active session and propagates a typed no-active-session
-     * error. `"resume-or-start"` preserves the default channel behavior.
-     */
-    intent?: "resume" | "resume-or-start";
-    /**
-     * The original (top-level) caller's auth for a newly started session,
-     * becoming `session.auth.initiator`. Defaults to {@link auth} when omitted
-     * (root session behavior). Ignored when the send resolves to an existing
-     * session, whose initiator never changes after start.
-     */
-    initiatorAuth?: SessionAuthContext | null;
-    mode?: RunMode;
-    /**
-     * Human-readable title for a newly started workflow session. Defaults to
-     * the first user message and is ignored when resuming an existing session.
-     */
-    title?: string;
-};
-/**
- * Options for {@link SendFn}. The channel owns its continuation-token
- * format: pass the channel-local raw token (the framework prepends
- * the channel name). Stateful channels also seed initial adapter
- * state via {@link state}, which becomes the new session's `state`
- * on first `runtime.run()` and is ignored on subsequent `deliver`s.
- */
-export type SendOptions<TState = undefined> = [TState] extends [undefined] ? BaseSendOptions : BaseSendOptions & {
-    state: TState;
-};
-/**
- * Resolves an existing {@link Session} by id, for example to read its event
- * stream from within a route handler.
- */
-export type GetSessionFn = (sessionId: string) => Session;
-/**
- * Options for {@link CancelFn}. `continuationToken` is the channel-local raw
- * token, exactly as passed to {@link SendFn}. `turnId` limits the request to
- * the turn the caller observed; a stale guard is consumed as a benign no-op.
- */
-export interface CancelOptions {
-    readonly continuationToken: string;
-    readonly turnId?: string;
-}
-/**
- * Requests cancellation of the active turn on the session that owns the
- * continuation token. Never starts a session, sends input, or clears history.
- *
- * Both statuses are successful: `"accepted"` means the request was consumed,
- * and `"no_active_turn"` covers an unknown token and a session with nothing
- * to cancel. Confirmation is `turn.cancelled` followed by `session.waiting`
- * on the event stream.
- */
-export type CancelFn = (options: CancelOptions) => Promise<CancelTurnResult>;
-/** Options for {@link CompactFn}. */
-export interface CompactOptions {
-    /** Channel-local raw token, in the same format accepted by {@link SendFn}. */
-    readonly continuationToken: string;
-}
-/**
- * Queues context compaction for the session owning a continuation token.
- * Never sends model input or starts a new session. An accepted request returns
- * to `session.waiting`; successful compaction emits `compaction.requested`
- * followed by `compaction.completed` on the session stream.
- */
-export type CompactFn = (options: CompactOptions) => Promise<CompactSessionResult>;
-/** Options for {@link ClearFn}. */
-export interface ClearOptions {
-    /** Channel-local raw token, in the same format accepted by {@link SendFn}. */
-    readonly continuationToken: string;
-}
-/**
- * Queues removal of the model-message history for the session owning a
- * continuation token. Preserves the session, agent configuration, durable
- * state, limits, and sandbox. Completion is `context.cleared` followed by
- * `session.waiting` on the session stream.
- */
-export type ClearFn = (options: ClearOptions) => Promise<ClearSessionResult>;
-/** Options for {@link ResetFn}. */
-export interface ResetOptions {
-    /** Channel-local raw token, in the same format accepted by {@link SendFn}. */
-    readonly continuationToken: string;
-    /** Human-readable terminal reason. Do not include credentials or message contents. */
-    readonly reason?: string;
-}
-/** Result of resetting the session that owned a continuation token. */
-export type ResetResult = {
-    readonly status: "reset";
-    readonly previousSessionId: string;
-} | {
-    readonly status: "no_active_session";
-};
-/**
- * Terminally retires the session currently owning a continuation token.
- * The token is available for the next {@link SendFn} after this resolves;
- * that send starts with fresh history and state, and initializes a new
- * session-scoped sandbox on first sandbox use.
- */
-export type ResetFn = (options: ResetOptions) => Promise<ResetResult>;
+/** Attaches an I/O-free handle to one exact durable session ID. */
+export type AttachSessionFn = (sessionId: string) => Session;
 export type RouteHandler<TState = undefined> = (req: Request, args: RouteHandlerArgs<TState>) => Promise<Response>;
 /**
  * A connected WebSocket peer passed to every {@link WebSocketRouteHooks}

package/dist/src/channel/schedule.d.ts

@@ -28,7 +28,7 @@ export interface ScheduleDispatchInput {
  *
  * For handler schedules: builds {@link ScheduleHandlerArgs} against the
  * request-scoped channel bundle and invokes the author's `run`. The
- * author owns control flow — `args.receive(channel, …)` hands work off
+ * author owns control flow — `args.to(channel, target).send(…)` hands work off
  * to a channel; `args.waitUntil(promise)` extends the task lifetime
  * so the dispatcher awaits in-flight work before settling.
  *

package/dist/src/channel/schedule.js

@@ -1 +1 @@
-import{createSession}from"#channel/session.js";import{SCHEDULE_APP_AUTH,SCHEDULE_APP_AUTH as SCHEDULE_APP_AUTH$1}from"#channel/schedule-auth.js";import{createCrossChannelReceiveFn,toCrossChannelTargets}from"#channel/cross-channel-receive.js";import{expectFunction}from"#internal/authored-module.js";const SCHEDULE_ADAPTER_KIND=`schedule`,SCHEDULE_ADAPTER={kind:SCHEDULE_ADAPTER_KIND};var ScheduleDispatcher=class{runtime;channels;constructor(e){this.runtime=e.runtime,this.channels=e.channels}async trigger(e){let t=[],i=[],a=createCrossChannelReceiveFn(this.runtime,toCrossChannelTargets(this.channels)),o={appAuth:SCHEDULE_APP_AUTH$1,receive:async(e,n)=>{let r=await a(e,n);return t.push(r),r},waitUntil(e){i.push(e)}};if(e.run)await e.run(o);else if(e.markdown!==void 0){let n=await this.runMarkdown(e.markdown);t.push(n)}else throw Error(`Schedule "${e.scheduleId}" has neither "run" nor "markdown" — at least one must be set.`);return{sessions:t,waitUntilTasks:i}}async runMarkdown(t){let r=await this.runtime.createSession({adapter:SCHEDULE_ADAPTER,auth:SCHEDULE_APP_AUTH$1,input:{message:t},mode:`task`});return createSession(r.sessionId,r.continuationToken,this.runtime)}};function expectScheduleRun(e,t,n){let r=e;if(typeof r!=`object`||!r)throw Error(`Schedule export "${n??`default`}" from "${t}" must be an object.`);return expectFunction(r.run,`Expected the schedule export "${n??`default`}" from "${t}" to export a \`run\` handler function.`)}export{SCHEDULE_ADAPTER,SCHEDULE_ADAPTER_KIND,SCHEDULE_APP_AUTH,ScheduleDispatcher,expectScheduleRun};
+import{createSession}from"#channel/session.js";import{SCHEDULE_APP_AUTH,SCHEDULE_APP_AUTH as SCHEDULE_APP_AUTH$1}from"#channel/schedule-auth.js";import{createCrossChannelToFn,toCrossChannelTargets}from"#channel/cross-channel-receive.js";import{expectFunction}from"#internal/authored-module.js";const SCHEDULE_ADAPTER_KIND=`schedule`,SCHEDULE_ADAPTER={kind:SCHEDULE_ADAPTER_KIND};var ScheduleDispatcher=class{runtime;channels;constructor(e){this.runtime=e.runtime,this.channels=e.channels}async trigger(e){let t=[],a=[],o=createCrossChannelToFn(this.runtime,toCrossChannelTargets(this.channels)),s={appAuth:SCHEDULE_APP_AUTH$1,to(e,n){let r=o(e,n);return{async send(e,n){let i=await r.send(e,n);return t.push(i),i}}},waitUntil(e){a.push(e)}};if(e.run)await e.run(s);else if(e.markdown!==void 0){let n=await this.runMarkdown(e.markdown);t.push(n)}else throw Error(`Schedule "${e.scheduleId}" has neither "run" nor "markdown" — at least one must be set.`);return{sessions:t,waitUntilTasks:a}}async runMarkdown(t){return createSession((await this.runtime.createSession({adapter:SCHEDULE_ADAPTER,auth:SCHEDULE_APP_AUTH$1,input:{message:t},mode:`task`})).sessionId,this.runtime)}};function expectScheduleRun(e,t,n){let r=e;if(typeof r!=`object`||!r)throw Error(`Schedule export "${n??`default`}" from "${t}" must be an object.`);return expectFunction(r.run,`Expected the schedule export "${n??`default`}" from "${t}" to export a \`run\` handler function.`)}export{SCHEDULE_ADAPTER,SCHEDULE_ADAPTER_KIND,SCHEDULE_APP_AUTH,ScheduleDispatcher,expectScheduleRun};

package/dist/src/channel/send-input.d.ts

@@ -0,0 +1,6 @@
+import type { UserContent } from "ai";
+import type { SendPayload } from "#channel/routes.js";
+/** Normalizes the shorthand input forms accepted by channel and session sends. */
+export declare function normalizeSendInput(input: string | UserContent | SendPayload): SendPayload;
+/** Serializes non-data URL file parts before input crosses the durable boundary. */
+export declare function serializeUrlFilePartsInMessage(message: string | UserContent | undefined): string | UserContent | undefined;

package/dist/src/channel/send-input.js

@@ -0,0 +1 @@
+import{serializeUrlFilePart}from"#internal/attachments/url-refs.js";function normalizeSendInput(e){return typeof e==`string`||Array.isArray(e)?{message:e}:e}function serializeUrlFilePartsInMessage(t){if(t===void 0||typeof t==`string`)return t;let n=!1,r=t.map(t=>t.type===`file`&&t.data instanceof URL&&t.data.protocol!==`data:`?(n=!0,{...t,data:serializeUrlFilePart(t.data)}):t);return n?r:t}export{normalizeSendInput,serializeUrlFilePartsInMessage};

package/dist/src/channel/session.d.ts

@@ -1,56 +1,67 @@
 import type { ContextAccessor } from "#context/key.js";
 import type { MessageStreamEvent } from "#protocol/message.js";
-import type { CancelTurnResult, Runtime } from "#channel/types.js";
+import type { UserContent } from "ai";
+import type { CancelTurnResult, ClearSessionResult, CompactSessionResult, ResetSessionResult, Runtime, SessionAuthContext, SessionCallback, SessionSendCommandResult, TurnCaller } from "#channel/types.js";
 import type { SessionAuth } from "#context/keys.js";
-/**
- * Result of starting or delivering to a session. Exposes the session
- * `id`, its channel-local `continuationToken`, and `getEventStream`, which
- * resolves to a `ReadableStream` of the session's harness events
- * (optionally from `startIndex`). Returned by {@link SendFn},
- * {@link GetSessionFn}, and a channel's `receive` hook. Unlike the live
- * {@link SessionHandle} on `ctx.session`, this is an inert result value:
- * its fields are snapshots and it cannot mutate the continuation token.
- */
+import type { InputResponse } from "#runtime/input/types.js";
+import type { JsonObject } from "#shared/json.js";
+/** Immutable-ID handle for one exact durable session. */
 export interface Session {
     readonly id: string;
-    readonly continuationToken: string;
-    /**
-     * Requests cancellation of this session's in-flight turn. `turnId` limits
-     * the request to the turn the caller observed. Both statuses are
-     * successful; confirmation is `turn.cancelled` followed by
-     * `session.waiting` on the event stream.
-     */
+    /** Sends a message to this exact session ID without creating or following a replacement. */
+    send(message: string | UserContent, options: SessionSendOptions): Promise<SessionSendCommandResult>;
+    /** Answers pending input requests on this exact session ID. */
+    respond(inputResponses: readonly InputResponse[], options: SessionRespondOptions): Promise<SessionSendCommandResult>;
+    /** Requests cancellation of this exact session's active turn. */
     cancel(options?: {
         turnId?: string;
     }): Promise<CancelTurnResult>;
-    /**
-     * Opens the durable event stream. Negative start indexes read relative to
-     * the current tail (`-1` starts at the latest event).
-     */
+    /** Queues compaction on this exact session ID. */
+    compact(): Promise<CompactSessionResult>;
+    /** Queues a context clear on this exact session ID. */
+    clear(): Promise<ClearSessionResult>;
+    /** Terminally retires this exact session ID. */
+    reset(options?: {
+        reason?: string;
+    }): Promise<ResetSessionResult>;
     getEventStream(options?: {
         startIndex?: number;
     }): Promise<ReadableStream<MessageStreamEvent>>;
-    /**
-     * Resolves the durable tail of the event stream: the zero-based index of
-     * the last recorded event, or `-1` before the first.
-     */
     getStreamTailIndex(): Promise<number>;
 }
+interface SessionDeliveryOptions {
+    readonly auth: SessionAuthContext | null;
+    /** Public callback destination for a delegated continuation turn. */
+    readonly callback?: SessionCallback;
+    readonly context?: readonly string[];
+    readonly outputSchema?: JsonObject;
+}
+/** Options for sending a message through a fixed session handle. */
+export type SessionSendOptions = SessionDeliveryOptions;
+/** Options for answering pending input requests through a fixed session handle. */
+export type SessionRespondOptions = SessionDeliveryOptions;
 /**
  * Live handle to the current session, exposed on `ctx.session` to
  * `deliver` and event handlers. The framework hydrates the read-only
  * fields from the active context at step start. A write through
- * {@link SessionHandle.setContinuationToken} updates the context so the
+ * `continuation.rekey()` updates the context so the
  * runtime can re-key the parked workflow hook at the next step boundary.
  */
 export interface SessionHandle {
     readonly id: string;
-    readonly continuationToken: string;
     readonly auth: SessionAuth;
-    setContinuationToken(rawToken: string): void;
+    readonly continuation?: {
+        readonly token: string;
+        rekey(rawToken: string): void;
+    };
 }
-export declare function createSession(id: string, continuationToken: string, runtime: Runtime): Session;
-export declare function createGetSessionFn(runtime: Runtime): (sessionId: string) => Session;
+export declare function createSession(id: string, runtime: Runtime, metadata?: {
+    readonly requestId?: string;
+}): Session;
+/** Builds an I/O-free factory for fixed session-ID handles. */
+export declare function createAttachSessionFn(runtime: Runtime, metadata?: {
+    readonly requestId?: string;
+}): (sessionId: string) => Session;
 /**
  * Builds a live {@link SessionHandle} backed by the active context
  * accessor. Read-only fields resolve through getters so they reflect
@@ -62,3 +73,6 @@ export declare function createGetSessionFn(runtime: Runtime): (sessionId: string
  * every adapter handler invocation.
  */
 export declare function buildSessionHandle(accessor: ContextAccessor): SessionHandle;
+/** @internal Converts validated public callback metadata into runtime turn routing. */
+export declare function sessionCallbackToTurnCaller(callback: SessionCallback | undefined): TurnCaller | undefined;
+export {};

package/dist/src/channel/session.js

@@ -1 +1 @@
-import{AuthKey,ContinuationTokenKey,InitiatorAuthKey,SessionIdKey}from"#context/keys.js";function createSession(e,t,n){return{id:e,continuationToken:t,async cancel(t){return n.dispatchSession({command:{kind:`cancel`,turnId:t?.turnId},sessionId:e})},async getEventStream(t){return n.getEventStream(e,t)},async getStreamTailIndex(){return n.getStreamTailIndex(e)}}}function createGetSessionFn(e){return t=>createSession(t,``,e)}function buildSessionHandle(i){return{get id(){return i.get(SessionIdKey)??``},get continuationToken(){return i.get(ContinuationTokenKey)??``},get auth(){return{current:i.get(AuthKey)??null,initiator:i.get(InitiatorAuthKey)??null}},setContinuationToken(e){let n=i.get(ContinuationTokenKey)??``,r=namespaceContinuationToken(n,e);n!==r&&i.set(ContinuationTokenKey,r)}}}function namespaceContinuationToken(e,t){let n=e.indexOf(`:`);if(n<=0)throw Error(`Cannot set session continuation token without an existing namespaced continuation token. Start the session with a placeholder continuationToken.`);return`${e.slice(0,n+1)}${t}`}export{buildSessionHandle,createGetSessionFn,createSession};
+import{serializeUrlFilePartsInMessage}from"#channel/send-input.js";import{AuthKey,ContinuationTokenKey,InitiatorAuthKey,SessionIdKey}from"#context/keys.js";import{toChannelLocalContinuationToken}from"#shared/continuation-token.js";function createSession(t,n,r={}){return{id:t,async send(i,a){let o=sessionCallbackToTurnCaller(a.callback),s={message:serializeUrlFilePartsInMessage(i)};a.context!==void 0&&(s.context=a.context),a.outputSchema!==void 0&&(s.outputSchema=a.outputSchema);let c={auth:a.auth,kind:`send`,payload:s,requestId:r.requestId};return await n.dispatchSession({command:o===void 0?c:{...c,caller:o},sessionId:t})},async respond(e,i){if(e.length===0)throw Error(`respond() requires at least one input response.`);let a=sessionCallbackToTurnCaller(i.callback),o={inputResponses:e};i.context!==void 0&&(o.context=i.context),i.outputSchema!==void 0&&(o.outputSchema=i.outputSchema);let s={auth:i.auth,kind:`send`,payload:o,requestId:r.requestId};return await n.dispatchSession({command:a===void 0?s:{...s,caller:a},sessionId:t})},async cancel(e){return await n.dispatchSession({command:{kind:`cancel`,turnId:e?.turnId},sessionId:t})},async compact(){return await n.dispatchSession({command:{kind:`compact`},sessionId:t})},async clear(){return await n.dispatchSession({command:{kind:`clear`},sessionId:t})},async reset(e){return await n.dispatchSession({command:{kind:`reset`,reason:e?.reason},sessionId:t})},async getEventStream(e){return n.getEventStream(t,e)},async getStreamTailIndex(){return n.getStreamTailIndex(t)}}}function createAttachSessionFn(e,t={}){return n=>createSession(n,e,t)}function buildSessionHandle(e){return{get id(){return e.get(SessionIdKey)??``},get auth(){return{current:e.get(AuthKey)??null,initiator:e.get(InitiatorAuthKey)??null}},get continuation(){let t=e.get(ContinuationTokenKey);if(!(t===void 0||t.length===0))return{token:toChannelLocalContinuationToken(t),rekey(r){let i=namespaceContinuationToken(t,r);t!==i&&e.set(ContinuationTokenKey,i)}}}}}function namespaceContinuationToken(e,t){let n=e.indexOf(`:`);if(n<=0)throw Error(`Cannot set session continuation token without an existing namespaced continuation token. Start the session with a placeholder continuationToken.`);return`${e.slice(0,n+1)}${t}`}function sessionCallbackToTurnCaller(e){return e===void 0?void 0:{callId:e.callId,replyTo:{kind:`callback`,url:e.url},subagentName:e.subagentName}}export{buildSessionHandle,createAttachSessionFn,createSession,sessionCallbackToTurnCaller};

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

@@ -1,6 +1,6 @@
 import type { UserContent } from "ai";
 import type { UnstampedMessageStreamEvent, MessageStreamEvent } from "#protocol/message.js";
-import type { CancelTurnStatus } from "#protocol/cancel-turn.js";
+import type { CancelTurnResult as ProtocolCancelTurnResult } from "#protocol/cancel-turn.js";
 import type { RunMode } from "#shared/run-mode.js";
 import type { RuntimeSubagentChildResult } from "#runtime/actions/types.js";
 import type { InputRequest, InputResponse } from "#runtime/input/types.js";
@@ -18,19 +18,7 @@ export interface CancelTurnInput {
     readonly turnId?: string;
 }
 /** Result of requesting turn cancellation. Both statuses are successful. */
-export interface CancelTurnResult {
-    readonly status: CancelTurnStatus;
-    /**
-     * For `no_active_turn`: the error class that classified the target as
-     * inactive, distinguishing "already finished" (`HookNotFoundError`) from a
-     * transiently unreachable cancel hook (`EntityConflictError`).
-     */
-    readonly reason?: string;
-}
-/** Identifies the continuation hook whose durable session should compact. */
-export interface CompactSessionInput {
-    readonly continuationToken: string;
-}
+export type CancelTurnResult = ProtocolCancelTurnResult;
 /** Result of queueing manual context compaction for a session. */
 export type CompactSessionResult = {
     readonly status: "accepted";
@@ -38,10 +26,6 @@ export type CompactSessionResult = {
 } | {
     readonly status: "no_active_session";
 };
-/** Identifies the continuation hook whose durable session should clear context. */
-export interface ClearSessionInput {
-    readonly continuationToken: string;
-}
 /** Result of queueing a manual context clear for a session. */
 export type ClearSessionResult = {
     readonly status: "accepted";
@@ -49,18 +33,6 @@ export type ClearSessionResult = {
 } | {
     readonly status: "no_active_session";
 };
-/** Identifies a session to transition permanently to a terminal state. */
-export interface TerminateSessionInput {
-    /** Human-readable reason recorded on the terminal workflow transition. */
-    readonly reason?: string;
-    readonly sessionId: string;
-}
-/** Result of attempting to terminally retire a session. */
-export type TerminateSessionResult = {
-    readonly status: "terminated";
-} | {
-    readonly status: "already_terminal";
-};
 /**
  * Identifies one turn within a session.
  *
@@ -177,7 +149,8 @@ export type SessionSendCommandResult = {
 } | {
     readonly status: "session_not_active";
 };
-export type ResetSessionCommandResult = {
+/** Result of terminally resetting a session. */
+export type ResetSessionResult = {
     readonly status: "reset";
     readonly previousSessionId: string;
 } | {
@@ -191,7 +164,7 @@ export type SessionCommandResult<TCommand extends SessionCommand = SessionComman
     readonly kind: "compact";
 } ? CompactSessionResult : TCommand extends {
     readonly kind: "clear";
-} ? ClearSessionResult : ResetSessionCommandResult;
+} ? ClearSessionResult : ResetSessionResult;
 export interface DispatchContinuationInput<TCommand extends SessionCommand = SessionCommand> {
     readonly command: TCommand;
     readonly continuationToken: string;
@@ -368,9 +341,10 @@ export interface RunInput {
     /**
      * Session continuation token for delivery and hook creation. Channels can
      * re-key the session during the first turn via
-     * `ctx.session.setContinuationToken(...)` (e.g. Slack adopts its first
+     * `ctx.session.continuation.rekey(...)` (e.g. Slack adopts its first
      * post's `ts` as the thread root), so an initial placeholder token is
-     * acceptable when full identity isn't known until the first message.
+     * acceptable when full identity isn't known until the first message. ID-only
+     * transports omit this field.
      */
     readonly continuationToken?: string;
     /**
@@ -440,7 +414,6 @@ export type RunResult = {
  * Carries the identifiers needed for stream endpoints.
  */
 export interface RunHandle {
-    readonly continuationToken: string;
     readonly events: ReadableStream<MessageStreamEvent>;
     /**
      * Runtime-owned identifier for this session. Stream and inspection APIs