eve 0.83.2 → 0.84.0

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

@@ -1,1198 +0,0 @@
-import type { FileUIPart, ProviderMetadata, TextUIPart, UserContent } from "ai";
-import type { ConnectionAuthorizationChallenge } from "#connections/errors.js";
-import type { RuntimeActionRequest, RuntimeActionResult, RuntimeToolResultActionResult } from "#shared/action-types.js";
-import type { InputRequest, InputResponse } from "#shared/input.js";
-import type { JsonObject, JsonValue } from "#shared/json.js";
-import type { TokenUsage } from "#shared/token-usage.js";
-export declare const EVE_SESSION_ID_HEADER = "x-eve-session-id";
-export declare const EVE_STREAM_FORMAT_HEADER = "x-eve-stream-format";
-export declare const EVE_STREAM_TAIL_INDEX_HEADER = "x-eve-stream-tail-index";
-export declare const EVE_STREAM_VERSION_HEADER = "x-eve-stream-version";
-export declare const EVE_MESSAGE_STREAM_CONTENT_TYPE = "application/x-ndjson; charset=utf-8";
-export declare const EVE_MESSAGE_STREAM_FORMAT = "ndjson";
-export declare const EVE_MESSAGE_STREAM_VERSION = "26";
-/** Version of transport control records understood by this eve release. */
-export declare const EVE_STREAM_CONTROL_VERSION = "1";
-export declare const EVE_STREAM_CONTROL_VERSION_QUERY = "streamControlVersion";
-/** Internal record emitted when a leased HTTP response should be renewed. */
-export declare const EVE_STREAM_LEASE_ENDED_CONTROL: {
-    readonly $eve: "stream.lease-ended";
-    readonly version: 1;
-};
-/**
- * eve-owned finish reason for one completed assistant step.
- *
- * `tool-calls` is the only non-terminal assistant step in the current
- * tool-loop harness. All other values indicate the assistant step ended the
- * current turn, except a step superseded by a steering message: it completes
- * with `other` and the turn continues with the next step.
- */
-export type AssistantStepFinishReason = "content-filter" | "error" | "length" | "other" | "stop" | "tool-calls";
-type ProviderMetadataEntry = NonNullable<ProviderMetadata[string]>;
-type GatewayGenerationId = Extract<ProviderMetadataEntry["generationId"], string>;
-export interface StepCompletedProviderMetadata {
-    readonly gateway: {
-        readonly generationId: GatewayGenerationId;
-    };
-}
-/**
- * Durable metadata attached to one persisted session stream event.
- *
- * Stamped once, immediately before the event is written to the workflow-owned
- * stream, and stored with it. Re-reading the stream — reconnecting, rewinding,
- * or replaying a finished session — yields the same values every time.
- */
-export interface MessageStreamEventMeta {
-    /** Server-issued message delivery identities, retained across the turn's workflow steps. */
-    readonly deliveryIds?: readonly string[];
-    /** ISO-8601 emission time. */
-    readonly at: string;
-    /**
-     * Unique, lexicographically sortable identifier for this event.
-     *
-     * Stamped from stream version 20 on: rewinding into a session that started
-     * before the upgrade yields events whose `id` is absent despite this type,
-     * and those cannot be deduplicated.
-     */
-    readonly id: string;
-}
-/**
- * Normalized completion status for one emitted runtime action result.
- *
- * `rejected` marks a tool call the user (or a policy) denied at a HITL
- * approval gate: it never executed, so it is neither a success nor a
- * runtime failure.
- */
-export type ActionResultStatus = "completed" | "failed" | "rejected";
-/**
- * Stable failure payload projected onto `action.result`.
- *
- * This keeps UI consumers from having to parse provider- or tool-specific
- * output strings just to determine whether a tool call failed.
- */
-export interface ActionResultError {
-    readonly code: string;
-    readonly message: string;
-    /** The `name` of the error a tool threw, such as `"QuotaError"`. */
-    readonly name?: string;
-}
-/**
- * Invocation metadata attached to the `session.started` event for one child
- * subagent workflow session.
- */
-export interface SubagentSessionInvocationMetadata {
-    readonly kind: "subagent";
-    readonly parentCallId: string;
-    readonly parentSessionId: string;
-    readonly parentTurnId: string;
-    readonly name: string;
-}
-/**
- * The session this one replaced. Present on a session eve started in place of
- * one whose deployment was retired, when the next ordinary channel message
- * arrived before the earlier session timed out. This session has its own id,
- * stream, auth, and state, and starts with no history from its predecessor;
- * read the predecessor with `sessions.attach(sessionId)` from `eve/server`.
- */
-export interface SessionPredecessor {
-    /** Id of the session this one replaced. Its recorded history stays readable. */
-    readonly sessionId: string;
-}
-/**
- * Runtime identity metadata attached to the `session.started` event.
- *
- * The server populates this at run time so remote eval processes and
- * reporters receive authoritative metadata about the eve instance
- * serving the run.
- */
-export interface RuntimeIdentity {
-    readonly agentId: string;
-    readonly agentName?: string;
-    readonly eveVersion: string;
-    readonly build?: {
-        readonly deployedAt?: string;
-        readonly gitBranch?: string;
-        readonly gitSha?: string;
-    };
-}
-/**
- * Portable trace coordinates for correlating an eve run with an external
- * observability backend. The fields follow the W3C trace-context model while
- * remaining owned by eve rather than exposing an OpenTelemetry type.
- */
-export interface RuntimeTraceContext {
-    readonly traceId: string;
-    readonly spanId: string;
-    readonly traceFlags: number;
-}
-/**
- * JSON request accepted by the canonical message route.
- *
- * `message` is either a plain text string or an AI SDK `UserContent`
- * array (mixing `text`, `image`, and `file` parts). Clients pass
- * multimodal attachments with the same shape AI SDK's `useChat`
- * `sendMessage({ files })` produces. `clientContext` is turn-scoped
- * client/page context; the channel converts it into internal model context
- * for every model call in that turn.
- */
-export type HandleMessageRequestBody = {
-    readonly inputResponses?: never;
-    readonly message: string | UserContent;
-    readonly clientContext?: string | readonly string[] | JsonObject;
-    readonly outputSchema?: JsonObject;
-} | {
-    readonly inputResponses: readonly InputResponse[];
-    readonly message?: never;
-    readonly clientContext?: string | readonly string[] | JsonObject;
-    readonly outputSchema?: JsonObject;
-};
-/**
- * Stream event emitted when the durable message workflow session starts.
- */
-export interface SessionStartedStreamEvent {
-    data: {
-        invocation?: SubagentSessionInvocationMetadata;
-        /** Present when this session replaced one that could no longer run. */
-        predecessor?: SessionPredecessor;
-        runtime?: RuntimeIdentity;
-        trace?: RuntimeTraceContext;
-    };
-    type: "session.started";
-}
-/** One message a delivery added with `history`, as `history.imported` publishes it. */
-export interface HistoryImportedMessage {
-    /** App-owned id the history entry carried, when one was supplied. */
-    readonly id?: string;
-    readonly role: "user" | "assistant";
-    readonly text: string;
-}
-/**
- * Stream event emitted when a delivery adds prior conversation with `history`.
- * It precedes that delivery's `message.received` in the same turn; the
- * messages sit in model history just before that turn's input.
- */
-export interface HistoryImportedStreamEvent {
-    data: {
-        messages: readonly HistoryImportedMessage[];
-        sequence: number;
-        turnId: string;
-    };
-    type: "history.imported";
-}
-/**
- * Stream event emitted when one runtime turn starts.
- */
-export interface TurnStartedStreamEvent {
-    data: {
-        sequence: number;
-        trace?: RuntimeTraceContext;
-        turnId: string;
-    };
-    type: "turn.started";
-}
-/**
- * Stream event emitted when the runtime receives one normalized user message.
- *
- * `message` is the existing flattened text summary. `parts` carries the
- * structured projection current emitters provide for clients that render
- * attachments.
- */
-export interface MessageReceivedStreamEvent {
-    data: {
-        message: string;
-        parts?: readonly MessageReceivedPart[];
-        sequence: number;
-        turnId: string;
-    };
-    type: "message.received";
-}
-/**
- * One structured part of a received user message.
- *
- * This mirrors the AI SDK UI text/file part surface, narrowed to renderable
- * metadata only. Raw bytes and framework-internal sandbox paths are never
- * projected; `url` is optional because it is present only for client-resolvable
- * `http(s)` and `data:` URLs.
- */
-export type MessageReceivedPart = Readonly<Pick<TextUIPart, "text" | "type">> | (Readonly<Pick<FileUIPart, "filename" | "mediaType" | "type">> & {
-    readonly size?: number;
-    readonly url?: FileUIPart["url"];
-});
-/**
- * Stream event emitted when the model requests one or more actions.
- *
- * A `tool-call` is one action kind, alongside `load-skill` and subagent calls.
- * Calls may arrive incrementally before execution, so consumers must correlate
- * action lifecycles by call ID rather than assume one event contains every call
- * from an assistant step.
- */
-export interface ActionPresentation {
-    readonly label?: string;
-}
-export type ActionPresentationByCallId = Readonly<Record<string, ActionPresentation>>;
-export interface ActionsRequestedStreamEvent {
-    data: {
-        actions: readonly RuntimeActionRequest[];
-        presentation?: ActionPresentationByCallId;
-        sequence: number;
-        stepIndex: number;
-        turnId: string;
-    };
-    type: "actions.requested";
-}
-export type ApprovalCandidateOutcome = "pending" | "rejected" | "failed" | "timed-out" | "stale";
-/** Safe lifecycle event for one responder-bound approval candidate. */
-export interface ApprovalCandidateStreamEvent {
-    data: {
-        candidateId: string;
-        outcome: ApprovalCandidateOutcome;
-        requestId: string;
-        responderPrincipalId: string;
-        reason?: string;
-        sequence: number;
-        stepIndex: number;
-        turnId: string;
-    };
-    type: "approval.candidate";
-}
-/** Terminal durable settlement for one approval request. */
-export interface ApprovalSettledStreamEvent {
-    data: {
-        outcome: "approved" | "cancelled";
-        requestId: string;
-        responderPrincipalId: string;
-        sequence: number;
-        stepIndex: number;
-        turnId: string;
-    };
-    type: "approval.settled";
-}
-/**
- * Stream event emitted when the harness needs human input before it can
- * continue the run.
- */
-export interface InputRequestedStreamEvent {
-    data: {
-        /**
-         * The call a relayed request serves: the task or workflow call whose run, or whose child
-         * session, asks. The request retains its origin coordinates. Absent for the
-         * session's own requests, whose approvals name their call in `request.action`.
-         */
-        callId?: string;
-        requests: readonly InputRequest[];
-        sequence: number;
-        stepIndex: number;
-        /** The task that asks, when the request comes from a task's run. */
-        taskId?: string;
-        turnId: string;
-    };
-    type: "input.requested";
-}
-/** Authoritative terminal outcome for one human-input request. */
-export type InputResolutionOutcome = "answered" | "approved" | "cancelled" | "denied" | "ignored" | "invalid";
-/** One server-accepted resolution from a pending human-input batch. */
-export interface InputResolution {
-    readonly kind: InputRequest["kind"];
-    readonly outcome: InputResolutionOutcome;
-    readonly requestId: string;
-    readonly response?: InputResponse;
-}
-/**
- * Stream event emitted after eve accepts a terminal resolution for one or more
- * pending human-input requests.
- */
-export interface InputResolvedStreamEvent {
-    data: {
-        resolutions: readonly InputResolution[];
-        sequence: number;
-        stepIndex: number;
-        turnId: string;
-    };
-    type: "input.resolved";
-}
-/**
- * Stream event emitted for each runtime action result projected back into the
- * session loop.
- */
-export interface ActionResultStreamEvent {
-    data: {
-        error?: ActionResultError;
-        presentation?: ActionPresentationByCallId;
-        result: RuntimeActionResult;
-        sequence: number;
-        stepIndex: number;
-        status: ActionResultStatus;
-        turnId: string;
-    };
-    type: "action.result";
-}
-/**
- * Stream event emitted for a preliminary snapshot from a locally executed
- * tool generator. The final snapshot is emitted as `action.result`.
- */
-export interface ActionPartialStreamEvent {
-    data: {
-        presentation?: ActionPresentationByCallId;
-        result: RuntimeToolResultActionResult;
-        sequence: number;
-        stepIndex: number;
-        turnId: string;
-    };
-    type: "action.partial";
-}
-/**
- * Stream event emitted when a workflow run opens a session with `ctx.agent`.
- * `callId` and `turnId` name the tool call whose run opened it; follow the
- * session with `session.agent(event).stream()`. For a task's run it comes
- * after that call's `task.started`.
- */
-export interface AgentStartedStreamEvent {
-    data: {
-        callId: string;
-        /** The turn of the call whose run opened the session. */
-        turnId: string;
-        /** The task whose run opened the session; absent when an `execute` call opened it. */
-        taskId?: string;
-        name: string;
-        /** The opened session's id. */
-        sessionId: string;
-        /** A local session's stream route, or the parent-origin proxy for a remote one. */
-        streamPath: string;
-        /**
-         * Where a remote session runs, read by the parent's stream proxy.
-         * `resolverId` keys the authored credential functions (`auth` and
-         * `headers`): a static agent's node id, or a dynamic agent's
-         * `credentialsStepId`. The event is persisted and streamed to clients, so
-         * it carries this key, never resolved header values.
-         */
-        remote?: {
-            resolverId?: string;
-            url: string;
-        };
-    };
-    type: "agent.started";
-}
-/**
- * Stream event emitted when a call starts a task. `(taskId, callId)`
- * identifies the call; `callId` is the tool call clients attach status to.
- * It comes before every event the task's run causes for the call, such as
- * `agent.started` and the call's `task.settled`.
- */
-export interface TaskStartedStreamEvent {
-    data: {
-        callId: string;
-        /**
-         * `"agent"` for a subagent's generated tool, local or remote; `"tool"`
-         * for an authored tool, including one that opens sessions with
-         * `ctx.agent`. An agent call that fails before its session opens has no
-         * `agent.started`, so this is how a client tells it is an agent call.
-         */
-        kind: "agent" | "tool";
-        /** The tool whose call started the task. */
-        name: string;
-        taskId: string;
-        turnId: string;
-    };
-    type: "task.started";
-}
-/**
- * Stream event emitted once when a task's call settles: by the run's return
- * or failure, or by a cancel. `turnId`, `name`, and `kind` are the same as on
- * the call's `task.started`.
- */
-export interface TaskSettledStreamEvent {
-    data: {
-        callId: string;
-        /**
-         * Why the call was cancelled; present only when `status` is `"cancelled"`
-         * and the session stopped it. Absent when the task's run stopped on its
-         * own, and on events recorded by eve versions before it was added.
-         */
-        cancel?: {
-            reason: TaskCancelReason;
-        };
-        /** Why the call failed; present only when `status` is `"failed"`. */
-        error?: {
-            message: string;
-        };
-        /**
-         * The task's kind, as on `task.started`. Absent on events recorded by eve
-         * versions before it was added.
-         */
-        kind?: TaskStartedStreamEvent["data"]["kind"];
-        /**
-         * The tool whose call started the task, as on `task.started`. Absent on
-         * events recorded by eve versions before it was added.
-         */
-        name?: string;
-        /** The call's result; present only when `status` is `"completed"`. */
-        output?: JsonValue;
-        status: "completed" | "failed" | "cancelled";
-        taskId: string;
-        turnId: string;
-    };
-    type: "task.settled";
-}
-/**
- * Why the session cancelled a task call: the model called `eve__task_cancel`,
- * someone cancelled the turn (or, between turns, the tasks still working), or
- * the turn ended while the task still worked.
- */
-export type TaskCancelReason = "task_cancel" | "turn_cancelled" | "turn_ended";
-/**
- * Stream event emitted when one assistant text delta is appended to the
- * current message for the current step.
- */
-export interface MessageAppendedStreamEvent {
-    data: {
-        messageDelta: string;
-        sequence: number;
-        stepIndex: number;
-        turnId: string;
-    };
-    type: "message.appended";
-}
-/**
- * Stream event emitted while the model is generating the input for one tool
- * call, before the validated call is announced via `actions.requested`.
- */
-export interface ActionInputAppendedStreamEvent {
-    data: {
-        callId: string;
-        inputTextDelta: string;
-        sequence: number;
-        stepIndex: number;
-        toolName: string;
-        turnId: string;
-    };
-    type: "action.input.appended";
-}
-/**
- * Stream event emitted when one reasoning delta is appended to the current
- * reasoning block for the current step.
- */
-export interface ReasoningAppendedStreamEvent {
-    data: {
-        reasoningDelta: string;
-        sequence: number;
-        stepIndex: number;
-        turnId: string;
-    };
-    type: "reasoning.appended";
-}
-/**
- * Stream event emitted when one assistant step completes with visible text.
- *
- * Events preserve the order of the underlying model response messages. A
- * single turn may emit more than one completed assistant message when the
- * model replies before requesting a tool call. `data.finishReason` describes
- * why that assistant message boundary completed.
- */
-export interface MessageCompletedStreamEvent {
-    data: {
-        finishReason: AssistantStepFinishReason;
-        message: string;
-        sequence: number;
-        stepIndex: number;
-        turnId: string;
-    };
-    type: "message.completed";
-}
-/**
- * Stream event emitted when one completed reasoning block is available for the
- * current step.
- */
-export interface ReasoningCompletedStreamEvent {
-    data: {
-        reasoning: string;
-        sequence: number;
-        stepIndex: number;
-        turnId: string;
-    };
-    type: "reasoning.completed";
-}
-/**
- * Stream event emitted when the harness finalized a structured result that
- * matches the requested output schema.
- */
-export interface ResultCompletedStreamEvent {
-    data: {
-        result: JsonValue;
-        sequence: number;
-        stepIndex: number;
-        turnId: string;
-    };
-    type: "result.completed";
-}
-/**
- * Stream event emitted when one model call starts inside the current turn.
- */
-export interface StepStartedStreamEvent {
-    data: {
-        readonly modelId: string;
-        sequence: number;
-        stepIndex: number;
-        turnId: string;
-    };
-    type: "step.started";
-}
-/**
- * Stream event emitted when one model call completes successfully.
- */
-export interface StepCompletedStreamEvent {
-    data: {
-        finishReason: AssistantStepFinishReason;
-        providerMetadata?: StepCompletedProviderMetadata;
-        sequence: number;
-        stepIndex: number;
-        turnId: string;
-        usage?: {
-            readonly costUsd?: number;
-            readonly inputTokens?: number;
-            readonly outputTokens?: number;
-            readonly cacheReadTokens?: number;
-            readonly cacheWriteTokens?: number;
-        };
-    };
-    type: "step.completed";
-}
-/**
- * Stream event emitted when one model call fails.
- */
-export interface StepFailedStreamEvent {
-    data: {
-        code: string;
-        details?: JsonObject;
-        message: string;
-        sequence: number;
-        stepIndex: number;
-        turnId: string;
-    };
-    type: "step.failed";
-}
-/**
- * Stream event emitted when one turn reaches a terminal successful outcome.
- */
-export interface TurnCompletedStreamEvent {
-    data: {
-        sequence: number;
-        turnId: string;
-    };
-    type: "turn.completed";
-}
-/** What an open turn waits on when it parks; see {@link TurnWaitingStreamEvent}. */
-export type TurnWaitingOn = "input" | "tasks";
-/**
- * Stream event emitted each time an open turn parks, such as when a call it is
- * running asks a question. The turn stays open: the next `step.started` with
- * the same `turnId` means it resumed, and only `turn.completed`,
- * `turn.failed`, or `turn.cancelled` end it.
- */
-export interface TurnWaitingStreamEvent {
-    data: {
-        /**
-         * What the turn waits on. `"input"`: a person must act on a sign-in,
-         * approval, or question; clients stop reading here. `"tasks"`: work the
-         * turn started is still running, and the turn resumes on its own.
-         */
-        on: TurnWaitingOn;
-        sequence: number;
-        turnId: string;
-        /**
-         * The session's token usage so far: its own model calls plus what the
-         * agents it delegated to spent. `costUsd` is absent when no model call
-         * reported a cost. Absent on events from eve versions before it was added.
-         */
-        usage?: TokenUsage;
-    };
-    type: "turn.waiting";
-}
-/**
- * Stream event emitted when one turn fails.
- */
-export interface TurnFailedStreamEvent {
-    data: {
-        code: string;
-        details?: JsonObject;
-        message: string;
-        sequence: number;
-        /**
-         * `true` when the failure ends the session and `session.failed` follows;
-         * `false` when `session.waiting` follows and the next message can retry.
-         * Absent on events from eve versions before it was added.
-         */
-        terminal?: boolean;
-        turnId: string;
-    };
-    type: "turn.failed";
-}
-/**
- * Stream event emitted when one turn is cancelled before reaching a
- * terminal outcome. Cancellation is not failure: the turn ends without
- * `turn.failed`/`session.failed`, is followed by `session.waiting`, and
- * the session accepts the next message normally.
- */
-export interface TurnCancelledStreamEvent {
-    data: {
-        sequence: number;
-        turnId: string;
-    };
-    type: "turn.cancelled";
-}
-/**
- * Stream event emitted after the durable model-message history is cleared.
- * The session itself and its non-message state remain active.
- */
-export interface ContextClearedStreamEvent {
-    data: {
-        sequence: number;
-        sessionId: string;
-        turnId: string;
-    };
-    type: "context.cleared";
-}
-/**
- * Stream event emitted when the workflow decides to compact the current
- * visible session history before the next model fragment runs.
- */
-export interface CompactionRequestedStreamEvent {
-    data: {
-        modelId: string;
-        sequence: number;
-        sessionId: string;
-        stepIndex: number;
-        turnId: string;
-        usageInputTokens: number | null;
-    };
-    type: "compaction.requested";
-}
-/**
- * Stream event emitted after one compaction checkpoint message has been
- * appended to the durable session history.
- */
-export interface CompactionCompletedStreamEvent {
-    data: {
-        modelId: string;
-        sequence: number;
-        sessionId: string;
-        stepIndex: number;
-        turnId: string;
-    };
-    type: "compaction.completed";
-}
-/**
- * Who a sign-in is for: the connection principal's identity. Its `attributes` stay out of
- * events, which reach every client of the stream.
- */
-export type AuthorizationPrincipal = {
-    readonly type: "app";
-} | {
-    readonly type: "user";
-    readonly id: string;
-    readonly issuer?: string;
-};
-/**
- * Stream event emitted when a connection or tool needs user authorization
- * before it can continue.
- */
-export interface AuthorizationRequiredStreamEvent {
-    data: {
-        /** Stable identity of this exact authorization attempt. */
-        attemptId?: string;
-        authorization?: ConnectionAuthorizationChallenge;
-        candidateId?: string;
-        description: string;
-        /** The credential the sign-in grants, shared by every scope that uses it. */
-        grant?: string;
-        name: string;
-        /** The connection principal the sign-in is for. */
-        principal?: AuthorizationPrincipal;
-        /**
-         * Session principal that started this sign-in, matching `responderPrincipalId`
-         * on approval events. Channels use it to deliver the challenge privately.
-         */
-        principalId?: string;
-        sequence: number;
-        stepIndex: number;
-        /** The task that needs the sign-in, when it comes from a task's run. */
-        taskId?: string;
-        turnId: string;
-        webhookUrl?: string;
-    };
-    type: "authorization.required";
-}
-/**
- * Outcome of one completed authorization attempt, emitted on
- * {@link AuthorizationCompletedStreamEvent}.
- */
-export type AuthorizationOutcome = "authorized" | "declined" | "failed" | "timed-out";
-/**
- * @deprecated Use {@link AuthorizationOutcome}.
- */
-export type ConnectionAuthorizationOutcome = AuthorizationOutcome;
-/**
- * Stream event emitted once `completeAuthorization` has resolved
- * (successfully or otherwise) for one pending authorization. Carries a
- * stable `outcome` plus an optional human-readable `reason`.
- *
- * Emitted when the tool completes authorization on resume, before the
- * model's next fragment streams in.
- */
-export interface AuthorizationCompletedStreamEvent {
-    data: {
-        /** Stable identity shared with the matching required event. */
-        attemptId?: string;
-        candidateId?: string;
-        /**
-         * The challenge from the matching `authorization.required` event,
-         * journaled across the park. Lets channels keep rendering the
-         * challenge's `displayName` in completion status text.
-         */
-        authorization?: ConnectionAuthorizationChallenge;
-        /** The credential the sign-in grants, as on the matching `authorization.required`. */
-        grant?: string;
-        name: string;
-        outcome: AuthorizationOutcome;
-        /** The connection principal the sign-in is for, as on the matching `authorization.required`. */
-        principal?: AuthorizationPrincipal;
-        /** Session principal that started the matching sign-in. */
-        principalId?: string;
-        reason?: string;
-        /**
-         * Whether a `failed` sign-in may be started again in the turn. `false` is terminal: the
-         * session reports the failure instead. Absent means retryable, as on events from eve
-         * versions before it.
-         */
-        retryable?: boolean;
-        sequence: number;
-        stepIndex: number;
-        /** The task that needed the sign-in, when it comes from a task's run. */
-        taskId?: string;
-        turnId: string;
-    };
-    type: "authorization.completed";
-}
-/**
- * Stream event emitted when the session parks waiting for the next user
- * message.
- */
-export interface SessionWaitingStreamEvent {
-    data: {
-        /** Channel-local continuation token, or the immutable session ID for an ID-only session. */
-        continuationToken: string;
-        /**
-         * The session's token usage so far: its own model calls plus what the
-         * agents it delegated to spent. `costUsd` is absent when no model call
-         * reported a cost. Absent on events from eve versions before it was added.
-         */
-        usage?: TokenUsage;
-        wait: "next-user-message";
-    };
-    type: "session.waiting";
-}
-/**
- * Stream event emitted when the session fails.
- */
-export interface SessionFailedStreamEvent {
-    data: {
-        code: string;
-        details?: JsonObject;
-        message: string;
-        sessionId: string;
-        /**
-         * The session's token usage so far: its own model calls plus what the
-         * agents it delegated to spent. `costUsd` is absent when no model call
-         * reported a cost. Absent on events from eve versions before it was added.
-         */
-        usage?: TokenUsage;
-    };
-    type: "session.failed";
-}
-/**
- * Stream event emitted when the session completes successfully.
- */
-export interface SessionCompletedStreamEvent {
-    /** Absent when the session's usage was unknown, and on events from eve versions before it was added. */
-    data?: {
-        /**
-         * The session's token usage: its own model calls plus what the agents it
-         * delegated to spent. `costUsd` is absent when no model call reported a cost.
-         */
-        usage: TokenUsage;
-    };
-    type: "session.completed";
-}
-/**
- * Serializable event before eve stamps the durable stream envelope.
- *
- * Internal emitters use this type while constructing events. Public stream
- * consumers receive {@link MessageStreamEvent}.
- */
-export type UnstampedMessageStreamEvent = ActionInputAppendedStreamEvent | AgentStartedStreamEvent | ApprovalCandidateStreamEvent | ApprovalSettledStreamEvent | ContextClearedStreamEvent | CompactionCompletedStreamEvent | HistoryImportedStreamEvent | CompactionRequestedStreamEvent | AuthorizationCompletedStreamEvent | AuthorizationRequiredStreamEvent | MessageAppendedStreamEvent | MessageCompletedStreamEvent | MessageReceivedStreamEvent | ReasoningAppendedStreamEvent | SessionCompletedStreamEvent | SessionFailedStreamEvent | SessionStartedStreamEvent | SessionWaitingStreamEvent | ResultCompletedStreamEvent | TaskSettledStreamEvent | TaskStartedStreamEvent | ActionsRequestedStreamEvent | InputRequestedStreamEvent | InputResolvedStreamEvent | ActionPartialStreamEvent | ActionResultStreamEvent | ReasoningCompletedStreamEvent | StepCompletedStreamEvent | StepFailedStreamEvent | StepStartedStreamEvent | TurnCancelledStreamEvent | TurnCompletedStreamEvent | TurnFailedStreamEvent | TurnStartedStreamEvent | TurnWaitingStreamEvent;
-/**
- * Stream events that represent an unrecovered turn/session failure.
- */
-export type TurnFailureStreamEvent = SessionFailedStreamEvent | StepFailedStreamEvent | TurnFailedStreamEvent;
-/**
- * One event read from an eve session stream.
- *
- * eve stamps the durable identity and emission time before writing the event.
- */
-export type MessageStreamEvent = UnstampedMessageStreamEvent & {
-    readonly meta: MessageStreamEventMeta;
-};
-/**
- * @deprecated Use {@link MessageStreamEvent}.
- */
-export type HandleMessageStreamEvent = MessageStreamEvent;
-/**
- * Returns true when the current stream has reached a turn boundary or terminal
- * session outcome.
- */
-export declare function isCurrentTurnBoundaryEvent(event: UnstampedMessageStreamEvent): boolean;
-/**
- * Narrows a stream event to the failure events that terminate or poison a turn.
- *
- * Generic so narrowing keeps the input's stamping: a
- * {@link MessageStreamEvent} narrows to a stamped failure event.
- */
-export declare function isTurnFailureEvent<TEvent extends UnstampedMessageStreamEvent>(event: TEvent): event is TEvent & TurnFailureStreamEvent;
-/** Creates the `history.imported` event for the messages one delivery added. */
-export declare function createHistoryImportedEvent(input: {
-    readonly messages: readonly HistoryImportedMessage[];
-    readonly sequence: number;
-    readonly turnId: string;
-}): HistoryImportedStreamEvent;
-/**
- * Creates the `session.started` event for one session.
- */
-export declare function createSessionStartedEvent(input?: {
-    readonly invocation?: SubagentSessionInvocationMetadata;
-    readonly predecessor?: SessionPredecessor;
-    readonly runtime?: RuntimeIdentity;
-    readonly trace?: RuntimeTraceContext;
-}): SessionStartedStreamEvent;
-/**
- * Creates the `turn.started` event for one prepared runtime turn.
- */
-export declare function createTurnStartedEvent(input: {
-    readonly sequence: number;
-    readonly trace?: RuntimeTraceContext;
-    readonly turnId: string;
-}): TurnStartedStreamEvent;
-/**
- * Creates the `message.received` event for one normalized user message.
- *
- * When the message is a structured `UserContent` array (e.g. text + file
- * parts), the event surfaces a text summary: concatenated text parts with
- * `[file: filename (mediaType)]` placeholders for non-text parts. This
- * keeps the wire event as a simple string for dev-REPL and web
- * consumers while preserving the authored turn content upstream.
- */
-export declare function createMessageReceivedEvent(input: {
-    readonly message: string | UserContent;
-    readonly sequence: number;
-    readonly turnId: string;
-}): MessageReceivedStreamEvent;
-/**
- * Creates the `actions.requested` event for one observed group of model action
- * requests.
- */
-export declare function createActionsRequestedEvent(input: {
-    readonly actions: readonly RuntimeActionRequest[];
-    readonly presentation?: ActionPresentationByCallId;
-    readonly sequence: number;
-    readonly stepIndex: number;
-    readonly turnId: string;
-}): ActionsRequestedStreamEvent;
-/** Creates an `action.input.appended` event for streamed tool input text. */
-export declare function createActionInputAppendedEvent(input: {
-    readonly callId: string;
-    readonly inputTextDelta: string;
-    readonly sequence: number;
-    readonly stepIndex: number;
-    readonly toolName: string;
-    readonly turnId: string;
-}): ActionInputAppendedStreamEvent;
-/**
- * Creates the `authorization.required` event for one authorization source
- * that needs user authorization before it can continue.
- *
- * `authorization` and `webhookUrl` are present together when the runtime
- * has suspended the turn on a framework-owned webhook; both are absent
- * for `getToken`-only authorization sources that authorize out of band.
- */
-export declare function createAuthorizationRequiredEvent(input: {
-    readonly attemptId?: string;
-    readonly authorization?: ConnectionAuthorizationChallenge;
-    readonly candidateId?: string;
-    readonly description: string;
-    readonly grant?: string;
-    readonly name: string;
-    readonly principal?: AuthorizationPrincipal;
-    readonly principalId?: string;
-    readonly sequence: number;
-    readonly stepIndex: number;
-    readonly taskId?: string;
-    readonly turnId: string;
-    readonly webhookUrl?: string;
-}): AuthorizationRequiredStreamEvent;
-/**
- * Creates the `authorization.completed` event emitted once per
- * authorization source after `completeAuthorization` has resolved or the
- * authorization deadline has expired.
- */
-export declare function createAuthorizationCompletedEvent(input: {
-    readonly attemptId?: string;
-    readonly authorization?: ConnectionAuthorizationChallenge;
-    readonly candidateId?: string;
-    readonly grant?: string;
-    readonly name: string;
-    readonly outcome: AuthorizationOutcome;
-    readonly principal?: AuthorizationPrincipal;
-    readonly principalId?: string;
-    readonly reason?: string;
-    readonly retryable?: boolean;
-    readonly sequence: number;
-    readonly stepIndex: number;
-    readonly taskId?: string;
-    readonly turnId: string;
-}): AuthorizationCompletedStreamEvent;
-/** Creates a safe candidate lifecycle event. */
-export declare function createApprovalCandidateEvent(input: ApprovalCandidateStreamEvent["data"]): ApprovalCandidateStreamEvent;
-/** Creates a terminal approval settlement event. */
-export declare function createApprovalSettledEvent(input: ApprovalSettledStreamEvent["data"]): ApprovalSettledStreamEvent;
-/**
- * Creates the `input.requested` event for one pending HITL batch.
- */
-export declare function createInputRequestedEvent(input: {
-    readonly callId?: string;
-    readonly requests: readonly InputRequest[];
-    readonly sequence: number;
-    readonly stepIndex: number;
-    readonly taskId?: string;
-    readonly turnId: string;
-}): InputRequestedStreamEvent;
-/** Creates the authoritative `input.resolved` event for one pending HITL batch. */
-export declare function createInputResolvedEvent(input: {
-    readonly resolutions: readonly InputResolution[];
-    readonly sequence: number;
-    readonly stepIndex: number;
-    readonly turnId: string;
-}): InputResolvedStreamEvent;
-/**
- * Creates the `action.result` event for one runtime action result.
- *
- * Pass `rejected: true` for a tool call denied at a HITL approval gate. The
- * call never executed, so the outcome is forced to `rejected` rather than
- * derived from the synthesized denial output.
- */
-export declare function createActionResultEvent(input: {
-    readonly presentation?: ActionPresentationByCallId;
-    readonly rejected?: boolean;
-    readonly result: RuntimeActionResult;
-    readonly sequence: number;
-    readonly stepIndex: number;
-    readonly turnId: string;
-}): ActionResultStreamEvent;
-/** Creates an `action.partial` event for one preliminary tool-result snapshot. */
-export declare function createActionPartialEvent(input: {
-    readonly presentation?: ActionPresentationByCallId;
-    readonly result: RuntimeToolResultActionResult;
-    readonly sequence: number;
-    readonly stepIndex: number;
-    readonly turnId: string;
-}): ActionPartialStreamEvent;
-/** Creates the `task.started` event for one call that starts a task. */
-export declare function createTaskStartedEvent(input: TaskStartedStreamEvent["data"]): TaskStartedStreamEvent;
-/** Creates the `task.settled` event for one settled task call. */
-export declare function createTaskSettledEvent(input: TaskSettledStreamEvent["data"]): TaskSettledStreamEvent;
-/**
- * Creates the `agent.started` event for one session a workflow run opened.
- */
-export declare function createAgentStartedEvent(input: {
-    readonly callId: string;
-    readonly name: string;
-    readonly parentSessionId: string;
-    readonly remote?: {
-        readonly resolverId?: string;
-        readonly url: string;
-    };
-    readonly sessionId: string;
-    readonly taskId?: string;
-    readonly turnId: string;
-}): AgentStartedStreamEvent;
-/**
- * Creates the `message.appended` event for one streamed assistant text delta.
- */
-export declare function createMessageAppendedEvent(input: {
-    readonly messageDelta: string;
-    readonly sequence: number;
-    readonly stepIndex: number;
-    readonly turnId: string;
-}): MessageAppendedStreamEvent;
-/**
- * Creates the `reasoning.appended` event for one streamed reasoning delta.
- */
-export declare function createReasoningAppendedEvent(input: {
-    readonly reasoningDelta: string;
-    readonly sequence: number;
-    readonly stepIndex: number;
-    readonly turnId: string;
-}): ReasoningAppendedStreamEvent;
-/**
- * Creates the `message.completed` event for one completed assistant text chunk.
- */
-export declare function createMessageCompletedEvent(input: {
-    readonly finishReason?: AssistantStepFinishReason;
-    readonly message: string;
-    readonly sequence: number;
-    readonly stepIndex: number;
-    readonly turnId: string;
-}): MessageCompletedStreamEvent;
-/**
- * Creates the `reasoning.completed` event for one completed reasoning block.
- */
-export declare function createReasoningCompletedEvent(input: {
-    readonly reasoning: string;
-    readonly sequence: number;
-    readonly stepIndex: number;
-    readonly turnId: string;
-}): ReasoningCompletedStreamEvent;
-/**
- * Creates the `result.completed` event for one finalized structured result.
- */
-export declare function createResultCompletedEvent(input: {
-    readonly result: JsonValue;
-    readonly sequence: number;
-    readonly stepIndex: number;
-    readonly turnId: string;
-}): ResultCompletedStreamEvent;
-/**
- * Creates the `step.started` event for one model call.
- */
-export declare function createStepStartedEvent(input: {
-    readonly modelId: string;
-    readonly sequence: number;
-    readonly stepIndex: number;
-    readonly turnId: string;
-}): StepStartedStreamEvent;
-/**
- * Creates the `step.completed` event for one completed model call.
- */
-export declare function createStepCompletedEvent(input: {
-    readonly finishReason: AssistantStepFinishReason;
-    readonly providerMetadata?: StepCompletedProviderMetadata;
-    readonly sequence: number;
-    readonly stepIndex: number;
-    readonly turnId: string;
-    readonly usage?: {
-        readonly costUsd?: number;
-        readonly inputTokens?: number;
-        readonly outputTokens?: number;
-        readonly cacheReadTokens?: number;
-        readonly cacheWriteTokens?: number;
-    };
-}): StepCompletedStreamEvent;
-/**
- * Creates the `step.failed` event for one failed model call.
- */
-export declare function createStepFailedEvent(input: {
-    readonly code: string;
-    readonly details?: JsonObject;
-    readonly message: string;
-    readonly sequence: number;
-    readonly stepIndex: number;
-    readonly turnId: string;
-}): StepFailedStreamEvent;
-/**
- * Creates the `turn.completed` event for one terminal successful turn.
- */
-export declare function createTurnCompletedEvent(input: {
-    readonly sequence: number;
-    readonly turnId: string;
-}): TurnCompletedStreamEvent;
-/**
- * Creates the `turn.waiting` event for one open turn that parked.
- */
-export declare function createTurnWaitingEvent(input: {
-    readonly on: TurnWaitingOn;
-    readonly sequence: number;
-    readonly turnId: string;
-    readonly usage: TokenUsage | undefined;
-}): TurnWaitingStreamEvent;
-/**
- * Creates the `turn.failed` event for one failed turn.
- */
-export declare function createTurnFailedEvent(input: {
-    readonly code: string;
-    readonly details?: JsonObject;
-    readonly message: string;
-    readonly sequence: number;
-    readonly terminal: boolean;
-    readonly turnId: string;
-}): TurnFailedStreamEvent;
-/** Creates the `turn.cancelled` event for one cancelled turn. */
-export declare function createTurnCancelledEvent(input: {
-    readonly sequence: number;
-    readonly turnId: string;
-}): TurnCancelledStreamEvent;
-/** Creates the `context.cleared` event for one manual history clear. */
-export declare function createContextClearedEvent(input: {
-    readonly sequence: number;
-    readonly sessionId: string;
-    readonly turnId: string;
-}): ContextClearedStreamEvent;
-/**
- * Creates the `compaction.requested` event for one runtime compaction pass.
- */
-export declare function createCompactionRequestedEvent(input: {
-    readonly modelId: string;
-    readonly sequence: number;
-    readonly sessionId: string;
-    readonly stepIndex: number;
-    readonly turnId: string;
-    readonly usageInputTokens: number | undefined;
-}): CompactionRequestedStreamEvent;
-/**
- * Creates the `compaction.completed` event for one appended checkpoint.
- */
-export declare function createCompactionCompletedEvent(input: {
-    readonly modelId: string;
-    readonly sequence: number;
-    readonly sessionId: string;
-    readonly stepIndex: number;
-    readonly turnId: string;
-}): CompactionCompletedStreamEvent;
-/**
- * Creates the `session.waiting` event for the only supported between-turn
- * wait.
- */
-export declare function createSessionWaitingEvent(usage: TokenUsage | undefined): SessionWaitingStreamEvent;
-/**
- * Creates the `session.failed` event for one terminal session failure.
- */
-export declare function createSessionFailedEvent(input: {
-    readonly code: string;
-    readonly details?: JsonObject;
-    readonly message: string;
-    readonly sessionId: string;
-    readonly usage: TokenUsage | undefined;
-}): SessionFailedStreamEvent;
-/**
- * Creates the `session.completed` event for one terminal session completion.
- */
-export declare function createSessionCompletedEvent(usage: TokenUsage | undefined): SessionCompletedStreamEvent;
-/**
- * Stamps one session event with its durable identity and emission time.
- *
- * Runtime/execution code only, once per event, immediately before the write.
- * One stamping seam is what makes the persisted stream and authored hooks
- * observe the same `meta.id`.
- */
-export declare function stampMessageStreamEvent(event: UnstampedMessageStreamEvent, deliveryIds?: readonly string[]): MessageStreamEvent;
-/**
- * Encodes one message stream event as newline-delimited JSON.
- */
-export declare function encodeMessageStreamEvent(event: MessageStreamEvent): Uint8Array;
-export {};