eve 0.83.3 → 0.84.1

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};

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

@@ -0,0 +1,24 @@
+import type { CallFact, CallProgressRecord } from "./families/call.js";
+import type { ChildFact } from "./families/child.js";
+import type { ContentFact, ContentProgress } from "./families/content.js";
+import type { ContextFact } from "./families/context.js";
+import type { DeliveryFact } from "./families/delivery.js";
+import type { InteractionFact } from "./families/interaction.js";
+import type { ModelFact } from "./families/model.js";
+import type { ResponseFact } from "./families/response.js";
+import type { SessionFact } from "./families/session.js";
+import type { TaskFact } from "./families/task.js";
+import type { TurnFact } from "./families/turn.js";
+import type { UsageFact } from "./families/usage.js";
+/** A decision the machine made, or an observation it accepted. Facts are grouped by commit. */
+export type Fact = SessionFact | DeliveryFact | TurnFact | ModelFact | ContentFact | CallFact | TaskFact | InteractionFact | ResponseFact | ChildFact | ContextFact | UsageFact;
+/** A preview of a value a fact will complete. Never folded into the lifecycle tables. */
+export type Progress = ContentProgress | CallProgressRecord;
+/** The fact of one type. */
+export type FactOf<TType extends Fact["type"]> = Extract<Fact, {
+    readonly type: TType;
+}>;
+/** The progress record of one type. */
+export type ProgressOf<TType extends Progress["type"]> = Extract<Progress, {
+    readonly type: TType;
+}>;

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

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

package/dist/src/protocol/session-events/families/call.d.ts

@@ -0,0 +1,142 @@
+import { z } from "#compiled/zod/index.js";
+import type { Cause, Envelope, ErrorInfo, JsonValue, ValueReference } from "../envelope.js";
+/** What a call belongs to: the model run that made it, or the call it runs inside. */
+export type CallOwner = {
+    readonly runId: string;
+} | {
+    readonly callId: string;
+};
+/**
+ * What a call can invoke: a tool, an agent, a skill to load, or `control`, the model managing its
+ * own tasks (waiting on or cancelling them), which readers showing activity usually leave out. A
+ * newer eve can add one: a reader's switch keeps a default branch.
+ */
+export type CapabilityKind = "tool" | "agent" | "skill" | "control";
+/** What a call invokes. */
+export interface Capability {
+    readonly kind: CapabilityKind;
+    readonly name: string;
+    readonly label?: string;
+    /** An `agent` another deployment serves: a remote agent, not a subagent of this one. */
+    readonly remote?: true;
+}
+/** A preview of a call's input as the model writes it. The first record announces the call. */
+export interface CallInputData {
+    readonly callId: string;
+    /** On the announcing record only: the entry the model calls, and what it invokes. */
+    readonly name?: string;
+    readonly kind?: CapabilityKind;
+    readonly delta: string;
+}
+export interface CallRequestedData {
+    readonly callId: string;
+    readonly owner: CallOwner;
+    readonly capability: Capability;
+    readonly input?: JsonValue;
+    readonly inputRef?: ValueReference;
+    /** The model's input didn't validate; the call settles `failed` and never runs. */
+    readonly inputError?: ErrorInfo;
+}
+/** What cleared a call to run. Absent when it needed no approval. */
+export type ClearedBy = {
+    readonly policy: string;
+} | {
+    readonly interactionId: string;
+};
+export interface CallStartedData {
+    readonly callId: string;
+    readonly clearedBy?: ClearedBy;
+    /** The task that serves the call. */
+    readonly taskId?: string;
+}
+/** A bounded snapshot of a call's output so far; the latest replaces earlier ones. */
+export interface CallProgressData {
+    readonly callId: string;
+    readonly output: JsonValue;
+    /** The call's label for this output, from the tool. */
+    readonly label?: string;
+}
+export type CallOutcome = "completed" | "failed" | "rejected" | "interrupted" | "abandoned";
+export interface CallSettledData {
+    readonly callId: string;
+    readonly outcome: CallOutcome;
+    readonly output?: JsonValue;
+    readonly outputRef?: ValueReference;
+    /** The call whose `call.settled` carries this call's output, for calls a reply settled together. */
+    readonly outputOf?: {
+        readonly callId: string;
+    };
+    readonly error?: ErrorInfo;
+    /** Open: `turn-cancelled` and `authorization-required` for interrupted calls, among others. */
+    readonly reason?: string;
+    /** Who rejected the call: `{interactionId}` or `{policy}`. */
+    readonly cause?: Cause;
+    /** The call's label once it settled, from the tool. */
+    readonly label?: string;
+}
+export type CallInput = Envelope<"call.input", CallInputData>;
+export type CallRequested = Envelope<"call.requested", CallRequestedData>;
+export type CallStarted = Envelope<"call.started", CallStartedData>;
+export type CallProgress = Envelope<"call.progress", CallProgressData>;
+export type CallSettled = Envelope<"call.settled", CallSettledData>;
+export type CallFact = CallRequested | CallStarted | CallSettled;
+export type CallProgressRecord = CallInput | CallProgress;
+export declare const clearedBySchema: z.ZodUnion<readonly [z.ZodObject<{
+    policy: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    interactionId: z.ZodString;
+}, z.core.$strip>]>;
+export declare const callSchemas: {
+    "call.requested": 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<"call.requested">;
+    }, z.core.$strip>;
+    "call.settled": 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<"call.settled">;
+    }, z.core.$strip>;
+    "call.started": 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<"call.started">;
+    }, z.core.$strip>;
+};
+export declare const callProgressSchemas: {
+    "call.input": 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<"call.input">;
+    }, z.core.$strip>;
+    "call.progress": 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<"call.progress">;
+    }, z.core.$strip>;
+};

package/dist/src/protocol/session-events/families/call.js

@@ -0,0 +1 @@
+import{cause,conforming,envelopeOf,errorInfo,id,jsonValue,known,valueReference}from"../common.js";import{z}from"#compiled/zod/index.js";const owner=conforming()(z.union([z.object({runId:id}),z.object({callId:id})])),clearedBySchema=conforming()(z.union([z.object({policy:z.string()}),z.object({interactionId:id})])),callSchemas={"call.requested":envelopeOf(`call.requested`,conforming()(z.object({callId:id,capability:z.object({kind:known(),name:z.string(),remote:z.literal(!0).optional(),label:z.string().optional()}),input:jsonValue.optional(),inputError:errorInfo.optional(),inputRef:valueReference.optional(),owner}))),"call.settled":envelopeOf(`call.settled`,conforming()(z.object({callId:id,cause:cause.optional(),error:errorInfo.optional(),outcome:known(),output:jsonValue.optional(),outputOf:z.object({callId:id}).optional(),outputRef:valueReference.optional(),reason:z.string().optional(),label:z.string().optional()}))),"call.started":envelopeOf(`call.started`,conforming()(z.object({callId:id,clearedBy:clearedBySchema.optional(),taskId:id.optional()})))},callProgressSchemas={"call.input":envelopeOf(`call.input`,conforming()(z.object({callId:id,delta:z.string(),kind:known().optional(),name:z.string().optional()}))),"call.progress":envelopeOf(`call.progress`,conforming()(z.object({callId:id,output:jsonValue,label:z.string().optional()})))};export{callProgressSchemas,callSchemas,clearedBySchema};

package/dist/src/protocol/session-events/families/child.d.ts

@@ -0,0 +1,51 @@
+import { z } from "#compiled/zod/index.js";
+import type { Envelope } from "../envelope.js";
+export interface ChildOpenedData {
+    /** The child session; its own lifecycle lives in its own stream. */
+    readonly sessionId: string;
+    readonly owner: {
+        readonly callId: string;
+    } | {
+        readonly taskId: string;
+    };
+    readonly name: string;
+    /** The route that serves the child's stream: its own, or the parent-origin proxy for a remote child. */
+    readonly stream: string;
+}
+/**
+ * A delivery a child session accepted for one of this session's calls. The child's own stream
+ * records the delivery's lifecycle as its `deliveryId`.
+ */
+export interface ChildSentData {
+    /** The child session that accepted the delivery. */
+    readonly sessionId: string;
+    /** The delivery's id in the child's stream, not one of this session's deliveries. */
+    readonly childDeliveryId: string;
+    /** The call the delivery was sent for. */
+    readonly callId: string;
+}
+export type ChildOpened = Envelope<"child.opened", ChildOpenedData>;
+export type ChildSent = Envelope<"child.sent", ChildSentData>;
+export type ChildFact = ChildOpened | ChildSent;
+export declare const childSchemas: {
+    "child.opened": 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<"child.opened">;
+    }, z.core.$strip>;
+    "child.sent": 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<"child.sent">;
+    }, z.core.$strip>;
+};

package/dist/src/protocol/session-events/families/child.js

@@ -0,0 +1 @@
+import{conforming,envelopeOf,id}from"../common.js";import{z}from"#compiled/zod/index.js";const childSchemas={"child.opened":envelopeOf(`child.opened`,conforming()(z.object({name:z.string(),owner:z.union([z.object({callId:id}),z.object({taskId:id})]),sessionId:id,stream:z.string()}))),"child.sent":envelopeOf(`child.sent`,conforming()(z.object({callId:id,childDeliveryId:id,sessionId:id})))};export{childSchemas};

package/dist/src/protocol/session-events/families/content.d.ts

@@ -0,0 +1,56 @@
+import { z } from "#compiled/zod/index.js";
+import type { Envelope, JsonValue, ValueReference } from "../envelope.js";
+/** Wire parts use `kind`: `type` names the event. Authoring and UI parts use `type`. */
+/** A content part's kind. Open: `text`, `reasoning`, `result`, and `file` today. */
+export type ContentKind = "text" | "reasoning" | "result" | "file" | (string & {});
+/** Whether a part narrates work the turn continues with, or replies. Open; unknown reads as narration. */
+export type ContentPhase = "narration" | "reply" | (string & {});
+/** A preview of a part's value. The first record for a part announces it with its kind. */
+export interface ContentDeltaData {
+    readonly partId: string;
+    /** On the announcing record only. */
+    readonly kind?: ContentKind;
+    readonly delta: string;
+}
+export interface ContentCompletedData {
+    readonly partId: string;
+    readonly runId: string;
+    readonly kind: ContentKind;
+    /** The part's whole value: text for text and reasoning, JSON for a result, a file's metadata. */
+    readonly value?: JsonValue;
+    readonly valueRef?: ValueReference;
+    readonly phase: ContentPhase;
+    /** A cancel stopped the part; its value is what streamed. */
+    readonly interrupted?: true;
+    /** For kinds a reader doesn't know. */
+    readonly mediaType?: string;
+    readonly fallbackText?: string;
+}
+export type ContentDelta = Envelope<"content.delta", ContentDeltaData>;
+export type ContentCompleted = Envelope<"content.completed", ContentCompletedData>;
+export type ContentFact = ContentCompleted;
+export type ContentProgress = ContentDelta;
+export declare const contentSchemas: {
+    "content.completed": 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<"content.completed">;
+    }, z.core.$strip>;
+};
+export declare const contentProgressSchemas: {
+    "content.delta": 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<"content.delta">;
+    }, z.core.$strip>;
+};

package/dist/src/protocol/session-events/families/content.js

@@ -0,0 +1 @@
+import{conforming,envelopeOf,id,jsonValue,valueReference}from"../common.js";import{z}from"#compiled/zod/index.js";const contentSchemas={"content.completed":envelopeOf(`content.completed`,conforming()(z.object({fallbackText:z.string().optional(),interrupted:z.literal(!0).optional(),kind:z.string(),mediaType:z.string().optional(),partId:id,phase:z.string(),runId:id,value:jsonValue.optional(),valueRef:valueReference.optional()})))},contentProgressSchemas={"content.delta":envelopeOf(`content.delta`,conforming()(z.object({delta:z.string(),kind:z.string().optional(),partId:id})))};export{contentProgressSchemas,contentSchemas};

package/dist/src/protocol/session-events/families/context.d.ts

@@ -0,0 +1,55 @@
+import { z } from "#compiled/zod/index.js";
+import type { Cause, Envelope, ErrorInfo } from "../envelope.js";
+/** A context change's kind. Open: `compaction` and `clear` today. */
+export type ContextKind = "compaction" | "clear" | (string & {});
+export interface ContextStartedData {
+    readonly changeId: string;
+    readonly kind: ContextKind;
+    /** The turn a threshold compaction ran in. */
+    readonly turnId?: string;
+    /** The control delivery for a manual change. */
+    readonly cause?: Cause;
+    /** What started a threshold compaction. */
+    readonly trigger?: {
+        readonly inputTokens: number;
+    };
+}
+export type ContextOutcome = "completed" | "failed" | "cancelled" | "interrupted";
+export interface ContextSettledData {
+    readonly changeId: string;
+    readonly kind: ContextKind;
+    readonly outcome: ContextOutcome;
+    /**
+     * The change's effect on the conversation: `null` empties it until the next turn, a turn
+     * selects that turn. Absent when the conversation is unchanged, as for a compaction.
+     */
+    readonly selects?: null | {
+        readonly turnId: string;
+    };
+    readonly error?: ErrorInfo;
+}
+export type ContextStarted = Envelope<"context.started", ContextStartedData>;
+export type ContextSettled = Envelope<"context.settled", ContextSettledData>;
+export type ContextFact = ContextStarted | ContextSettled;
+export declare const contextSchemas: {
+    "context.settled": 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<"context.settled">;
+    }, z.core.$strip>;
+    "context.started": 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<"context.started">;
+    }, z.core.$strip>;
+};

package/dist/src/protocol/session-events/families/context.js

@@ -0,0 +1 @@
+import{cause,conforming,envelopeOf,errorInfo,id,known}from"../common.js";import{z}from"#compiled/zod/index.js";const contextSchemas={"context.settled":envelopeOf(`context.settled`,conforming()(z.object({changeId:id,error:errorInfo.optional(),kind:z.string(),outcome:known(),selects:z.object({turnId:id}).nullable().optional()}))),"context.started":envelopeOf(`context.started`,conforming()(z.object({cause:cause.optional(),changeId:id,kind:z.string(),trigger:z.object({inputTokens:z.number().int().nonnegative()}).optional(),turnId:id.optional()})))};export{contextSchemas};