eve 0.5.4 → 0.6.0-beta.3

package/dist/src/channel/receive-target.d.ts

@@ -0,0 +1,17 @@
+declare const receiveTargetMarker: unique symbol;
+/**
+ * Structural marker that channel factories (e.g. `slackChannel`,
+ * `twilioChannel`) add to declare the target type their `receive()` accepts.
+ * `receive(channel, { target })` helpers and the route-handler
+ * `args.receive(channel, ...)` read this marker to infer typed targets
+ * from a plain channel import.
+ */
+export interface TypedReceiveTarget<TTarget = Record<string, unknown>> {
+    readonly [receiveTargetMarker]?: TTarget;
+}
+/**
+ * Extracts the receive-target type from a channel value, falling back to
+ * `Record<string, unknown>` when the channel declares no marker.
+ */
+export type InferReceiveTarget<TChannel> = TChannel extends TypedReceiveTarget<infer TTarget> ? TTarget : Record<string, unknown>;
+export {};

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

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

package/dist/src/channel/resolve-text.d.ts

@@ -0,0 +1,19 @@
+import type { InputRequest, InputResponse } from "#runtime/input/types.js";
+/**
+ * Maps freeform text to an {@link InputResponse} for a single request.
+ *
+ * Emitters import this utility to resolve text-based user input against
+ * pending request options. The harness and runtime do not call it.
+ *
+ * Resolution order:
+ * 1. Exact option ID (case-insensitive)
+ * 2. Exact option label (case-insensitive)
+ * 3. 1-based numeric index into the options array
+ * 4. Freeform text if {@link InputRequest.allowFreeform} is not `false`
+ */
+export declare function resolveTextToResponse(text: string, request: InputRequest): InputResponse | undefined;
+/**
+ * Resolves text against all pending requests, returning one
+ * {@link InputResponse} for each request that could be matched.
+ */
+export declare function resolveTextToResponses(text: string, requests: readonly InputRequest[]): readonly InputResponse[];

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

@@ -0,0 +1 @@
+function resolveTextToResponse(e,t){let n=e.trim();if(n.length===0)return;let r=n.toLowerCase();if(t.options!==void 0&&t.options.length>0){let e=matchOption(r,t.options);if(e!==void 0)return{requestId:t.requestId,optionId:e.id}}if((t.allowFreeform===!0||t.options===void 0||t.options.length===0)&&n.length>0)return{requestId:t.requestId,text:n}}function resolveTextToResponses(e,t){let n=[];for(let r of t){let t=resolveTextToResponse(e,r);t!==void 0&&n.push(t)}return n}function matchOption(e,t){let n=t.find(t=>t.id.toLowerCase()===e);if(n!==void 0)return n;let r=t.find(t=>t.label.toLowerCase()===e);if(r!==void 0)return r;let i=Number(e);if(Number.isInteger(i)&&i>0&&i<=t.length)return t[i-1]}export{resolveTextToResponse,resolveTextToResponses};

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

@@ -0,0 +1,217 @@
+import type { UserContent } from "ai";
+import type { CrossChannelReceiveFn } from "#channel/cross-channel-receive.js";
+import type { SessionAuthContext, SessionCallback } from "#channel/types.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; `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.
+ */
+export interface RouteHandlerArgs<TState = undefined> {
+    send: SendFn<TState>;
+    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;
+    params: Readonly<Record<string, string>>;
+    waitUntil: (task: Promise<unknown>) => void;
+    requestIp: string | null;
+}
+export interface SendPayload {
+    readonly message?: string | UserContent;
+    readonly inputResponses?: readonly InputResponse[];
+    /**
+     * Context strings contributed by the channel. Eve appends each entry
+     * as a `role: "user"` message to `session.history` before the delivery
+     * message and persists it across the session.
+     */
+    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.
+     */
+    readonly outputSchema?: JsonObject;
+}
+/**
+ * Starts or continues a session on this channel. Accepts a plain string,
+ * `UserContent`, or a {@link SendPayload}, plus {@link SendOptions} (auth,
+ * continuation token, run mode, and an optional seed `state` for stateful
+ * channels). Resolves to the resulting {@link Session}.
+ */
+export type SendFn<TState = undefined> = (input: string | UserContent | SendPayload, options: SendOptions<TState>) => Promise<Session>;
+type BaseSendOptions = {
+    auth: SessionAuthContext | null;
+    callback?: SessionCallback;
+    continuationToken: string;
+    mode?: RunMode;
+};
+/**
+ * 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;
+export type RouteHandler<TState = undefined> = (req: Request, args: RouteHandlerArgs<TState>) => Promise<Response>;
+/**
+ * A connected WebSocket peer passed to every {@link WebSocketRouteHooks}
+ * callback. Send frames with `send`; manage pub/sub topics with `subscribe`,
+ * `unsubscribe`, and `publish` (`topics` is the current subscription set).
+ * `close` closes gracefully; `terminate` aborts the socket immediately.
+ */
+export interface WebSocketPeer {
+    readonly id: string;
+    readonly context: Record<string, unknown>;
+    readonly namespace: string;
+    readonly request: Request;
+    readonly remoteAddress?: string;
+    readonly topics: Set<string>;
+    close(code?: number, reason?: string): void;
+    publish(topic: string, data: unknown, options?: {
+        compress?: boolean;
+    }): void;
+    send(data: unknown, options?: {
+        compress?: boolean;
+    }): number | void | undefined;
+    subscribe(topic: string): void;
+    terminate(): void;
+    unsubscribe(topic: string): void;
+}
+/**
+ * An inbound WebSocket frame passed to the `message` hook. `rawData` is the
+ * original payload as received; `data` is the decoded value. Use `json`,
+ * `text`, `arrayBuffer`, `blob`, or `uint8Array` to decode it explicitly.
+ */
+export interface WebSocketMessage {
+    readonly data: unknown;
+    readonly id: string;
+    readonly rawData: unknown;
+    arrayBuffer(): ArrayBuffer | SharedArrayBuffer;
+    blob(): Blob;
+    json<T = unknown>(): T;
+    text(): string;
+    uint8Array(): Uint8Array;
+}
+/**
+ * The `Request` passed to the `upgrade` hook, extended with an optional
+ * `context` bag carrying host-supplied data for the upgrade.
+ */
+export interface WebSocketUpgradeRequest extends Request {
+    readonly context?: Record<string, unknown>;
+}
+/**
+ * Return value of the `upgrade` hook. Return an object to attach `context`,
+ * `headers`, or a `namespace`, or to mark the upgrade `handled`; return a
+ * `Response` to reject the handshake; return `void` to proceed with defaults.
+ */
+export type WebSocketUpgradeResult = {
+    readonly context?: Record<string, unknown>;
+    readonly handled?: boolean;
+    readonly headers?: WebSocketHeaders;
+    readonly namespace?: string;
+} | Response | void;
+/**
+ * Lifecycle callbacks for a WebSocket connection. `open`, `message`, `close`,
+ * and `error` react to peer activity; `upgrade` runs first and may rewrite or
+ * short-circuit the handshake by returning a {@link WebSocketUpgradeResult}.
+ */
+export interface WebSocketRouteHooks {
+    close?(peer: WebSocketPeer, details: {
+        code?: number;
+        reason?: string;
+    }): void | Promise<void>;
+    error?(peer: WebSocketPeer, error: Error): void | Promise<void>;
+    message?(peer: WebSocketPeer, message: WebSocketMessage): void | Promise<void>;
+    open?(peer: WebSocketPeer): void | Promise<void>;
+    upgrade?(request: WebSocketUpgradeRequest): Promise<WebSocketUpgradeResult> | WebSocketUpgradeResult;
+}
+/**
+ * Handler for a {@link WS} route. Runs once per upgrade request and returns the
+ * {@link WebSocketRouteHooks} for that connection.
+ */
+export type WebSocketRouteHandler<TState = undefined> = (req: Request, args: RouteHandlerArgs<TState>) => Promise<WebSocketRouteHooks> | WebSocketRouteHooks;
+/**
+ * An HTTP route descriptor (method, path, handler). `transport` is optional and
+ * treated as `"http"`: any route whose `transport` is not `"websocket"` is
+ * dispatched over HTTP.
+ */
+export interface HttpRouteDefinition<TState = undefined> {
+    readonly transport?: "http";
+    readonly method: ChannelMethod;
+    readonly path: string;
+    readonly handler: RouteHandler<TState>;
+}
+/**
+ * A WebSocket route descriptor produced by {@link WS}. Its `handler` returns the
+ * {@link WebSocketRouteHooks} for each connection.
+ */
+export interface WebSocketRouteDefinition<TState = undefined> {
+    readonly transport: "websocket";
+    readonly method: "WEBSOCKET";
+    readonly path: string;
+    readonly handler: WebSocketRouteHandler<TState>;
+}
+/**
+ * A single channel route: either an {@link HttpRouteDefinition} or a
+ * {@link WebSocketRouteDefinition}. Produced by the {@link GET}, {@link POST},
+ * {@link PUT}, {@link PATCH}, {@link DELETE}, and {@link WS} helpers and listed
+ * in a channel's `routes` array.
+ */
+export type RouteDefinition<TState = undefined> = HttpRouteDefinition<TState> | WebSocketRouteDefinition<TState>;
+/**
+ * Declares an HTTP `GET` route at `path`, dispatching to `handler`. The handler
+ * receives the `Request` and {@link RouteHandlerArgs}.
+ */
+export declare function GET<TState = undefined>(path: string, handler: RouteHandler<TState>): HttpRouteDefinition<TState>;
+/**
+ * Declares an HTTP `POST` route at `path`. See {@link GET} for the handler
+ * contract.
+ */
+export declare function POST<TState = undefined>(path: string, handler: RouteHandler<TState>): HttpRouteDefinition<TState>;
+/**
+ * Declares an HTTP `PUT` route at `path`. See {@link GET} for the handler
+ * contract.
+ */
+export declare function PUT<TState = undefined>(path: string, handler: RouteHandler<TState>): HttpRouteDefinition<TState>;
+/**
+ * Declares an HTTP `PATCH` route at `path`. See {@link GET} for the handler
+ * contract.
+ */
+export declare function PATCH<TState = undefined>(path: string, handler: RouteHandler<TState>): HttpRouteDefinition<TState>;
+/**
+ * Declares an HTTP `DELETE` route at `path`. See {@link GET} for the handler
+ * contract.
+ */
+export declare function DELETE<TState = undefined>(path: string, handler: RouteHandler<TState>): HttpRouteDefinition<TState>;
+/**
+ * Declares a WebSocket channel route.
+ *
+ * The handler runs once per upgrade request and returns lifecycle hooks for
+ * that connection. The hooks are Eve-owned structural types so channel authors
+ * can use CrossWS-compatible helpers without Eve exposing CrossWS directly.
+ */
+export declare function WS<TState = undefined>(path: string, handler: WebSocketRouteHandler<TState>): WebSocketRouteDefinition<TState>;
+export declare function isHttpRouteDefinition<TState>(route: RouteDefinition<TState>): route is HttpRouteDefinition<TState>;
+export declare function isWebSocketRouteDefinition<TState>(route: RouteDefinition<TState>): route is WebSocketRouteDefinition<TState>;
+export {};

package/dist/src/channel/routes.js

@@ -0,0 +1 @@
+function GET(e,t){return{transport:`http`,method:`GET`,path:e,handler:t}}function POST(e,t){return{transport:`http`,method:`POST`,path:e,handler:t}}function PUT(e,t){return{transport:`http`,method:`PUT`,path:e,handler:t}}function PATCH(e,t){return{transport:`http`,method:`PATCH`,path:e,handler:t}}function DELETE(e,t){return{transport:`http`,method:`DELETE`,path:e,handler:t}}function WS(e,t){return{transport:`websocket`,method:`WEBSOCKET`,path:e,handler:t}}function isHttpRouteDefinition(e){return e.transport!==`websocket`}function isWebSocketRouteDefinition(e){return e.transport===`websocket`}export{DELETE,GET,PATCH,POST,PUT,WS,isHttpRouteDefinition,isWebSocketRouteDefinition};

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

@@ -0,0 +1,66 @@
+import type { ChannelAdapter } from "#channel/adapter.js";
+import { type Session } from "#channel/session.js";
+import type { Runtime, SessionAuthContext } from "#channel/types.js";
+import type { ScheduleRunHandler } from "#public/definitions/schedule.js";
+import type { ResolvedChannelDefinition } from "#runtime/types.js";
+/**
+ * Pre-built application auth context handed to schedules. Schedules
+ * run on behalf of the agent itself, not a downstream user.
+ */
+export declare const SCHEDULE_APP_AUTH: SessionAuthContext;
+/**
+ * Durable adapter kind used when a schedule fires without targeting a
+ * channel — the markdown form, and the synthesized run the dispatcher
+ * builds for it.
+ *
+ * Framework-owned — authored code never constructs a schedule adapter
+ * directly. Registered in `FRAMEWORK_ADAPTERS`.
+ */
+export declare const SCHEDULE_ADAPTER_KIND = "schedule";
+export declare const SCHEDULE_ADAPTER: ChannelAdapter;
+/**
+ * Loaded shape of one schedule for the dispatcher. Either `run` is
+ * defined (authored handler) or `markdown` is defined (fire-and-forget).
+ */
+export interface ScheduleDispatchInput {
+    readonly scheduleId: string;
+    readonly run?: ScheduleRunHandler;
+    readonly markdown?: string;
+}
+/**
+ * Dispatches scheduled task execution.
+ *
+ * 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
+ * to a channel; `args.waitUntil(promise)` extends the task lifetime
+ * so the dispatcher awaits in-flight work before settling.
+ *
+ * For markdown schedules: synthesizes a channel-less run that starts a
+ * session with {@link SCHEDULE_ADAPTER} in task mode and the markdown
+ * body as the message.
+ *
+ * Returns a {@link ScheduleDispatchResult} carrying any sessions the
+ * handler started (for telemetry / task-result observability) and the
+ * `waitUntil` promises the handler registered.
+ */
+export interface ScheduleDispatchResult {
+    readonly sessions: readonly Session[];
+    readonly waitUntilTasks: readonly Promise<unknown>[];
+}
+export declare class ScheduleDispatcher {
+    private readonly runtime;
+    private readonly channels;
+    constructor(config: {
+        readonly runtime: Runtime;
+        readonly channels: readonly ResolvedChannelDefinition[];
+    });
+    trigger(input: ScheduleDispatchInput): Promise<ScheduleDispatchResult>;
+    private runMarkdown;
+}
+/**
+ * Convenience: extract a `run` function from one loaded schedule module
+ * value, or throw with the file path so misconfigured modules fail
+ * obviously instead of crashing deep inside the dispatcher.
+ */
+export declare function expectScheduleRun(value: unknown, logicalPath: string, exportName: string | undefined): ScheduleRunHandler;

package/dist/src/channel/schedule.js

@@ -0,0 +1 @@
+import{createSession}from"#channel/session.js";import{createCrossChannelReceiveFn,toCrossChannelTargets}from"#channel/cross-channel-receive.js";import{expectFunction}from"#internal/authored-module.js";const SCHEDULE_APP_AUTH={attributes:{},authenticator:`app`,principalId:`eve:app`,principalType:`runtime`},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 r=[],a=[],o=createCrossChannelReceiveFn(this.runtime,toCrossChannelTargets(this.channels)),s={appAuth:SCHEDULE_APP_AUTH,receive:async(e,t)=>{let n=await o(e,t);return r.push(n),n},waitUntil(e){a.push(e)}};if(e.run)await e.run(s);else if(e.markdown!==void 0){let t=await this.runMarkdown(e.markdown);r.push(t)}else throw Error(`Schedule "${e.scheduleId}" has neither "run" nor "markdown" — at least one must be set.`);return{sessions:r,waitUntilTasks:a}}async runMarkdown(t){let n=await this.runtime.run({adapter:SCHEDULE_ADAPTER,auth:SCHEDULE_APP_AUTH,input:{message:t},mode:`task`});return createSession(n.sessionId,n.continuationToken,this.runtime)}};function expectScheduleRun(e,t,n){let i=e;if(typeof i!=`object`||!i)throw Error(`Schedule export "${n??`default`}" from "${t}" must be an object.`);return expectFunction(i.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.d.ts

@@ -0,0 +1,4 @@
+import type { ChannelAdapter } from "#channel/adapter.js";
+import type { Runtime } from "#channel/types.js";
+import type { SendFn } from "#channel/routes.js";
+export declare function createSendFn<TState = undefined>(runtime: Runtime, adapter: ChannelAdapter<any>, channelName: string): SendFn<TState>;

package/dist/src/channel/send.js

@@ -0,0 +1 @@
+import{createSession}from"#channel/session.js";import{createLogger}from"#internal/logging.js";import{isRuntimeNoActiveSessionError}from"#execution/runtime-errors.js";import{serializeUrlFilePart}from"#internal/attachments/url-refs.js";const log=createLogger(`channel.send`);function createSendFn(t,r,i){return async(a,o)=>{let s=o.auth,c=o.callback,l=o.mode??`conversation`,u=o.state,d=o.continuationToken,f=`${i}:${d}`,{message:p,inputResponses:m,context:h,outputSchema:g}=normalizeSendInput(a),_=serializeUrlFilePartsInMessage(p);try{let{sessionId:n}=await t.deliver({auth:s,continuationToken:f,payload:{inputResponses:m,message:_,context:h,outputSchema:g}});return createSession(n,d,t)}catch(e){isRuntimeNoActiveSessionError(e)||log.warn(`deliver failed, falling back to starting a new session`,{continuationToken:f})}if(m&&m.length>0)throw Error(`Cannot deliver inputResponses — the target session was not found via continuation token.`);let v=u?{...r,state:{...r.state,...u}}:r;return createSession((await t.run({adapter:v,auth:s,capabilities:l===`conversation`?{requestInput:!0}:void 0,channelName:i,callback:c,continuationToken:f,input:{message:_??``,context:h,outputSchema:g},mode:l})).sessionId,d,t)}}function serializeUrlFilePartsInMessage(e){if(e===void 0||typeof e==`string`)return e;let t=!1,n=e.map(e=>e.type===`file`&&e.data instanceof URL&&e.data.protocol!==`data:`?(t=!0,{...e,data:serializeUrlFilePart(e.data)}):e);return t?n:e}function normalizeSendInput(e){return typeof e==`string`||Array.isArray(e)?{message:e}:e}export{createSendFn};

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

@@ -0,0 +1,10 @@
+import type { SessionCallback } from "#channel/types.js";
+export type SessionCallbackParseResult = {
+    readonly callback: SessionCallback;
+    readonly ok: true;
+} | {
+    readonly cause: unknown;
+    readonly message: string;
+    readonly ok: false;
+};
+export declare function parseSessionCallback(value: unknown): SessionCallbackParseResult;

package/dist/src/channel/session-callback.js

@@ -0,0 +1 @@
+import{z}from"#compiled/zod/index.js";import{createEveCallbackRoutePath}from"#protocol/routes.js";import{isReservedIpAddress}from"#shared/network-address.js";const sessionCallbackSchema=z.object({callId:z.string().min(1),subagentName:z.string().min(1),token:z.string().min(1),url:z.string().min(1)}).strict().superRefine((e,t)=>{let r;try{r=new URL(e.url)}catch{t.addIssue({code:`custom`,message:`Callback url must be absolute.`,path:[`url`]});return}readCallbackUrlToken(r)!==e.token&&t.addIssue({code:`custom`,message:`Callback url token must match callback token.`,path:[`url`]}),isReservedIpAddress(r.hostname)&&t.addIssue({code:`custom`,message:`Callback url host must not be a private or reserved address.`,path:[`url`]})});function parseSessionCallback(e){let t=sessionCallbackSchema.safeParse(e);return t.success?{callback:t.data,ok:!0}:{cause:t.error,message:formatSessionCallbackParseError(t.error),ok:!1}}function readCallbackUrlToken(e){let n=createEveCallbackRoutePath(``);if(!e.pathname.startsWith(n))return null;let r=e.pathname.slice(n.length);if(r.length===0||r.includes(`/`))return null;try{return decodeURIComponent(r)}catch{return null}}function formatSessionCallbackParseError(e){return`Invalid callback metadata: ${e.issues.map(e=>`${e.path.length===0?`callback`:`callback.${e.path.join(`.`)}`}: ${e.message}`).join(`; `)}`}export{parseSessionCallback};

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

@@ -0,0 +1,46 @@
+import type { ContextAccessor } from "#context/key.js";
+import type { HandleMessageStreamEvent } from "#protocol/message.js";
+import type { Runtime } from "#channel/types.js";
+import type { SessionAuth } from "#context/keys.js";
+/**
+ * Result of starting or delivering to a session. Exposes the session
+ * `id`, its namespaced `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.
+ */
+export interface Session {
+    readonly id: string;
+    readonly continuationToken: string;
+    getEventStream(options?: {
+        startIndex?: number;
+    }): Promise<ReadableStream<HandleMessageStreamEvent>>;
+}
+/**
+ * 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
+ * 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;
+}
+export declare function createSession(id: string, continuationToken: string, runtime: Runtime): Session;
+export declare function createGetSessionFn(runtime: Runtime): (sessionId: string) => Session;
+/**
+ * Builds a live {@link SessionHandle} backed by the active context
+ * accessor. Read-only fields resolve through getters so they reflect
+ * any updates made by other handlers within the same step (e.g. the
+ * `deliver` hook seeding `AuthKey` before an event handler reads
+ * `session.auth`).
+ *
+ * Used by {@link buildAdapterContext} to populate `ctx.session` on
+ * every adapter handler invocation.
+ */
+export declare function buildSessionHandle(accessor: ContextAccessor): SessionHandle;

package/dist/src/channel/session.js

@@ -0,0 +1 @@
+import{AuthKey,ContinuationTokenKey,InitiatorAuthKey,SessionIdKey}from"#context/keys.js";function createSession(e,t,n){return{id:e,continuationToken:t,async getEventStream(t){return n.getEventStream(e,t)}}}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};