eve 0.83.2 → 0.84.0

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

@@ -1,10 +1,12 @@
-import type { UserContent } from "ai";
-import type { LegacyRemoteAgentCaller } from "#execution/legacy-remote-agent/protocol.js";
+import type { SessionStreamEvent } from "#protocol/session-event.js";
+import type { MessageContent } from "#shared/message-content.js";
+import type { ChannelDelivery } from "#shared/channel-delivery.js";
+import type { RemoteChildBinding } from "#execution/child-binding.js";
 import type { SessionInboxAddress } from "#execution/session-inbox/address.js";
-import type { MessageStreamEvent, UnstampedMessageStreamEvent } from "#protocol/message.js";
 import type { CancelTurnResult as ProtocolCancelTurnResult } from "#protocol/cancel-turn.js";
 import type { RuntimeSubagentChildResult, RuntimeSubagentDispatchFailure, RuntimeToolResultActionResult } from "#shared/action-types.js";
-import type { InputRequest, InputResponse } from "#shared/input.js";
+import type { InteractionOpenedData, InteractionSettledData } from "#protocol/session-events/families/interaction.js";
+import type { ResponseOutcome } from "#protocol/session-events/families/response.js";
 import type { ChannelAdapter } from "#channel/adapter.js";
 import type { JsonObject } from "#shared/json.js";
 import type { SessionHistoryMessage } from "#shared/session-history.js";
@@ -18,8 +20,8 @@ import type { ChannelInstrumentationProjection } from "#channel/instrumentation.
 /** Identifies the session turn to cancel. */
 export interface CancelTurnInput {
     readonly sessionId: string;
-    /** Limits the request to the turn the caller observed. */
-    readonly turnId?: string;
+    /** Limits cancellation to the observed turn; null records a no-op without targeting later work. */
+    readonly turnId?: string | null;
 }
 /** Result of requesting turn cancellation. Both statuses are successful. */
 export type CancelTurnResult = ProtocolCancelTurnResult;
@@ -86,11 +88,10 @@ export type SessionTraceRoot = {
     readonly sessionId: string;
 };
 /**
- * Serializable W3C span context identifying a parent's open trace window.
- * Structural rather than an OTel `SpanContext` so the channel surface stays
- * free of tracing dependencies.
+ * Trace coordinates and the inherited policy decision used to seed a session's trace.
+ * Separate from `TraceContext`, which carries only portable W3C coordinates.
  */
-export interface SessionTraceContext {
+export interface SessionTraceSeed {
     readonly decision?: InstrumentationDecision;
     readonly forwardedTracePolicy?: ForwardedTraceAssertion;
     readonly spanId: string;
@@ -104,7 +105,7 @@ export interface ChannelDeliveryMetadata {
     readonly channelName: string;
     readonly deliveryId: string;
     readonly requestId?: string;
-    readonly requestTraceContext?: SessionTraceContext;
+    readonly requestTraceContext?: SessionTraceSeed;
 }
 /** Associates delivery metadata with one payload in a durable envelope. */
 export interface ChannelDeliveryMetadataEntry extends ChannelDeliveryMetadata {
@@ -127,6 +128,7 @@ export interface SessionAuthContext {
 }
 /** Framework-internal caller waiting for one delegated conversation turn. */
 export interface TurnCaller {
+    /** The call that opened the session, whose lineage its messages keep. */
     readonly callId: string;
     readonly subagentName: string;
     readonly replyTo: {
@@ -138,25 +140,11 @@ export interface TurnCaller {
         readonly url: string;
     };
 }
-/**
- * Base deliver payload crossing the runtime boundary.
- *
- * The runtime reads {@link message} and {@link inputResponses} for delivery
- * coalescing. Adapters extend this interface with their own typed fields (e.g.
- * Slack adapters add `interaction`) and receive the extended type through the
- * generic payload on their `deliver` hook.
- *
- * `message` is a plain text string or an AI SDK `UserContent` array (mixing
- * `text`, `image`, and `file` parts), letting channels forward file
- * attachments and other multimodal input straight to the harness.
- */
-export interface DeliverPayload {
-    readonly inputResponses?: readonly InputResponse[];
-    readonly message?: string | UserContent;
-    readonly context?: readonly string[];
-    /** Prior conversation added as user and assistant turns before this delivery's input. */
+/** Internal transport payload, including framework-owned compatibility and context fields. */
+export interface DeliverPayload extends Omit<ChannelDelivery, "state"> {
+    /** Framework-owned history; delivery hooks cannot replace it. */
     readonly history?: readonly SessionHistoryMessage[];
-    readonly outputSchema?: JsonObject;
+    readonly state?: unknown;
     readonly [key: string]: unknown;
 }
 /** Controls how a channel message interacts with an active turn. */
@@ -176,19 +164,36 @@ export type SessionCommand = {
     readonly delivery?: ChannelDeliveryMetadata;
     readonly requestId?: string;
     readonly turnPolicy?: TurnPolicy;
-} | {
+} | ({
     readonly kind: "cancel";
-    readonly turnId?: string;
-} | {
+    readonly turnId?: string | null;
+} & SessionControlIdentity) | {
     readonly kind: "prewarm";
     readonly targetDeploymentId?: string;
-} | {
+} | ({
     readonly kind: "compact";
-} | {
+} & SessionControlIdentity) | ({
     readonly kind: "clear";
-} | {
+} & SessionControlIdentity) | ({
     readonly kind: "reset";
     readonly reason?: string;
+} & SessionControlIdentity);
+/**
+ * A control is a delivery: its id, and who sent it, so the facts it causes name it.
+ */
+export interface SessionControlIdentity {
+    readonly deliveryId: string;
+    readonly auth?: SessionAuthContext | null;
+}
+/** Who sends a control, so the delivery it arrives as names them. */
+export interface SessionControlOptions {
+    readonly auth?: SessionAuthContext | null;
+}
+/** A control command as one delivery: a fresh id, and the sender when known. */
+export declare function controlCommand<TCommand extends {
+    readonly kind: "cancel" | "clear" | "compact" | "reset";
+}>(command: TCommand, options?: SessionControlOptions): TCommand & SessionControlIdentity & {
+    readonly deliveryId: string;
 };
 export type SessionSendCommandResult = {
     readonly status: "accepted";
@@ -277,65 +282,71 @@ export interface RuntimeActionResultHookPayload {
     readonly results: readonly (RuntimeSubagentChildResult | RuntimeSubagentDispatchFailure | RuntimeToolResultActionResult)[];
 }
 /**
- * Event coordinates attached to a proxied `input.requested` batch.
- *
- * Mirrors the `data` payload of the child's `input.requested` stream event so
- * the parent re-emits the same semantics without inventing new identifiers.
+ * A change to an interaction a delegated child session or workflow run owns, relayed to the
+ * session that serves it and keyed by the asker's ids: a request it opened, how it settled one,
+ * or how it settled an answer this session forwarded. The serving session mirrors each in its own
+ * stream; the asker's stream stays its own. An opened request names its origin from the asker's
+ * side: the asker, its interaction, and the call it asks about.
  */
-export interface SubagentInputRequestEvent {
-    readonly requests: readonly InputRequest[];
-    readonly sequence: number;
-    readonly stepIndex: number;
-    /** The task that asks, when a task's run forwards the request. */
-    readonly taskId?: string;
-    readonly turnId: string;
-}
+export type RelayedInteractionEvent = {
+    readonly type: "interaction.opened";
+    readonly data: InteractionOpenedData;
+} | {
+    readonly type: "interaction.settled";
+    readonly data: InteractionSettledData;
+} | {
+    readonly type: "response.admitted";
+    readonly data: RelayedResponseAdmission;
+} | {
+    readonly type: "response.settled";
+    readonly data: RelayedResponseSettlement;
+};
 /**
- * Proxy payload sent from a child subagent to its parent when the child parks
- * on a pending input batch.
- *
- * Runtime-internal. Channel adapters and authored code never observe this
- * kind: it exists only on the durable hook between the subagent adapter's
- * `input.requested` handler and the parent's runtime loop.
+ * An asker admitted an answer it was forwarded: it stands, revisable, while the rest of its batch
+ * waits. Which interaction, and the delivery the asker received it in.
  */
-export interface SubagentInputRequestHookPayload {
+export interface RelayedResponseAdmission {
+    readonly interactionId: string;
+    /** The delivery the asker received the answer in, when it kept the forwarder's id. */
+    readonly deliveryId?: string;
+}
+/** How an asker settled an answer: which interaction, from which delivery, and how. */
+export interface RelayedResponseSettlement {
+    readonly interactionId: string;
+    /** The delivery the asker received the answer in, when it kept the forwarder's id. */
+    readonly deliveryId?: string;
+    readonly outcome: ResponseOutcome;
+    readonly reason?: string;
+}
+/** Where answers to a relayed request go: the asker's hook, inbox, and the source it reads. */
+export interface RelayRoute {
+    readonly childContinuationToken: string;
+    readonly childSessionInbox?: SessionInboxAddress;
+    /** Independent source when several requests share an answer destination. */
+    readonly inputSource?: string;
     readonly remote?: import("#eve-channel/support.js").RemoteAgentBinding & {
         readonly sessionId: string;
     };
-    /** Independent source when several requests share an answer destination. */
-    readonly inputSource?: string;
-    readonly callId: string;
-    readonly childContinuationToken: string;
-    readonly childSessionId: string;
-    readonly childSessionInbox?: SessionInboxAddress;
-    readonly event: SubagentInputRequestEvent;
-    readonly kind: "subagent-input-request";
-    readonly subagentName: string;
 }
 /**
- * Lifecycle event forwarded from a delegated child: responder and sign-in progress, and the
- * resolution of its requests. The parent relays it unchanged.
- */
-export type SubagentAuthorizationEvent = Extract<UnstampedMessageStreamEvent, {
-    type: "approval.candidate" | "approval.settled" | "authorization.required" | "authorization.completed" | "input.resolved";
-}>;
-/**
- * Proxy payload sent from a child subagent while it waits for authorization.
- *
- * Runtime-internal. The parent re-emits the unchanged event through its own
- * channel; the authorization callback continues to target the child directly.
+ * Interaction facts one commit of a child session (or a workflow run) changed, relayed up to the
+ * session that serves it: the requests it opened together, or one other fact. Runtime-internal:
+ * channel adapters and authored code never observe this kind. `route` comes with requests a
+ * person answers.
  */
-export interface SubagentAuthorizationEventHookPayload {
+export interface SubagentInteractionHookPayload {
+    readonly kind: "subagent-interaction";
+    /** The serving session's call that delegated to the asker. */
     readonly callId: string;
     readonly childSessionId: string;
-    readonly event: SubagentAuthorizationEvent;
-    readonly kind: "subagent-authorization-event";
     readonly subagentName: string;
+    readonly events: readonly RelayedInteractionEvent[];
+    readonly route?: RelayRoute;
 }
 /**
  * Serializable payload sent through the workflow `resumeHook`.
  */
-export type HookPayload = ClearSessionHookPayload | CompactSessionHookPayload | DeliverHookPayload | RuntimeActionResultHookPayload | SessionTimeoutHookPayload | SubagentAuthorizationEventHookPayload | SubagentInputRequestHookPayload;
+export type HookPayload = ClearSessionHookPayload | CompactSessionHookPayload | DeliverHookPayload | RuntimeActionResultHookPayload | SessionTimeoutHookPayload | SubagentInteractionHookPayload;
 /**
  * Initial caller callback attached to a delegated session at creation.
  *
@@ -433,12 +444,15 @@ export interface RunInput {
      * caller for their own turn.
      */
     readonly callback?: SessionCallback;
-    /** Set when {@link callback} belongs to a remote agent protocol 1 caller. */
-    readonly legacyRemoteAgentCaller?: LegacyRemoteAgentCaller;
+    /**
+     * Set when {@link callback} belongs to a caller on an earlier remote agent protocol. The session
+     * reports its result to that caller, but relays none of its requests.
+     */
+    readonly earlierCallerProtocol?: number;
     /**
      * Session continuation token for delivery and hook creation. Channels can
      * add a continuation address during the first turn via
-     * `ctx.session.continuation.alias(...)` (e.g. Slack adopts its first
+     * `ctx.channel.continuation.alias(...)` (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. Earlier
      * addresses remain valid after an alias. ID-only
@@ -464,7 +478,7 @@ export interface RunInput {
     readonly initiatorAuth?: SessionAuthContext | null;
     readonly input: {
         /** Omitted only when creating a conversation session before its first turn. */
-        readonly message?: string | UserContent;
+        readonly message?: MessageContent;
         readonly context?: readonly string[];
         /** Prior conversation; with no message, it waits for the first message's turn. */
         readonly history?: readonly SessionHistoryMessage[];
@@ -481,7 +495,7 @@ export interface RunInput {
      * Dispatching parent's open trace window. Handed down rather than looked up
      * because trace state is scoped to one session's context.
      */
-    readonly parentTraceContext?: SessionTraceContext;
+    readonly parentTraceContext?: SessionTraceSeed;
     /** Framework-owned metadata for a protocol-neutral external invocation. */
     readonly externalInvocation?: {
         readonly continuationToken: string;
@@ -503,18 +517,6 @@ export interface DeliverInput {
     readonly continuationToken: string;
     readonly payload: DeliverPayload;
 }
-/**
- * Terminal outcome of a runtime run.
- *
- * The durable event stream's `session.completed` / `session.failed`
- * events report terminal state on the workflow runtime.
- */
-export type RunResult = {
-    readonly status: "completed";
-    readonly output: string;
-} | {
-    readonly status: "waiting";
-};
 /**
  * Handle returned by `runtime.createSession()` once the durable run is accepted,
  * before its command inbox or step loop necessarily starts.
@@ -522,7 +524,9 @@ export type RunResult = {
  * Carries the identifiers needed for stream endpoints.
  */
 export interface RunHandle {
-    readonly events: ReadableStream<MessageStreamEvent>;
+    /** Initial message delivery; absent for an idle prewarm. */
+    readonly deliveryId?: string;
+    readonly events: ReadableStream<SessionStreamEvent>;
     /**
      * Runtime-owned identifier for this session. Stream and inspection APIs
      * key on it: workflow-backed runs expose the workflow run id.
@@ -581,7 +585,13 @@ export interface Runtime {
      * not exist or its history has expired. A historical read (`follow: false`)
      * never inspects or changes the session's lifecycle.
      */
-    getEventStream(sessionId: string, options?: GetEventStreamOptions): Promise<ReadableStream<MessageStreamEvent>>;
+    getEventStream(sessionId: string, options?: SessionStreamOptions): Promise<ReadableStream<SessionStreamEvent>>;
+    /**
+     * Returns a session's stored lines from `options.startIndex`, one parsed record per line: a
+     * commit (`{at, facts}`) or a progress record (`{progress}`). A line's position is its index,
+     * counting every line, including ones this version can't read. Backs the HTTP stream route.
+     */
+    getLineStream(sessionId: string, options?: SessionStreamOptions): Promise<ReadableStream<unknown>>;
     /**
      * Resolves the durable tail of a session's event stream: the zero-based
      * index of the last recorded event, or `-1` before the first. Callers use
@@ -589,21 +599,17 @@ export interface Runtime {
      * live stream.
      */
     getStreamTailIndex(sessionId: string): Promise<number>;
-}
-/**
- * Options accepted by {@link Runtime.getEventStream}.
- */
-export interface GetEventStreamOptions {
     /**
-     * Zero-based index of the first event to emit. Negative values read from
-     * the current tail (`-1` starts at the latest event). Defaults to `0`
-     * (replay the entire stream).
+     * Reads where a remote child of `sessionId` runs, from the private record the parent wrote
+     * before linking it. Only the parent's stream proxy reads it.
      */
-    readonly startIndex?: number;
+    readChildBinding?(sessionId: string, childSessionId: string): Promise<RemoteChildBinding | undefined>;
     /**
-     * Whether to keep following events recorded after the read opens. When
-     * `false`, the stream ends at the durable tail observed when it opens, and
-     * it stays readable while the session is stranded. Defaults to `true`.
+     * Whether a run that can still execute owns the session: one holds its inbox, on a deployment
+     * that runs. `false` when the session's owner ended or is stranded; its stream gets no more
+     * lines.
      */
-    readonly follow?: boolean;
+    hasRunnableOwner?(sessionId: string): Promise<boolean>;
 }
+export type { SessionStreamOptions } from "#shared/session.js";
+import type { SessionStreamOptions } from "#shared/session.js";

package/dist/src/channel/types.js

@@ -1 +1 @@
-const DEFAULT_TURN_POLICY=`steer`;export{DEFAULT_TURN_POLICY};
+const DEFAULT_TURN_POLICY=`steer`;function controlCommand(e,t){let n=crypto.randomUUID();return t?.auth===void 0?{...e,deliveryId:n}:{...e,auth:t.auth,deliveryId:n}}export{DEFAULT_TURN_POLICY,controlCommand};