eve 0.83.3 → 0.84.0

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

@@ -0,0 +1,11 @@
+import { z } from "#compiled/zod/index.js";
+/** The data-only part of an accepted command, carried across an HTTP or workflow boundary. */
+export interface DeliveryReceipt {
+    readonly sessionId: string;
+    readonly deliveryId: string;
+}
+export declare const DeliveryResponseSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    sessionId: z.ZodString;
+    deliveryId: z.ZodString;
+}, z.core.$strip>;

package/dist/src/protocol/delivery.js

@@ -0,0 +1 @@
+import{z}from"#compiled/zod/index.js";const DeliveryResponseSchema=z.object({ok:z.literal(!0),sessionId:z.string().min(1),deliveryId:z.string().min(1)});export{DeliveryResponseSchema};

package/dist/src/protocol/descendant-observation.d.ts

@@ -0,0 +1,12 @@
+/** Fixed safety bounds for optional descendant observation, independent of execution budgets. */
+export declare const DESCENDANT_MAX_DEPTH = 8;
+export declare const DESCENDANT_MAX_SESSIONS = 128;
+export declare const DESCENDANT_MAX_READS = 8;
+/** Coordinates are data; the owning server verifies the opening at this committed source line. */
+export interface DescendantHop {
+    readonly sessionId: string;
+    readonly position: number;
+}
+/** Server-established reader namespace and session identity; never contains credentials. */
+export declare const EVE_OBSERVATION_KEY_HEADER = "x-eve-observation-key";
+export declare function localObservationKey(sessionId: string): string;

package/dist/src/protocol/descendant-observation.js

@@ -0,0 +1 @@
+const DESCENDANT_MAX_DEPTH=8,DESCENDANT_MAX_SESSIONS=128,DESCENDANT_MAX_READS=8,EVE_OBSERVATION_KEY_HEADER=`x-eve-observation-key`;function localObservationKey(e){return JSON.stringify([`local`,e])}export{DESCENDANT_MAX_DEPTH,DESCENDANT_MAX_READS,DESCENDANT_MAX_SESSIONS,EVE_OBSERVATION_KEY_HEADER,localObservationKey};

package/dist/src/protocol/interaction-json.d.ts

@@ -0,0 +1,66 @@
+import { z } from "#compiled/zod/index.js";
+import type { Interaction } from "#protocol/session-projection/reader.js";
+/** Shared JSON projection for invocation results. Sign-in callbacks stay on the server. */
+export declare const interactionJsonSchema: z.ZodObject<{
+    interactionId: z.ZodString;
+    request: z.ZodObject<{
+        allowFreeform: z.ZodOptional<z.ZodBoolean>;
+        display: z.ZodOptional<z.ZodType<import("#protocol/session-events/families/interaction.js").InteractionDisplay, unknown, z.core.$ZodTypeInternals<import("#protocol/session-events/families/interaction.js").InteractionDisplay, unknown>>>;
+        kind: z.ZodType<import("#protocol/session-events/families/interaction.js").InteractionKind, unknown, z.core.$ZodTypeInternals<import("#protocol/session-events/families/interaction.js").InteractionKind, unknown>>;
+        link: z.ZodOptional<z.ZodObject<{
+            label: z.ZodOptional<z.ZodString>;
+            url: z.ZodString;
+        }, z.core.$strip>>;
+        options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            description: z.ZodOptional<z.ZodString>;
+            id: z.ZodString;
+            label: z.ZodString;
+            style: z.ZodOptional<z.ZodType<import("#protocol/session-events/families/interaction.js").InteractionOptionStyle, unknown, z.core.$ZodTypeInternals<import("#protocol/session-events/families/interaction.js").InteractionOptionStyle, unknown>>>;
+        }, z.core.$strip>>>;
+        prompt: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
+        signIn: z.ZodOptional<z.ZodObject<{
+            displayName: z.ZodOptional<z.ZodString>;
+            expiresAt: z.ZodOptional<z.ZodString>;
+            grant: z.ZodOptional<z.ZodString>;
+            instructions: z.ZodOptional<z.ZodString>;
+            name: z.ZodString;
+            principal: z.ZodOptional<z.ZodObject<{
+                id: z.ZodOptional<z.ZodString>;
+                issuer: z.ZodOptional<z.ZodString>;
+                type: z.ZodString;
+            }, z.core.$strip>>;
+            url: z.ZodOptional<z.ZodString>;
+            userCode: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    call: z.ZodOptional<z.ZodObject<{
+        callId: z.ZodString;
+        name: z.ZodString;
+        input: z.ZodOptional<z.ZodJSONSchema>;
+    }, z.core.$strip>>;
+    status: z.ZodEnum<{
+        open: "open";
+        settled: "settled";
+    }>;
+    outcome: z.ZodOptional<z.ZodEnum<{
+        abandoned: "abandoned";
+        accepted: "accepted";
+        declined: "declined";
+        expired: "expired";
+        failed: "failed";
+        interrupted: "interrupted";
+        invalid: "invalid";
+        withdrawn: "withdrawn";
+    }>>;
+    reason: z.ZodOptional<z.ZodString>;
+    answer: z.ZodOptional<z.ZodObject<{
+        interactionId: z.ZodString;
+        optionId: z.ZodOptional<z.ZodString>;
+        text: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    turnId: z.ZodString;
+    stepIndex: z.ZodNumber;
+    taskId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare function interactionJson(value: Interaction): z.infer<typeof interactionJsonSchema>;

package/dist/src/protocol/interaction-json.js

@@ -0,0 +1 @@
+import{z}from"#compiled/zod/index.js";import{interactionRequestSchema}from"#protocol/session-events/families/interaction.js";const interactionJsonSchema=z.object({interactionId:z.string(),request:interactionRequestSchema.extend({signIn:interactionRequestSchema.shape.signIn.unwrap().omit({callbackUrl:!0}).optional()}),call:z.object({callId:z.string(),name:z.string(),input:z.json().optional()}).optional(),status:z.enum([`open`,`settled`]),outcome:z.enum([`accepted`,`declined`,`invalid`,`failed`,`withdrawn`,`interrupted`,`abandoned`,`expired`]).optional(),reason:z.string().optional(),answer:z.object({interactionId:z.string(),optionId:z.string().optional(),text:z.string().optional()}).optional(),turnId:z.string(),stepIndex:z.number().int().nonnegative(),taskId:z.string().optional()});function interactionJson(e){return interactionJsonSchema.parse(e)}export{interactionJson,interactionJsonSchema};

package/dist/src/protocol/interaction-options.d.ts

@@ -0,0 +1,4 @@
+/** Option id that approves a call or grants a fresh budget window. */
+export declare const APPROVE_OPTION_ID = "approve";
+/** Option id that denies a call or declines budget continuation. */
+export declare const DENY_OPTION_ID = "deny";

package/dist/src/protocol/interaction-options.js

@@ -0,0 +1 @@
+const APPROVE_OPTION_ID=`approve`,DENY_OPTION_ID=`deny`;export{APPROVE_OPTION_ID,DENY_OPTION_ID};

package/dist/src/protocol/remote-agent-protocol.d.ts

@@ -4,11 +4,38 @@
  * version, and the receiver's response names its own. Deployments from before
  * the version existed speak 1.
  */
-export declare const REMOTE_AGENT_PROTOCOL_VERSION = 2;
+export declare const REMOTE_AGENT_PROTOCOL_VERSION = 3;
+/**
+ * Error code a parent's callback route answers when nothing waits on the callback's token: the
+ * parent already took the result, or stopped waiting. Its message is the same in every protocol.
+ */
+export declare const REMOTE_CALLBACK_NOT_PENDING = "CALLBACK_NOT_PENDING";
+export declare const REMOTE_CALLBACK_NOT_PENDING_MESSAGE = "Session callback not pending.";
 /** Error code a receiver answers when the caller speaks another protocol version. */
 export declare const REMOTE_AGENT_PROTOCOL_MISMATCH = "REMOTE_AGENT_PROTOCOL_MISMATCH";
 /** Protocol of eve 0.66–0.68, which sent no version. */
 export declare const UNVERSIONED_REMOTE_AGENT_PROTOCOL = 1;
+/**
+ * Protocol of eve before v27 sessions. Its children relay people's input as v26 requests and take
+ * answers as v26 `inputResponses`, which this deployment translates both ways.
+ */
+export declare const V26_INPUT_REMOTE_AGENT_PROTOCOL = 2;
+/** The callback URL for a child that speaks `version`. */
+export declare function callbackUrlForProtocol(url: string, version: number): string;
+/** The protocol a callback URL says its parent agreed with the child, if it names one. */
+export declare function readCallbackProtocol(url: string): number | undefined;
+/**
+ * Whether a remote agent serves a caller on this protocol version. It serves versions 2 and up,
+ * but relays requests and streams only to a caller on its own version.
+ */
+export declare function servesRemoteAgentCaller(version: number): boolean;
+/** Why a session can't ask its caller for input: the caller speaks an earlier protocol. */
+export declare function formatEarlierRemoteCallerInputError(callerVersion: number): string;
+/** Why a parent can't proxy a remote child's stream: the child speaks an earlier protocol. */
+export declare function formatEarlierRemoteChildStreamError(input: {
+    readonly name: string;
+    readonly childVersion: number;
+}): string;
 /** Reads a peer's protocol version, treating an absent one as the unversioned protocol. */
 export declare function readRemoteAgentProtocolVersion(value: unknown): number;
 /** The caller's message when a remote agent's deployment speaks another version. */

package/dist/src/protocol/remote-agent-protocol.js

@@ -1 +1 @@
-const REMOTE_AGENT_PROTOCOL_VERSION=2,REMOTE_AGENT_PROTOCOL_MISMATCH=`REMOTE_AGENT_PROTOCOL_MISMATCH`,UNVERSIONED_REMOTE_AGENT_PROTOCOL=1;function readRemoteAgentProtocolVersion(e){return typeof e==`number`?e:1}function formatRemoteAgentProtocolMismatch(e){return`Remote agent "${e.name}" speaks eve remote agent protocol ${String(e.receiverVersion)}, but this deployment speaks protocol 2. Upgrade both deployments to the same eve release.`}export{REMOTE_AGENT_PROTOCOL_MISMATCH,REMOTE_AGENT_PROTOCOL_VERSION,UNVERSIONED_REMOTE_AGENT_PROTOCOL,formatRemoteAgentProtocolMismatch,readRemoteAgentProtocolVersion};
+const REMOTE_AGENT_PROTOCOL_VERSION=3,REMOTE_CALLBACK_NOT_PENDING=`CALLBACK_NOT_PENDING`,REMOTE_CALLBACK_NOT_PENDING_MESSAGE=`Session callback not pending.`,REMOTE_AGENT_PROTOCOL_MISMATCH=`REMOTE_AGENT_PROTOCOL_MISMATCH`,UNVERSIONED_REMOTE_AGENT_PROTOCOL=1,V26_INPUT_REMOTE_AGENT_PROTOCOL=2,CALLBACK_PROTOCOL_QUERY=`eveRemoteProtocol`;function callbackUrlForProtocol(e,t){let n=new URL(e);return n.searchParams.set(CALLBACK_PROTOCOL_QUERY,String(t)),n.toString()}function readCallbackProtocol(e){let t=URL.parse(e)?.searchParams.get(CALLBACK_PROTOCOL_QUERY);if(t!=null&&/^[1-9]\d*$/.test(t))return Number(t)}function servesRemoteAgentCaller(e){return Number.isSafeInteger(e)&&e>=2&&e<=3}function formatEarlierRemoteCallerInputError(e){return`This session needs a person's answer, but its caller's deployment speaks eve remote agent protocol ${String(e)}, which can't receive approvals, questions, or sign-ins from protocol 3. Upgrade the caller's deployment to the same eve release.`}function formatEarlierRemoteChildStreamError(e){return`Remote agent "${e.name}" speaks eve remote agent protocol ${String(e.childVersion)}, so this deployment can't follow its stream. Its result still arrives. Upgrade both deployments to the same eve release to follow it.`}function readRemoteAgentProtocolVersion(e){return typeof e==`number`?e:1}function formatRemoteAgentProtocolMismatch(e){return`Remote agent "${e.name}" speaks eve remote agent protocol ${String(e.receiverVersion)}, but this deployment speaks protocol 3. Upgrade both deployments to the same eve release.`}export{REMOTE_AGENT_PROTOCOL_MISMATCH,REMOTE_AGENT_PROTOCOL_VERSION,REMOTE_CALLBACK_NOT_PENDING,REMOTE_CALLBACK_NOT_PENDING_MESSAGE,UNVERSIONED_REMOTE_AGENT_PROTOCOL,V26_INPUT_REMOTE_AGENT_PROTOCOL,callbackUrlForProtocol,formatEarlierRemoteCallerInputError,formatEarlierRemoteChildStreamError,formatRemoteAgentProtocolMismatch,readCallbackProtocol,readRemoteAgentProtocolVersion,servesRemoteAgentCaller};

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

@@ -31,6 +31,9 @@ export declare const EVE_SESSION_RESET_ROUTE_PATTERN = "/eve/v1/session/:session
 export declare const EVE_SESSION_STUBS_ROUTE_PATTERN = "/eve/v1/session/:sessionId/stubs";
 /** Stable event-stream route pattern for one exact session ID. */
 export declare const EVE_SESSION_STREAM_ROUTE_PATTERN = "/eve/v1/session/:sessionId/stream";
+/** Reads a recorded descendant path through its root's authorized reader. */
+export declare const EVE_DESCENDANT_STREAM_ROUTE_PATTERN = "/eve/v1/session/:sessionId/descendants/stream";
+export declare function createEveDescendantStreamRoutePath(sessionId: string): string;
 /**
  * Parent-origin proxy route for one remotely executed child session stream.
  */
@@ -128,7 +131,5 @@ export declare function createEveConnectionCallbackRoutePath(name: string, attem
  * Creates the stable framework-owned terminal callback route path.
  */
 export declare function createEveCallbackRoutePath(token: string): string;
-/** Builds the capability path used to answer one remote child turn. */
-export declare function createEveTaskInputRoutePath(token: string): string;
 /** Builds the tool-stub verification route for one session. */
 export declare function createEveSessionStubsRoutePath(sessionId: string): string;

package/dist/src/protocol/routes.js

@@ -1 +1 @@
-const EVE_ROUTE_PREFIX=`/eve/v1`,EVE_PRODUCTION_CRON_ROUTE_PATTERN=`${EVE_ROUTE_PREFIX}/cron/:token`,EVE_HEALTH_ROUTE_PATH=`${EVE_ROUTE_PREFIX}/health`,EVE_INFO_ROUTE_PATH=`${EVE_ROUTE_PREFIX}/info`,EVE_SESSION_ROUTE_PATH=`${EVE_ROUTE_PREFIX}/session`,EVE_SESSION_ROUTE_PATTERN=`${EVE_SESSION_ROUTE_PATH}/:sessionId`,EVE_SESSION_CANCEL_ROUTE_PATTERN=`${EVE_SESSION_ROUTE_PATH}/:sessionId/cancel`,EVE_SESSION_COMPACT_ROUTE_PATTERN=`${EVE_SESSION_ROUTE_PATH}/:sessionId/compact`,EVE_SESSION_CLEAR_ROUTE_PATTERN=`${EVE_SESSION_ROUTE_PATH}/:sessionId/clear`,EVE_SESSION_RESET_ROUTE_PATTERN=`${EVE_SESSION_ROUTE_PATH}/:sessionId/reset`,EVE_SESSION_STUBS_ROUTE_PATTERN=`${EVE_SESSION_ROUTE_PATH}/:sessionId/stubs`,EVE_SESSION_STREAM_ROUTE_PATTERN=`${EVE_SESSION_ROUTE_PATH}/:sessionId/stream`,EVE_SUBAGENT_STREAM_ROUTE_PATTERN=`${EVE_SESSION_ROUTE_PATH}/:parentSessionId/subagents/:callId/:childSessionId/stream`,EVE_DEV_DISPATCH_SCHEDULE_ROUTE_PATTERN=`${EVE_ROUTE_PREFIX}/dev/schedules/:scheduleId`,EVE_DEV_RUNTIME_ARTIFACTS_ROUTE_PATH=`${EVE_ROUTE_PREFIX}/dev/runtime-artifacts`,EVE_DEV_RUNTIME_ARTIFACTS_REBUILD_ROUTE_PATH=`${EVE_DEV_RUNTIME_ARTIFACTS_ROUTE_PATH}/rebuild`,EVE_DEV_RUNTIME_ARTIFACTS_SUSPEND_ROUTE_PATH=`${EVE_DEV_RUNTIME_ARTIFACTS_ROUTE_PATH}/suspend`,EVE_DEV_RUNTIME_ARTIFACTS_RESUME_ROUTE_PATH=`${EVE_DEV_RUNTIME_ARTIFACTS_ROUTE_PATH}/resume`;function createEveDevDispatchSchedulePath(e){return`${EVE_ROUTE_PREFIX}/dev/schedules/${encodeURIComponent(e)}`}const EVE_CONNECTION_CALLBACK_ROUTE_PATTERN=`${EVE_ROUTE_PREFIX}/connections/:name/callback/:attemptId/:token`,EVE_CALLBACK_ROUTE_PATTERN=`${EVE_ROUTE_PREFIX}/callback/:token`;function createEveSessionRoutePath(e){return`${EVE_SESSION_ROUTE_PATH}/${encodeURIComponent(e)}`}function createEveSessionCancelRoutePath(e){return`${EVE_SESSION_ROUTE_PATH}/${encodeURIComponent(e)}/cancel`}function createEveSubagentStreamRoutePath(e){return`${EVE_SESSION_ROUTE_PATH}/${encodeURIComponent(e.parentSessionId)}/subagents/${encodeURIComponent(e.callId)}/${encodeURIComponent(e.childSessionId)}/stream`}function createEveSessionCompactRoutePath(e){return`${EVE_SESSION_ROUTE_PATH}/${encodeURIComponent(e)}/compact`}function createEveSessionClearRoutePath(e){return`${EVE_SESSION_ROUTE_PATH}/${encodeURIComponent(e)}/clear`}function createEveSessionResetRoutePath(e){return`${EVE_SESSION_ROUTE_PATH}/${encodeURIComponent(e)}/reset`}function createEveSessionStreamRoutePath(e){return`${EVE_SESSION_ROUTE_PATH}/${encodeURIComponent(e)}/stream`}function createEveConnectionCallbackRoutePath(e,t,n){return`${EVE_ROUTE_PREFIX}/connections/${encodeURIComponent(e)}/callback/${encodeURIComponent(t)}/${encodeURIComponent(n)}`}function createEveCallbackRoutePath(e){return`${EVE_ROUTE_PREFIX}/callback/${encodeURIComponent(e)}`}function createEveTaskInputRoutePath(e){return`${EVE_ROUTE_PREFIX}/task-input/${encodeURIComponent(e)}`}function createEveSessionStubsRoutePath(e){return`${createEveSessionRoutePath(e)}/stubs`}export{EVE_CALLBACK_ROUTE_PATTERN,EVE_CONNECTION_CALLBACK_ROUTE_PATTERN,EVE_DEV_DISPATCH_SCHEDULE_ROUTE_PATTERN,EVE_DEV_RUNTIME_ARTIFACTS_REBUILD_ROUTE_PATH,EVE_DEV_RUNTIME_ARTIFACTS_RESUME_ROUTE_PATH,EVE_DEV_RUNTIME_ARTIFACTS_ROUTE_PATH,EVE_DEV_RUNTIME_ARTIFACTS_SUSPEND_ROUTE_PATH,EVE_HEALTH_ROUTE_PATH,EVE_INFO_ROUTE_PATH,EVE_PRODUCTION_CRON_ROUTE_PATTERN,EVE_ROUTE_PREFIX,EVE_SESSION_CANCEL_ROUTE_PATTERN,EVE_SESSION_CLEAR_ROUTE_PATTERN,EVE_SESSION_COMPACT_ROUTE_PATTERN,EVE_SESSION_RESET_ROUTE_PATTERN,EVE_SESSION_ROUTE_PATH,EVE_SESSION_ROUTE_PATTERN,EVE_SESSION_STREAM_ROUTE_PATTERN,EVE_SESSION_STUBS_ROUTE_PATTERN,EVE_SUBAGENT_STREAM_ROUTE_PATTERN,createEveCallbackRoutePath,createEveConnectionCallbackRoutePath,createEveDevDispatchSchedulePath,createEveSessionCancelRoutePath,createEveSessionClearRoutePath,createEveSessionCompactRoutePath,createEveSessionResetRoutePath,createEveSessionRoutePath,createEveSessionStreamRoutePath,createEveSessionStubsRoutePath,createEveSubagentStreamRoutePath,createEveTaskInputRoutePath};
+const EVE_ROUTE_PREFIX=`/eve/v1`,EVE_PRODUCTION_CRON_ROUTE_PATTERN=`${EVE_ROUTE_PREFIX}/cron/:token`,EVE_HEALTH_ROUTE_PATH=`${EVE_ROUTE_PREFIX}/health`,EVE_INFO_ROUTE_PATH=`${EVE_ROUTE_PREFIX}/info`,EVE_SESSION_ROUTE_PATH=`${EVE_ROUTE_PREFIX}/session`,EVE_SESSION_ROUTE_PATTERN=`${EVE_SESSION_ROUTE_PATH}/:sessionId`,EVE_SESSION_CANCEL_ROUTE_PATTERN=`${EVE_SESSION_ROUTE_PATH}/:sessionId/cancel`,EVE_SESSION_COMPACT_ROUTE_PATTERN=`${EVE_SESSION_ROUTE_PATH}/:sessionId/compact`,EVE_SESSION_CLEAR_ROUTE_PATTERN=`${EVE_SESSION_ROUTE_PATH}/:sessionId/clear`,EVE_SESSION_RESET_ROUTE_PATTERN=`${EVE_SESSION_ROUTE_PATH}/:sessionId/reset`,EVE_SESSION_STUBS_ROUTE_PATTERN=`${EVE_SESSION_ROUTE_PATH}/:sessionId/stubs`,EVE_SESSION_STREAM_ROUTE_PATTERN=`${EVE_SESSION_ROUTE_PATH}/:sessionId/stream`,EVE_DESCENDANT_STREAM_ROUTE_PATTERN=`${EVE_SESSION_ROUTE_PATH}/:sessionId/descendants/stream`;function createEveDescendantStreamRoutePath(e){return`${EVE_SESSION_ROUTE_PATH}/${encodeURIComponent(e)}/descendants/stream`}const EVE_SUBAGENT_STREAM_ROUTE_PATTERN=`${EVE_SESSION_ROUTE_PATH}/:parentSessionId/subagents/:callId/:childSessionId/stream`,EVE_DEV_DISPATCH_SCHEDULE_ROUTE_PATTERN=`${EVE_ROUTE_PREFIX}/dev/schedules/:scheduleId`,EVE_DEV_RUNTIME_ARTIFACTS_ROUTE_PATH=`${EVE_ROUTE_PREFIX}/dev/runtime-artifacts`,EVE_DEV_RUNTIME_ARTIFACTS_REBUILD_ROUTE_PATH=`${EVE_DEV_RUNTIME_ARTIFACTS_ROUTE_PATH}/rebuild`,EVE_DEV_RUNTIME_ARTIFACTS_SUSPEND_ROUTE_PATH=`${EVE_DEV_RUNTIME_ARTIFACTS_ROUTE_PATH}/suspend`,EVE_DEV_RUNTIME_ARTIFACTS_RESUME_ROUTE_PATH=`${EVE_DEV_RUNTIME_ARTIFACTS_ROUTE_PATH}/resume`;function createEveDevDispatchSchedulePath(e){return`${EVE_ROUTE_PREFIX}/dev/schedules/${encodeURIComponent(e)}`}const EVE_CONNECTION_CALLBACK_ROUTE_PATTERN=`${EVE_ROUTE_PREFIX}/connections/:name/callback/:attemptId/:token`,EVE_CALLBACK_ROUTE_PATTERN=`${EVE_ROUTE_PREFIX}/callback/:token`;function createEveSessionRoutePath(e){return`${EVE_SESSION_ROUTE_PATH}/${encodeURIComponent(e)}`}function createEveSessionCancelRoutePath(e){return`${EVE_SESSION_ROUTE_PATH}/${encodeURIComponent(e)}/cancel`}function createEveSubagentStreamRoutePath(e){return`${EVE_SESSION_ROUTE_PATH}/${encodeURIComponent(e.parentSessionId)}/subagents/${encodeURIComponent(e.callId)}/${encodeURIComponent(e.childSessionId)}/stream`}function createEveSessionCompactRoutePath(e){return`${EVE_SESSION_ROUTE_PATH}/${encodeURIComponent(e)}/compact`}function createEveSessionClearRoutePath(e){return`${EVE_SESSION_ROUTE_PATH}/${encodeURIComponent(e)}/clear`}function createEveSessionResetRoutePath(e){return`${EVE_SESSION_ROUTE_PATH}/${encodeURIComponent(e)}/reset`}function createEveSessionStreamRoutePath(e){return`${EVE_SESSION_ROUTE_PATH}/${encodeURIComponent(e)}/stream`}function createEveConnectionCallbackRoutePath(e,t,n){return`${EVE_ROUTE_PREFIX}/connections/${encodeURIComponent(e)}/callback/${encodeURIComponent(t)}/${encodeURIComponent(n)}`}function createEveCallbackRoutePath(e){return`${EVE_ROUTE_PREFIX}/callback/${encodeURIComponent(e)}`}function createEveSessionStubsRoutePath(e){return`${createEveSessionRoutePath(e)}/stubs`}export{EVE_CALLBACK_ROUTE_PATTERN,EVE_CONNECTION_CALLBACK_ROUTE_PATTERN,EVE_DESCENDANT_STREAM_ROUTE_PATTERN,EVE_DEV_DISPATCH_SCHEDULE_ROUTE_PATTERN,EVE_DEV_RUNTIME_ARTIFACTS_REBUILD_ROUTE_PATH,EVE_DEV_RUNTIME_ARTIFACTS_RESUME_ROUTE_PATH,EVE_DEV_RUNTIME_ARTIFACTS_ROUTE_PATH,EVE_DEV_RUNTIME_ARTIFACTS_SUSPEND_ROUTE_PATH,EVE_HEALTH_ROUTE_PATH,EVE_INFO_ROUTE_PATH,EVE_PRODUCTION_CRON_ROUTE_PATTERN,EVE_ROUTE_PREFIX,EVE_SESSION_CANCEL_ROUTE_PATTERN,EVE_SESSION_CLEAR_ROUTE_PATTERN,EVE_SESSION_COMPACT_ROUTE_PATTERN,EVE_SESSION_RESET_ROUTE_PATTERN,EVE_SESSION_ROUTE_PATH,EVE_SESSION_ROUTE_PATTERN,EVE_SESSION_STREAM_ROUTE_PATTERN,EVE_SESSION_STUBS_ROUTE_PATTERN,EVE_SUBAGENT_STREAM_ROUTE_PATTERN,createEveCallbackRoutePath,createEveConnectionCallbackRoutePath,createEveDescendantStreamRoutePath,createEveDevDispatchSchedulePath,createEveSessionCancelRoutePath,createEveSessionClearRoutePath,createEveSessionCompactRoutePath,createEveSessionResetRoutePath,createEveSessionRoutePath,createEveSessionStreamRoutePath,createEveSessionStubsRoutePath,createEveSubagentStreamRoutePath};

package/dist/src/protocol/session-event.d.ts

@@ -0,0 +1,22 @@
+import type { FactPosition } from "#protocol/session-events/envelope.js";
+import type { Fact, Progress } from "#protocol/session-events/facts.js";
+/** What a session publishes: v27 facts and progress records. */
+export type SessionEvent = Fact | Progress;
+/** Where and when a reader read one event back. Never on the wire: readers attach it. */
+export interface SessionEventMeta {
+    readonly position: FactPosition;
+    /** The time of the commit that holds it, or of the latest commit for a progress record. */
+    readonly at: string;
+    /** False while more known records remain in this line; readers stop only after the commit. */
+    readonly endOfLine?: boolean;
+    /**
+     * Exclusive source-line coverage when a reader consumed later lines that emitted no events.
+     * Only on a complete line's last event; its original `position` stays unchanged. Preserve
+     * this reader metadata when saving events, rather than deriving coverage from event counts.
+     */
+    readonly next?: number;
+}
+/** One event as a reader reads it back. */
+export type SessionStreamEvent = SessionEvent & {
+    readonly meta: SessionEventMeta;
+};

package/dist/src/protocol/session-event.js

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

package/dist/src/protocol/session-events/authoring.d.ts

@@ -0,0 +1,2 @@
+export declare const authoringEventTypes: readonly ["session.started", "session.ended", "delivery.admitted", "delivery.consumed", "delivery.settled", "turn.started", "turn.paused", "turn.settled", "model.requested", "model.started", "model.retried", "model.settled", "content.delta", "content.completed", "call.input", "call.requested", "call.started", "call.progress", "call.settled", "usage.recorded", "context.started", "context.settled", "interaction.opened", "interaction.settled", "response.submitted", "response.admitted", "response.settled", "child.opened", "task.ended", "task.started"];
+export type AuthoringEventType = (typeof authoringEventTypes)[number];

package/dist/src/protocol/session-events/authoring.js

@@ -0,0 +1 @@
+const authoringEventTypes=`session.started,session.ended,delivery.admitted,delivery.consumed,delivery.settled,turn.started,turn.paused,turn.settled,model.requested,model.started,model.retried,model.settled,content.delta,content.completed,call.input,call.requested,call.started,call.progress,call.settled,usage.recorded,context.started,context.settled,interaction.opened,interaction.settled,response.submitted,response.admitted,response.settled,child.opened,task.ended,task.started`.split(`,`);export{authoringEventTypes};

package/dist/src/protocol/session-events/catalog.d.ts

@@ -0,0 +1,50 @@
+import type { Fact, Progress } from "./facts.js";
+export type Family = "session" | "delivery" | "turn" | "model" | "content" | "call" | "task" | "interaction" | "response" | "child" | "context" | "usage";
+/**
+ * A fact's role in its family's lifecycle: it introduces an entity, updates an open one, ends it,
+ * introduces and ends it at once (a content part), or records something with no lifecycle.
+ */
+export type FactRole = "introduces" | "updates" | "terminal" | "complete" | "record";
+export interface FactDescriptor {
+    readonly family: Family;
+    readonly role: FactRole;
+    /** The payload field that names the entity the fact is about. */
+    readonly idField: string;
+}
+export declare const SESSION_OUTCOMES: readonly ["completed", "failed"];
+export declare const DELIVERY_OUTCOMES: readonly ["handled", "awaiting-input", "applied", "ignored", "refused", "failed"];
+export declare const TURN_OUTCOMES: readonly ["completed", "failed", "cancelled"];
+export declare const MODEL_OUTCOMES: readonly ["completed", "failed", "interrupted", "abandoned"];
+export declare const CALL_OUTCOMES: readonly ["completed", "failed", "rejected", "interrupted", "abandoned"];
+export declare const TASK_OUTCOMES: readonly ["completed", "failed", "cancelled"];
+export declare const INTERACTION_OUTCOMES: readonly ["accepted", "declined", "invalid", "failed", "withdrawn", "interrupted", "abandoned", "expired"];
+export declare const RESPONSE_OUTCOMES: readonly ["applied", "refused", "failed", "withdrawn", "abandoned", "expired"];
+export declare const CONTEXT_OUTCOMES: readonly ["completed", "failed", "cancelled", "interrupted"];
+type TerminalType = Extract<Fact["type"], `${string}.${"ended" | "settled"}`>;
+/** Each terminal's closed outcome set. A value outside it is a contract violation. */
+export declare const TERMINAL_OUTCOMES: {
+    readonly [TType in TerminalType]: readonly string[];
+};
+export declare const FACT_CATALOG: {
+    readonly [TType in Fact["type"]]: FactDescriptor;
+};
+export interface ProgressDescriptor {
+    readonly family: Family;
+    readonly idField: string;
+}
+export declare const PROGRESS_CATALOG: {
+    readonly [TType in Progress["type"]]: ProgressDescriptor;
+};
+export type FactType = Fact["type"];
+export type ProgressType = Progress["type"];
+/** True for a fact type this version knows. Readers ignore the others. */
+export declare function isFactType(type: unknown): type is FactType;
+/** True for a progress type this version knows. Readers ignore the others. */
+export declare function isProgressType(type: unknown): type is ProgressType;
+/** True for a terminal fact type. */
+export declare function isTerminalType(type: unknown): type is TerminalType;
+/** True when a terminal's outcome belongs to its closed set. */
+export declare function isKnownOutcome(type: TerminalType, outcome: unknown): boolean;
+/** A content part's phase, with unknown values read as narration. */
+export declare function contentPhase(phase: unknown): "narration" | "reply";
+export {};

package/dist/src/protocol/session-events/catalog.js

@@ -0,0 +1 @@
+const SESSION_OUTCOMES=[`completed`,`failed`],DELIVERY_OUTCOMES=[`handled`,`awaiting-input`,`applied`,`ignored`,`refused`,`failed`],TURN_OUTCOMES=[`completed`,`failed`,`cancelled`],MODEL_OUTCOMES=[`completed`,`failed`,`interrupted`,`abandoned`],CALL_OUTCOMES=[`completed`,`failed`,`rejected`,`interrupted`,`abandoned`],TASK_OUTCOMES=[`completed`,`failed`,`cancelled`],INTERACTION_OUTCOMES=[`accepted`,`declined`,`invalid`,`failed`,`withdrawn`,`interrupted`,`abandoned`,`expired`],RESPONSE_OUTCOMES=[`applied`,`refused`,`failed`,`withdrawn`,`abandoned`,`expired`],CONTEXT_OUTCOMES=[`completed`,`failed`,`cancelled`,`interrupted`],TERMINAL_OUTCOMES={"call.settled":CALL_OUTCOMES,"context.settled":CONTEXT_OUTCOMES,"delivery.settled":DELIVERY_OUTCOMES,"interaction.settled":INTERACTION_OUTCOMES,"model.settled":MODEL_OUTCOMES,"response.settled":RESPONSE_OUTCOMES,"session.ended":SESSION_OUTCOMES,"task.ended":TASK_OUTCOMES,"turn.settled":TURN_OUTCOMES},FACT_CATALOG={"call.requested":{family:`call`,idField:`callId`,role:`introduces`},"call.settled":{family:`call`,idField:`callId`,role:`terminal`},"call.started":{family:`call`,idField:`callId`,role:`updates`},"child.opened":{family:`child`,idField:`sessionId`,role:`introduces`},"child.sent":{family:`child`,idField:`sessionId`,role:`record`},"content.completed":{family:`content`,idField:`partId`,role:`complete`},"context.settled":{family:`context`,idField:`changeId`,role:`terminal`},"context.started":{family:`context`,idField:`changeId`,role:`introduces`},"delivery.admitted":{family:`delivery`,idField:`deliveryId`,role:`introduces`},"delivery.consumed":{family:`delivery`,idField:`deliveryId`,role:`updates`},"delivery.settled":{family:`delivery`,idField:`deliveryId`,role:`terminal`},"interaction.opened":{family:`interaction`,idField:`interactionId`,role:`introduces`},"interaction.settled":{family:`interaction`,idField:`interactionId`,role:`terminal`},"model.requested":{family:`model`,idField:`runId`,role:`introduces`},"model.retried":{family:`model`,idField:`runId`,role:`updates`},"model.settled":{family:`model`,idField:`runId`,role:`terminal`},"model.started":{family:`model`,idField:`runId`,role:`updates`},"response.admitted":{family:`response`,idField:`responseId`,role:`updates`},"response.settled":{family:`response`,idField:`responseId`,role:`terminal`},"response.submitted":{family:`response`,idField:`responseId`,role:`introduces`},"session.ended":{family:`session`,idField:``,role:`terminal`},"session.started":{family:`session`,idField:``,role:`introduces`},"task.ended":{family:`task`,idField:`taskId`,role:`terminal`},"task.started":{family:`task`,idField:`taskId`,role:`introduces`},"turn.paused":{family:`turn`,idField:`turnId`,role:`updates`},"turn.settled":{family:`turn`,idField:`turnId`,role:`terminal`},"turn.started":{family:`turn`,idField:`turnId`,role:`introduces`},"usage.recorded":{family:`usage`,idField:``,role:`record`}},PROGRESS_CATALOG={"call.input":{family:`call`,idField:`callId`},"call.progress":{family:`call`,idField:`callId`},"content.delta":{family:`content`,idField:`partId`}};function isFactType(e){return typeof e==`string`&&Object.hasOwn(FACT_CATALOG,e)}function isProgressType(e){return typeof e==`string`&&Object.hasOwn(PROGRESS_CATALOG,e)}function isTerminalType(e){return typeof e==`string`&&Object.hasOwn(TERMINAL_OUTCOMES,e)}function isKnownOutcome(e,t){return typeof t==`string`&&TERMINAL_OUTCOMES[e].includes(t)}function contentPhase(e){return e===`reply`?`reply`:`narration`}export{CALL_OUTCOMES,CONTEXT_OUTCOMES,DELIVERY_OUTCOMES,FACT_CATALOG,INTERACTION_OUTCOMES,MODEL_OUTCOMES,PROGRESS_CATALOG,RESPONSE_OUTCOMES,SESSION_OUTCOMES,TASK_OUTCOMES,TERMINAL_OUTCOMES,TURN_OUTCOMES,contentPhase,isFactType,isKnownOutcome,isProgressType,isTerminalType};

package/dist/src/protocol/session-events/checker.d.ts

@@ -0,0 +1,23 @@
+import type { StoredLine } from "./envelope.js";
+import type { SessionView } from "../session-projection/tables.js";
+export interface Violation {
+    readonly position: number;
+    /** The fact's index in its commit; absent for a progress record or the whole line. */
+    readonly index?: number;
+    readonly type?: string;
+    readonly rule: ViolationRule;
+    readonly message: string;
+}
+export type ViolationRule = "envelope" | "schema" | "introduce-before-reference" | "introduced-twice" | "one-terminal" | "closed-outcome" | "closure" | "after-session-end" | "one-open-turn" | "attempts" | "progress" | "paused-on-person" | "serves-running-task" | "batch-settles-together";
+export interface StreamChecker {
+    /** Checks the next line. Positions must increase; a repeated position is a duplicate, skipped. */
+    check(line: StoredLine, position: number): readonly Violation[];
+}
+export declare function createStreamChecker(options?: {
+    /** Schema validation, from `schemas.ts`, for tests and development. */
+    readonly validate?: (record: unknown, kind: "fact" | "progress") => string | undefined;
+    /** Check from a checkpoint's operational view, including retained ownership ancestors.
+     * Forgotten history cannot establish global identity uniqueness; full-stream checks can.
+     */
+    readonly seed?: SessionView;
+}): StreamChecker;

package/dist/src/protocol/session-events/checker.js

@@ -0,0 +1 @@
+import{FACT_CATALOG,isFactType,isKnownOutcome,isProgressType,isTerminalType}from"./catalog.js";import{copyView,emptySessionView,foldReceivedEvent}from"../session-projection/fold.js";import{activeTurn,interactionOwner,subjectTurn,waiting}from"../session-projection/selectors.js";import{isOpen,openUnder,refOf,rowOf}from"../session-projection/tree.js";const TREE_FAMILY={call:`call`,content:`part`,context:`change`,delivery:`delivery`,interaction:`interaction`,model:`run`,response:`response`,task:`task`,turn:`turn`},ID_FIELDS={callId:`call`,changeId:`change`,deliveryId:`delivery`,interactionId:`interaction`,responseId:`response`,runId:`run`,taskId:`task`,turnId:`turn`};function referencesOf(e,t){let n=[];for(let[r,i]of Object.entries(e)){if(r===t)continue;let e=ID_FIELDS[r];if(e!==void 0&&typeof i==`string`&&n.push({family:e,id:i}),r===`owner`||r===`subject`||r===`startedBy`){let e=refOf(i);e!==void 0&&n.push(e)}}return n}function createStreamChecker(e={}){let t=e.seed===void 0?emptySessionView():copyView(e.seed),n=new Set,r=new Set,i=t.position-1;return{check(n,r){let a=[];if(r<=i)return a;i=r;let report=(e,t,n={})=>a.push({message:t,position:r,rule:e,...n});if(`progress`in n)return checkProgress(n.progress,report),foldReceivedEvent(t,{meta:{position:{index:0,line:r}},type:``}),a;if(!Array.isArray(n.facts)||n.facts.length===0)return report(`envelope`,`A commit holds at least one fact.`),a;let o=[];n.facts.forEach((i,a)=>{let s=i,c={index:a,type:s?.type},fail=(e,t)=>report(e,t,c);if(typeof s!=`object`||!s||typeof s.type!=`string`){fail(`envelope`,`A fact has no type.`);return}if(s.type.split(`.`).length!==2&&fail(`envelope`,`"${s.type}" isn't family.verb.`),isFactType(s.type)){let n=e.validate?.(s,`fact`);if(n!==void 0){fail(`schema`,n);return}if(t.session.status===`ended`){fail(`after-session-end`,`${s.type} follows session.ended.`);return}let r=checkFact(s,fail);r!==void 0&&o.push({index:a,ref:r})}foldReceivedEvent(t,{...s,meta:{at:n.at,endOfLine:a===n.facts.length-1,position:{index:a,line:r}}})}),checkWaitPromises(n.facts,report);for(let{index:e,ref:n}of o){let r=n===`session`?`the session`:`${n.family} "${n.id}"`;for(let i of openUnder(t,n))report(`closure`,`${i.family} "${i.id}" is still open when ${r} ends.`,{index:e})}return a}};function checkFact(e,n){let r=FACT_CATALOG[e.type],i=e.data;if(isTerminalType(e.type)&&!isKnownOutcome(e.type,i.outcome)&&n(`closed-outcome`,`${e.type} has outcome "${String(i.outcome)}", outside its closed set.`),e.type===`session.started`){t.session.status!==`new`&&n(`introduced-twice`,`session.started appears twice.`);return}if(t.session.status===`new`&&n(`introduce-before-reference`,`${e.type} precedes session.started.`),e.type===`session.ended`)return`session`;for(let a of referencesOf(i,r.idField))rowOf(t,a.family,a.id)===void 0&&n(`introduce-before-reference`,`${e.type} names ${a.family} "${a.id}" before it was introduced.`);if(e.type===`turn.started`){let e=activeTurn(t);e!==void 0&&n(`one-open-turn`,`turn ${String(i.turnId)} started while turn ${e.turnId} is open.`)}if(e.type===`turn.paused`)for(let{interactionId:r}of e.data.awaiting){let i=t.interactions[r],a=i!==void 0&&(interactionOwner(t,i).turnId===e.data.turnId||subjectTurn(t,i)===e.data.turnId);(i?.status!==`open`||!a)&&n(`paused-on-person`,`turn.paused awaits "${r}", not open under its turn.`)}e.type===`call.started`&&e.data.taskId!==void 0&&t.tasks[e.data.taskId]?.status===`ended`&&n(`serves-running-task`,`call.started names task "${e.data.taskId}" after it ended.`);let a=TREE_FAMILY[r.family],o=i[r.idField];if(a===void 0||typeof o!=`string`)return;let s={family:a,id:o},c=rowOf(t,a,o);switch(r.role){case`introduces`:c!==void 0&&n(`introduced-twice`,`${e.type} introduces ${a} "${o}" again.`);return;case`complete`:{c!==void 0&&n(`one-terminal`,`${a} "${o}" completes twice.`);let e=refOf({runId:String(i.runId)});rowOf(t,e.family,e.id)!==void 0&&!isOpen(t,e)&&n(`closure`,`${a} "${o}" completes after its run settled.`);return}case`updates`:c===void 0?n(`introduce-before-reference`,`${e.type} names ${a} "${o}" before it was introduced.`):isOpen(t,s)?checkAttempt(e,n):n(`one-terminal`,`${e.type} updates ${a} "${o}" after it ended.`);return;case`terminal`:if(c===void 0){n(`introduce-before-reference`,`${e.type} ends ${a} "${o}" before it was introduced.`);return}if(!isOpen(t,s)){n(`one-terminal`,`${e.type} ends ${a} "${o}" a second time.`);return}return s;default:return}}function checkWaitPromises(e,n){e.forEach((e,r)=>{let i=e?.type===`turn.paused`||e?.type===`delivery.settled`&&e.data.outcome===`awaiting-input`?e.data.turnId:void 0;if(i!==void 0&&waiting(t,i)?.on!==`interaction`&&n(`paused-on-person`,`${e.type} announces a wait turn ${i} doesn't have.`,{index:r}),e?.type!==`interaction.settled`||e.data.outcome!==`accepted`&&e.data.outcome!==`declined`)return;let own=e=>e?.request.kind===`approval`&&e.origin===void 0,a=t.interactions[e.data.interactionId];own(a)&&Object.values(t.interactions).filter(e=>own(e)&&e.introducedAt===a.introducedAt&&e.status===`open`).length>0&&n(`batch-settles-together`,`"${a.interactionId}" settled apart from its batch.`,{index:r})})}function checkAttempt(e,n){if(e.type!==`model.started`&&e.type!==`model.retried`)return;let{attempt:r,runId:i}=e.data,a=t.runs[i]?.attempt;e.type===`model.started`&&a!==void 0&&r<=a&&n(`attempts`,`run "${i}" starts attempt ${r} after attempt ${a}.`),e.type===`model.retried`&&r!==a&&n(`attempts`,`run "${i}" retries attempt ${r}, but its current is ${a}.`)}function checkProgress(i,a){let o=i;if(typeof o!=`object`||!o||!isProgressType(o.type))return;let s={type:o.type},c=e.validate?.(o,`progress`);if(c!==void 0){a(`schema`,c,s);return}if(t.session.status===`ended`){a(`after-session-end`,`${o.type} follows session.ended.`,s);return}switch(o.type){case`content.delta`:{let{partId:e,kind:r}=o.data;if(t.parts[e]!==void 0)a(`progress`,`content.delta for part "${e}" after it completed.`,s);else if(!n.has(e)){r===void 0&&a(`progress`,`content.delta for unannounced part "${e}" has no kind.`,s);let i=o.scope?.runId;(i===void 0||!isOpen(t,{family:`run`,id:i}))&&a(`progress`,`content.delta announces part "${e}" outside an open run.`,s),n.add(e)}return}case`call.input`:{let{callId:e,name:n}=o.data,i=t.calls[e];i!==void 0&&i.status===`settled`?a(`progress`,`call.input for call "${e}" after it settled.`,s):i===void 0&&!r.has(e)&&(n===void 0&&a(`progress`,`call.input for unannounced call "${e}" has no name.`,s),r.add(e));return}case`call.progress`:isOpen(t,{family:`call`,id:o.data.callId})||a(`progress`,`call.progress for call "${o.data.callId}" that isn't running.`,s);return}}}export{createStreamChecker};

package/dist/src/protocol/session-events/common.d.ts

@@ -0,0 +1,105 @@
+import { z } from "#compiled/zod/index.js";
+import type { JsonValue } from "./envelope.js";
+/**
+ * A schema that parses to exactly `T`. Checked at compile time both ways, so the build fails when
+ * the two drift apart: a field one has and the other lacks, a field one requires and the other
+ * leaves optional, or a value one accepts and the other doesn't.
+ */
+export declare function conforming<T>(): <TSchema extends z.ZodType>(schema: TSchema & ([z.output<TSchema>] extends [T] ? [T] extends [DeepReadonly<z.output<TSchema>>] ? [Exclude<KeysOf<T>, KeysOf<z.output<TSchema>>>] extends [never] ? [Exclude<KeysOf<z.output<TSchema>>, KeysOf<T>>] extends [never] ? unknown : {
+    readonly missingFromType: Exclude<KeysOf<z.output<TSchema>>, KeysOf<T>>;
+} : {
+    readonly missingFromSchema: Exclude<KeysOf<T>, KeysOf<z.output<TSchema>>>;
+} : {
+    readonly schemaRejectsSome: T;
+} : {
+    readonly schemaDoesNotParseTo: T;
+})) => TSchema;
+type KeysOf<T> = T extends unknown ? keyof T : never;
+/** Public types are read-only and parsed values aren't; only the shapes are compared. */
+type DeepReadonly<T> = T extends readonly (infer U)[] ? readonly DeepReadonly<U>[] : T extends object ? {
+    readonly [K in keyof T]: DeepReadonly<T[K]>;
+} : T;
+/**
+ * A string whose values the stream names: it parses open, so a reader keeps what a newer writer
+ * sends, and types as the values known today, so a reader's switch keeps a default branch.
+ * A plain string, not `z.custom`, so schemas published as JSON Schema (MCP tool output) can
+ * still describe it.
+ */
+export declare function known<T extends string>(): z.ZodType<T>;
+export declare const id: z.ZodString;
+export declare const jsonValue: z.ZodType<JsonValue>;
+export declare const scope: z.ZodObject<{
+    changeId: z.ZodOptional<z.ZodString>;
+    runId: z.ZodOptional<z.ZodString>;
+    taskId: z.ZodOptional<z.ZodString>;
+    turnId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const cause: z.ZodUnion<readonly [z.ZodObject<{
+    deliveryId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    turnId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    taskId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    callId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    interactionId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    responseId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    changeId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    policy: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    hook: z.ZodString;
+}, z.core.$strip>]>;
+export declare const principal: z.ZodObject<{
+    id: z.ZodString;
+    issuer: z.ZodOptional<z.ZodString>;
+    type: z.ZodString;
+}, z.core.$strip>;
+export declare const errorInfo: z.ZodObject<{
+    code: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    hint: z.ZodOptional<z.ZodString>;
+    id: z.ZodOptional<z.ZodString>;
+    message: z.ZodString;
+}, z.core.$strip>;
+export declare const usage: z.ZodObject<{
+    cacheReadTokens: z.ZodNumber;
+    cacheWriteTokens: z.ZodNumber;
+    costUsd: z.ZodOptional<z.ZodNumber>;
+    inputTokens: z.ZodNumber;
+    outputTokens: z.ZodNumber;
+}, z.core.$strip>;
+export declare const valueReference: z.ZodObject<{
+    mediaType: z.ZodOptional<z.ZodString>;
+    preview: z.ZodOptional<z.ZodString>;
+    ref: z.ZodOptional<z.ZodString>;
+    size: z.ZodOptional<z.ZodNumber>;
+    withheld: z.ZodOptional<z.ZodLiteral<true>>;
+}, z.core.$strip>;
+export declare const userPart: z.ZodUnion<readonly [z.ZodObject<{
+    kind: z.ZodLiteral<"text">;
+    text: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    filename: z.ZodOptional<z.ZodString>;
+    kind: z.ZodLiteral<"file">;
+    mediaType: z.ZodString;
+    ref: z.ZodOptional<z.ZodString>;
+    size: z.ZodOptional<z.ZodNumber>;
+    unavailable: z.ZodOptional<z.ZodLiteral<true>>;
+    url: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>]>;
+/** The schema of one fact or progress record's envelope around its payload. */
+export declare function envelopeOf<TType extends string>(type: TType, data: z.ZodType): z.ZodObject<{
+    data: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    scope: z.ZodOptional<z.ZodObject<{
+        changeId: z.ZodOptional<z.ZodString>;
+        runId: z.ZodOptional<z.ZodString>;
+        taskId: z.ZodOptional<z.ZodString>;
+        turnId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    type: z.ZodLiteral<TType>;
+}, z.core.$strip>;
+export {};

package/dist/src/protocol/session-events/common.js

@@ -0,0 +1 @@
+import{z}from"#compiled/zod/index.js";function conforming(){return e=>e}function known(){return z.string()}const id=z.string().min(1),jsonValue=z.lazy(()=>z.union([z.null(),z.boolean(),z.number(),z.string(),z.array(jsonValue),z.record(z.string(),jsonValue)])),scope=conforming()(z.object({changeId:id.optional(),runId:id.optional(),taskId:id.optional(),turnId:id.optional()})),cause=conforming()(z.union([z.object({deliveryId:id}),z.object({turnId:id}),z.object({taskId:id}),z.object({callId:id}),z.object({interactionId:id}),z.object({responseId:id}),z.object({changeId:id}),z.object({policy:z.string()}),z.object({hook:z.string()})])),principal=conforming()(z.object({id,issuer:z.string().optional(),type:z.string()})),errorInfo=conforming()(z.object({code:z.string(),name:z.string().optional(),hint:z.string().optional(),id:z.string().optional(),message:z.string()})),count=z.number().int().nonnegative(),usage=conforming()(z.object({cacheReadTokens:count,cacheWriteTokens:count,costUsd:z.number().finite().nonnegative().optional(),inputTokens:count,outputTokens:count})),valueReference=conforming()(z.object({mediaType:z.string().optional(),preview:z.string().optional(),ref:z.string().optional(),size:count.optional(),withheld:z.literal(!0).optional()})),userPart=conforming()(z.union([z.object({kind:z.literal(`text`),text:z.string()}),z.object({filename:z.string().optional(),kind:z.literal(`file`),mediaType:z.string(),ref:z.string().optional(),size:count.optional(),unavailable:z.literal(!0).optional(),url:z.string().optional()})]));function envelopeOf(e,t){return z.object({data:t,scope:scope.optional(),type:z.literal(e)})}export{cause,conforming,envelopeOf,errorInfo,id,jsonValue,known,principal,scope,usage,userPart,valueReference};

package/dist/src/protocol/session-events/envelope.d.ts

@@ -0,0 +1,174 @@
+/**
+ * One line of a session stream: a commit, which holds every fact of one transition, or one
+ * progress record. A line's zero-based index in the stream is its position, and its identity.
+ */
+export type StoredLine<TFact = unknown, TProgress = unknown> = CommitLine<TFact> | ProgressLine<TProgress>;
+/** Every fact one transition recorded, in order, with the time the writer wrote them. */
+export interface CommitLine<TFact = unknown> {
+    /** When the writer wrote the line, as ISO 8601 in UTC. For display and durations, never order. */
+    readonly at: string;
+    /** Never empty. A fact may reference an entity an earlier fact in the same line introduced. */
+    readonly facts: readonly TFact[];
+}
+/** A preview of a value a later fact completes. Any progress record may be missing. */
+export interface ProgressLine<TProgress = unknown> {
+    readonly progress: TProgress;
+}
+/**
+ * The owners a fact belongs to, stamped by the publisher. Owners never change, so a scope never
+ * goes stale; readers that don't fold use it to place a fact.
+ */
+export interface Scope {
+    readonly turnId?: string;
+    readonly taskId?: string;
+    readonly runId?: string;
+    readonly changeId?: string;
+}
+/** A fact or progress record: its type (`family.verb`), its owners, and its payload. */
+export interface Envelope<TType extends string, TData> {
+    readonly type: TType;
+    readonly scope?: Scope;
+    readonly data: TData;
+}
+/**
+ * Records the stream route writes into a response. They are never stored and never counted, and
+ * readers ignore the ones they don't know.
+ */
+export type TransportRecord = PositionMarker | {
+    readonly $eve: "heartbeat";
+} | {
+    readonly $eve: "stream.lease-ended";
+} | {
+    readonly $eve: "stream.ended";
+};
+/** Written after lines a read skipped: the position of the next line the response sends. */
+export interface PositionMarker {
+    readonly $eve: "position";
+    readonly next: number;
+}
+export declare const HEARTBEAT_RECORD: {
+    readonly $eve: "heartbeat";
+};
+export declare const LEASE_ENDED_RECORD: {
+    readonly $eve: "stream.lease-ended";
+};
+export declare const STREAM_ENDED_RECORD: {
+    readonly $eve: "stream.ended";
+};
+/** Where one fact or progress record sits: its line's position, and its index in the line. */
+export interface FactPosition {
+    readonly line: number;
+    readonly index: number;
+}
+/** What one record read from a response is. */
+export type ReadRecord<TFact = unknown, TProgress = unknown> = {
+    readonly kind: "commit";
+    readonly line: CommitLine<TFact>;
+} | {
+    readonly kind: "progress";
+    readonly line: ProgressLine<TProgress>;
+} | {
+    readonly kind: "transport";
+    readonly record: TransportRecord;
+} | {
+    readonly kind: "unknown-transport";
+    readonly name: string;
+} | {
+    readonly kind: "invalid";
+    readonly value: unknown;
+};
+/** Tells the kinds of record apart by key, as every reader does. */
+export declare function classifyRecord<TFact = unknown, TProgress = unknown>(value: unknown): ReadRecord<TFact, TProgress>;
+/** True for a stored line: a commit or a progress record. */
+export declare function isStoredLine(value: unknown): value is StoredLine;
+/** Encodes one stored line as NDJSON. */
+export declare function encodeLine(line: StoredLine | TransportRecord): string;
+/** Below the workflow writer's 10 MiB per-chunk ceiling, including UTF-8 and the newline. */
+export declare const MAX_SESSION_LINE_BYTES: number;
+export declare class SessionLineTooLargeError extends Error {
+    readonly bytes: number;
+    constructor(bytes: number);
+}
+/** Encodes one atomic chunk, refusing oversized lines before a durable write. */
+export declare function encodeLineBytes(line: StoredLine | TransportRecord): Uint8Array;
+/**
+ * What caused something, by the entity that did. The set is open: a reader that meets a cause it
+ * doesn't know treats it as the system's.
+ */
+export type Cause = {
+    readonly deliveryId: string;
+} | {
+    readonly turnId: string;
+} | {
+    readonly taskId: string;
+} | {
+    readonly callId: string;
+} | {
+    readonly interactionId: string;
+} | {
+    readonly responseId: string;
+} | {
+    readonly changeId: string;
+} | {
+    readonly policy: string;
+} | {
+    readonly hook: string;
+};
+/** Who submitted a delivery, as its channel authenticated them. */
+export interface Principal {
+    readonly id: string;
+    /** Open: `"user"` and `"app"` today. */
+    readonly type: string;
+    readonly issuer?: string;
+}
+/** A failure's code and its human-readable message. Codes are open strings. */
+export interface ErrorInfo {
+    /** The thrown error's class name, when a producer knows it. */
+    readonly name?: string;
+    readonly code: string;
+    readonly message: string;
+    /** An id to quote when asking for support; the server's logs carry the same id. */
+    readonly id?: string;
+    /** What to do about it, when eve recognizes the failure: a person-facing remedy. */
+    readonly hint?: string;
+}
+/** Tokens and cost one unit of work spent. */
+export interface Usage {
+    readonly inputTokens: number;
+    readonly outputTokens: number;
+    readonly cacheReadTokens: number;
+    readonly cacheWriteTokens: number;
+    /** Absent when the provider reported no cost. */
+    readonly costUsd?: number;
+}
+/**
+ * A value carried by reference instead of inline: too large for a line, or withheld. A field
+ * that may be large has an inline slot and a `…Ref` slot, so absent, inline, referenced, and
+ * withheld values stay distinct.
+ */
+export interface ValueReference {
+    /** Resolved through a session-scoped route. Absent when the value is withheld. */
+    readonly ref?: string;
+    readonly mediaType?: string;
+    readonly size?: number;
+    /** A short preview for display. */
+    readonly preview?: string;
+    /** The value exists but isn't published. */
+    readonly withheld?: true;
+}
+/** Any JSON value. */
+export type { JsonValue } from "./json.js";
+/** One part of what a person sent. The kind set is open. */
+export type UserPart = {
+    readonly kind: "text";
+    readonly text: string;
+} | {
+    readonly kind: "file";
+    readonly mediaType: string;
+    readonly filename?: string;
+    readonly size?: number;
+    /** Absent with `unavailable` when no store holds the file. */
+    readonly ref?: string;
+    readonly url?: string;
+    readonly unavailable?: true;
+};

package/dist/src/protocol/session-events/envelope.js

@@ -0,0 +1 @@
+const HEARTBEAT_RECORD={$eve:`heartbeat`},LEASE_ENDED_RECORD={$eve:`stream.lease-ended`},STREAM_ENDED_RECORD={$eve:`stream.ended`};function classifyRecord(e){if(typeof e!=`object`||!e||Array.isArray(e))return{kind:`invalid`,value:e};let t=e;if(typeof t.$eve==`string`)switch(t.$eve){case`position`:return typeof t.next==`number`&&Number.isSafeInteger(t.next)?{kind:`transport`,record:{$eve:`position`,next:t.next}}:{kind:`unknown-transport`,name:t.$eve};case`heartbeat`:case`stream.lease-ended`:case`stream.ended`:return{kind:`transport`,record:{$eve:t.$eve}};default:return{kind:`unknown-transport`,name:t.$eve}}return Array.isArray(t.facts)&&typeof t.at==`string`?{kind:`commit`,line:e}:t.progress!==null&&typeof t.progress==`object`?{kind:`progress`,line:e}:{kind:`invalid`,value:e}}function isStoredLine(e){let{kind:t}=classifyRecord(e);return t===`commit`||t===`progress`}function encodeLine(e){return`${JSON.stringify(e)}\n`}const MAX_SESSION_LINE_BYTES=8388608;var SessionLineTooLargeError=class extends Error{bytes;constructor(e){super(`Session commit is ${e} bytes; the limit is ${MAX_SESSION_LINE_BYTES}. A commit cannot be split. Reduce inline content or use a supported value reference.`),this.name=`SessionLineTooLargeError`,this.bytes=e}};const lineEncoder=new TextEncoder;function encodeLineBytes(e){let t=lineEncoder.encode(encodeLine(e));if(t.byteLength>8388608)throw new SessionLineTooLargeError(t.byteLength);return t}export{HEARTBEAT_RECORD,LEASE_ENDED_RECORD,MAX_SESSION_LINE_BYTES,STREAM_ENDED_RECORD,SessionLineTooLargeError,classifyRecord,encodeLine,encodeLineBytes,isStoredLine};