eve 0.83.2 → 0.84.0

package/dist/src/public/connections/index.d.ts

@@ -1,13 +1,11 @@
 /**
  * Connection authoring helpers for `agent/connections/*.ts` files.
  */
-export type { AuthorizationCallback, AuthorizationDefinition, CredentialOwner, ConnectionAuthDefinition, ConnectionAuthProvider, ConnectionAuthResolver, ConnectionPrincipal, HeadersDefinition, InteractiveAuthorizationDefinition, NonInteractiveAuthorizationDefinition, TokenResult, ToolFilterDefinition, } from "#shared/connection-types.js";
+export type { AuthorizationCallback, AuthorizationDefinition, ConnectionAuthDefinition, ConnectionAuthResolver, ConnectionPrincipal, HeadersDefinition, InteractiveAuthorizationDefinition, NonInteractiveAuthorizationDefinition, TokenResult, ToolFilterDefinition, } from "#shared/connection-types.js";
 export { defineInteractiveAuthorization } from "#shared/connection-types.js";
-export type { JsonValue } from "#public/types/json.js";
-export { defineDynamic, type DynamicConnectionDefinition, type DynamicConnectionEvents, type DynamicConnectionResolveContext, type DynamicConnectionResult, type DynamicConnectionSet, } from "#public/definitions/connections/dynamic.js";
-export type { DynamicResolveContext, DynamicSentinel } from "#dynamic/definition.js";
+export { defineDynamic, type DynamicConnectionDefinition, type DynamicConnectionResult, type DynamicConnectionSet, } from "#public/definitions/connections/dynamic.js";
+export type { DynamicContext, DynamicKey, DynamicModelContext, DynamicSentinel, DynamicTurn, Memo, Occurrence, SessionFrame, } from "#dynamic/definition.js";
 export { defineMcpClientConnection, type McpClientConnectionDefinition, } from "#public/definitions/connections/mcp.js";
 export type { ConnectionToolCallDefinition, ProvidedArgumentContext, ProvidedArgumentsDefinition, ProvidedArgumentValue, } from "#public/definitions/connections/tool-call.js";
 export { defineOpenAPIConnection, type OpenAPIConnectionDefinition, type OpenAPISpecSource, } from "#public/definitions/connections/openapi.js";
 export { type ConnectionAuthorizationChallenge, ConnectionAuthorizationFailedError, type ConnectionAuthorizationFailedErrorOptions, ConnectionAuthorizationRequiredError, type ConnectionAuthorizationRequiredErrorOptions, isConnectionAuthorizationFailedError, isConnectionAuthorizationRequiredError, } from "#public/connections/errors.js";
-export type { Experimental_ConnectionEvents, Experimental_ConnectionEvent, Experimental_ConnectionEventOrigin, Experimental_ConnectionEventContext, } from "#public/definitions/connections/events.js";

package/dist/src/public/context/index.d.ts

@@ -9,6 +9,7 @@
  * import { defineState } from "eve/context";
  * ```
  */
-export type { Session, SessionAuth, SessionAuthContext, SessionParent, SessionPredecessor, SessionTurn, } from "#context/accessors.js";
+export type { SessionAuth, SessionAuthContext, SessionParent, SessionPredecessor, SessionTurn, } from "#context/accessors.js";
 export { defineState, type StateHandle } from "#public/definitions/state.js";
-export type { SessionContext } from "#public/definitions/callback-context.js";
+export type { SessionContext, SessionInfo, SessionSchedule } from "#context/session-context.js";
+export type { HistoryMessage } from "#shared/history-message.js";

package/dist/src/public/definitions/agent.d.ts

@@ -1,9 +1,9 @@
-import type { AgentBuildDefinition, PublicAgentDefinition, PublicAgentStaticModelDefinition } from "#shared/agent-definition.js";
+import type { PublicAgentDefinition, PublicAgentStaticModelDefinition } from "#shared/agent-definition.js";
 import type { ExactDefinition } from "#public/definitions/exact.js";
 import type { RemoteAgentDefinition } from "#public/definitions/remote-agent.js";
-import type { DynamicEvents, DynamicSentinel } from "#dynamic/definition.js";
+import { defineDynamic as defineDynamicBase } from "#dynamic/definition.js";
 declare const DEFINED_AGENT: unique symbol;
-export type { AgentModelResolveContext, AgentModelOptionsDefinition, AgentModelResolver, AgentReasoningDefinition, AgentBuildDefinition, PublicAgentDynamicModelDefinition as AgentDynamicModelDefinition, PublicAgentDynamicModelResult as AgentDynamicModelResult, AgentExperimentalDefinition, AgentLimitsDefinition, SessionUsageLimit, PublicAgentModelSelectionDefinition as AgentModelSelectionDefinition, AgentWorkflowDefinition, AgentWorkflowRetentionDefinition, AgentWorkflowWorldDefinition, PublicAgentModelDefinition as AgentModelDefinition, PublicAgentStaticModelDefinition as AgentStaticModelDefinition, PublicAgentCompactionDefinition as AgentCompactionDefinition, } from "#shared/agent-definition.js";
+export type { AgentModelOptionsDefinition, AgentReasoningDefinition, AgentBuildDefinition, AgentExperimentalDefinition, AgentLimitsDefinition, SessionUsageLimit, PublicAgentModelSelectionDefinition as AgentModelSelectionDefinition, AgentWorkflowDefinition, AgentWorkflowRetentionDefinition, AgentWorkflowWorldDefinition, PublicAgentModelDefinition as AgentModelDefinition, PublicAgentStaticModelDefinition as AgentStaticModelDefinition, PublicAgentCompactionDefinition as AgentCompactionDefinition, } from "#shared/agent-definition.js";
 /**
  * Additive public agent configuration authored in `agent.ts`.
  *
@@ -30,23 +30,23 @@ export type DynamicLocalSubagentDefinition = Extract<AgentDefinition, {
 };
 /** Definition a dynamic subagent resolver may select at runtime. */
 export type DynamicSubagentDefinition = DynamicLocalSubagentDefinition | RemoteAgentDefinition;
-type DynamicEventHandler<TEvents extends DynamicEvents> = Extract<NonNullable<TEvents[keyof TEvents]>, (...args: never[]) => unknown>;
-type DynamicEventResult<TEvents extends DynamicEvents> = Awaited<ReturnType<DynamicEventHandler<TEvents>>>;
-type DynamicSubagentDescriptionConstraint<TEvents extends DynamicEvents> = Exclude<Extract<DynamicEventResult<TEvents>, DefinedAgent>, DynamicLocalSubagentDefinition> extends never ? unknown : {
-    readonly "Dynamic subagent definitions require a description": never;
-};
-interface DefineDynamicAgent {
-    <const TEvents extends DynamicEvents>(definition: {
-        readonly build?: AgentBuildDefinition;
-        readonly events: TEvents;
-    } & DynamicSubagentDescriptionConstraint<TEvents>): DynamicSentinel<DynamicEventResult<TEvents>>;
-}
+/** What a dynamic subagent resolves to: the subagent, or `null` to omit it. */
+export type DynamicSubagentResult = DynamicSubagentDefinition | null;
 /**
- * Defines dynamic agent configuration. A returned subagent requires a
- * description so its parent knows when to delegate. Use `build` for static
- * packaging controls that must apply before the runtime resolver runs.
+ * Defines a value that depends on the session; see `defineDynamic` from `eve/tools` and the other
+ * folders' entry points. In `agent.ts` it makes the `model` field dynamic, and its function can't
+ * read `ctx.model`. In `subagents/<name>/agent.ts` it makes the whole subagent dynamic: its
+ * function returns `defineAgent({ description, model })`, a remote agent, or `null` to omit it.
+ *
+ * ```ts
+ * export default defineDynamic((ctx) =>
+ *   ctx.session.auth.current?.attributes.plan === "enterprise"
+ *     ? defineAgent({ description: "Analyze financial data.", model: ctx.model.id })
+ *     : null,
+ * );
+ * ```
  */
-export declare const defineDynamic: DefineDynamicAgent;
+export declare const defineDynamic: typeof defineDynamicBase;
 /**
  * Defines the agent configuration authored in `agent.ts` and returns it
  * unchanged, preserving its literal type.

package/dist/src/public/definitions/agent.js

@@ -1 +1 @@
-import{defineDynamic as defineDynamic$1}from"#dynamic/definition.js";const defineDynamic=(e=>{let t=defineDynamic$1({events:e.events});return e.build===void 0?t:{...t,build:e.build}});function defineAgent(e){return e}export{defineAgent,defineDynamic};
+import{defineDynamic as defineDynamic$1}from"#dynamic/definition.js";const defineDynamic=defineDynamic$1;function defineAgent(e){return e}export{defineAgent,defineDynamic};

package/dist/src/public/definitions/approval.d.ts

@@ -1,2 +1,2 @@
-export type { Approval, ApprovalConfiguration, ApprovalContext, ApprovalPolicy, ApprovalPrompt, ApprovalPromptContext, ApprovalRequest, ApprovalResponse, ApprovalResponseAuth, ApprovalResponseContext, ApprovalResponseDecision, ApprovalResponsePolicy, ApprovalResponseSession, ApprovalStatus, ConnectionToolAnnotations, ToolApproval, ToolApprovalConfiguration, } from "#approval/definition.js";
+export type { Approval, ApprovalConfiguration, ApprovalContext, ApprovalPolicy, ApprovalPrompt, ApprovalPromptContext, ApprovalRequest, ApprovalResponse, ApprovalResponseAuth, ApprovalResponseContext, ApprovalResponseDecision, ApprovalResponsePolicy, ApprovalResponseSession, ApprovalStatus, ConnectionToolAnnotations, } from "#approval/definition.js";
 export { resolveApprovalPolicy } from "#approval/definition.js";

package/dist/src/public/definitions/channel.d.ts

@@ -1,18 +1,28 @@
+import { type AuthoringEventType } from "#protocol/session-events/authoring.js";
+import type { SessionEvent } from "#protocol/session-event.js";
+import type { CommittedLine } from "#channel/adapter.js";
+export type { CommittedLine } from "#channel/adapter.js";
+export type { ChannelDelivery } from "#shared/channel-delivery.js";
 import { type ChannelReference } from "#channel/compiled-channel.js";
 import { type ChannelCorsOptions } from "#channel/cors.js";
 import type { ChannelCreateOptions, ChannelCreateResult, ChannelFrom, ChannelReceiveContext, ChannelResolveSession, ChannelRespondOptions, ChannelSendOptions, ChannelSource } from "#channel/channel-operations.js";
 import type { RouteDefinition } from "#channel/routes.js";
-import type { Session } from "#channel/session.js";
+import type { ChannelContinuationOps } from "#shared/channel-context.js";
+export type { ChannelContext, ChannelContinuationOps } from "#shared/channel-context.js";
+import type { Delivery } from "#shared/delivery.js";
+export type { Delivery, DeliveryResult } from "#shared/delivery.js";
+export { SessionNotActiveError } from "#channel/session-not-active-error.js";
 import type { TurnPolicy } from "#channel/types.js";
-import type { UnstampedMessageStreamEvent } from "#protocol/message.js";
 import type { SessionContext } from "#public/definitions/callback-context.js";
+import type { FactPosition } from "#protocol/session-events/envelope.js";
+import { type SessionView } from "#protocol/session-projection/session-view.js";
 import type { GenericChannelDefinition, GenericReceiveInput } from "#shared/channel-definition.js";
 declare const CHANNEL_METADATA_TYPE: unique symbol;
-export type { CancelTurnResult, ClearSessionResult, CompactSessionResult, GetEventStreamOptions, ResetSessionResult, SessionCallback, TurnPolicy, } from "#channel/types.js";
+export type { CancelTurnResult, ClearSessionResult, CompactSessionResult, ResetSessionResult, SessionCallback, TurnPolicy, } from "#channel/types.js";
 export { SessionStrandedError } from "#channel/session-stranded-error.js";
-export type { Session, SessionHandle } from "#channel/session.js";
+export type { Session } from "#channel/session.js";
 export type { ChannelAudience } from "#shared/channel-audience.js";
-export type { AudienceCaller, AudienceContext, AudienceInput, AudiencePrincipal, ConversationEnvironment, } from "#shared/conversation-context.js";
+export type { AudienceCaller, AudienceContext, ConversationEnvironment, } from "#shared/conversation-context.js";
 export type { SessionRespondOptions, SessionSendOptions } from "#channel/session.js";
 export type { ChannelCreateOptions, ChannelCreateResult, ChannelFrom, ChannelReceiveContext, ChannelResolveSession, ChannelRespondOptions, ChannelSendOptions, ChannelSource, };
 export type { ChannelCors, ChannelCorsOptions } from "#channel/cors.js";
@@ -90,61 +100,48 @@ export declare function disableRoute(): DisabledRouteSentinel;
  * produced by {@link disableRoute}.
  */
 export declare function isDisabledRouteSentinel(value: unknown): value is DisabledRouteSentinel;
-type EventData<T extends UnstampedMessageStreamEvent["type"]> = Extract<UnstampedMessageStreamEvent, {
+/** The session event a handler keyed `T` observes. */
+export type ChannelEventOf<T extends SessionEvent["type"]> = Extract<SessionEvent, {
     type: T;
-}> extends {
-    data: infer D;
-} ? D : undefined;
-/** Continuation routing on the `channel` argument of every channel event handler. */
-export interface ChannelContinuationOps {
-    readonly continuation?: {
-        readonly token: string;
-        alias(token: string): void;
-    };
-}
+}>;
+/** Continuation routing on the `ctx.channel` of every channel event handler. */
 /**
- * Channel context passed to event handlers: `TCtx` intersected with
- * {@link ChannelContinuationOps}.
- */
-type ChannelContext<TCtx> = TCtx & ChannelContinuationOps;
-type ChannelEventHandler<T extends UnstampedMessageStreamEvent["type"], TCtx> = (data: EventData<T>, channel: ChannelContext<TCtx>, ctx: SessionContext) => void | Promise<void>;
-type ChannelSessionFailedHandler<TCtx> = (data: EventData<"session.failed">, channel: ChannelContext<TCtx>) => void | Promise<void>;
-/**
- * Optional handlers keyed by session lifecycle event name. Each handler receives
- * the event `data`, the {@link ChannelContext}, and a {@link SessionContext}
- * `ctx`. The `session.failed` handler is the exception: it receives only `data`
- * and the channel context, with no `ctx`; its data includes `sessionId`.
- */
-export interface ChannelEvents<TCtx = void> {
-    readonly "approval.candidate"?: ChannelEventHandler<"approval.candidate", TCtx>;
-    readonly "approval.settled"?: ChannelEventHandler<"approval.settled", TCtx>;
-    readonly "context.cleared"?: ChannelEventHandler<"context.cleared", TCtx>;
-    readonly "compaction.requested"?: ChannelEventHandler<"compaction.requested", TCtx>;
-    readonly "compaction.completed"?: ChannelEventHandler<"compaction.completed", TCtx>;
-    readonly "turn.started"?: ChannelEventHandler<"turn.started", TCtx>;
-    readonly "actions.requested"?: ChannelEventHandler<"actions.requested", TCtx>;
-    readonly "action.partial"?: ChannelEventHandler<"action.partial", TCtx>;
-    readonly "action.result"?: ChannelEventHandler<"action.result", TCtx>;
-    readonly "message.completed"?: ChannelEventHandler<"message.completed", TCtx>;
-    readonly "message.appended"?: ChannelEventHandler<"message.appended", TCtx>;
-    readonly "reasoning.appended"?: ChannelEventHandler<"reasoning.appended", TCtx>;
-    readonly "reasoning.completed"?: ChannelEventHandler<"reasoning.completed", TCtx>;
-    readonly "step.started"?: ChannelEventHandler<"step.started", TCtx>;
-    readonly "step.completed"?: ChannelEventHandler<"step.completed", TCtx>;
-    readonly "input.requested"?: ChannelEventHandler<"input.requested", TCtx>;
-    readonly "input.resolved"?: ChannelEventHandler<"input.resolved", TCtx>;
-    readonly "task.started"?: ChannelEventHandler<"task.started", TCtx>;
-    readonly "task.settled"?: ChannelEventHandler<"task.settled", TCtx>;
-    readonly "turn.waiting"?: ChannelEventHandler<"turn.waiting", TCtx>;
-    readonly "turn.failed"?: ChannelEventHandler<"turn.failed", TCtx>;
-    readonly "turn.completed"?: ChannelEventHandler<"turn.completed", TCtx>;
-    readonly "turn.cancelled"?: ChannelEventHandler<"turn.cancelled", TCtx>;
-    readonly "session.failed"?: ChannelSessionFailedHandler<TCtx>;
-    readonly "session.completed"?: ChannelEventHandler<"session.completed", TCtx>;
-    readonly "session.waiting"?: ChannelEventHandler<"session.waiting", TCtx>;
-    readonly "authorization.required"?: ChannelEventHandler<"authorization.required", TCtx>;
-    readonly "authorization.completed"?: ChannelEventHandler<"authorization.completed", TCtx>;
+ * What a channel event handler knows beyond the event it observes: the channel's own context,
+ * where the event sits on the stream, and the session's tables. Observer-only, so tools never see
+ * it.
+ */
+export interface ChannelEventContext<TChannel = ChannelContinuationOps> extends SessionContext {
+    /** The channel's context, as its `context()` built it, with continuation routing. */
+    readonly channel: TChannel;
+    /** The position of the event's line, and its index in that line. */
+    readonly position: FactPosition;
+    /** Immutable observation snapshot of the whole commit the event is in. */
+    readonly view: SessionView;
 }
+/**
+ * Handles one session event: the fact or progress record, with its `type`, `data`, and `scope`,
+ * and the {@link ChannelEventContext}. Hooks receive the same event.
+ */
+export type ChannelEventHandler<T extends SessionEvent["type"], TCtx = void> = (event: ChannelEventOf<T>, ctx: ChannelEventContext<TCtx & ChannelContinuationOps>) => void | Promise<void>;
+/**
+ * Handles one committed line, once its events' handlers ran: the facts the channel heard, and the
+ * {@link ChannelEventContext} with the session's tables as of the line. For what a channel keeps
+ * in step with the tables, such as a status, a card, or the prompts still open, so it renders
+ * once per change rather than once per event.
+ */
+export type ChannelCommitHandler<TCtx = void> = (line: CommittedLine, ctx: ChannelEventContext<TCtx & ChannelContinuationOps>) => void | Promise<void>;
+/**
+ * Optional handlers keyed by session event type: the session's facts and the progress records a
+ * channel streams (`content.delta`, `call.input`, `call.progress`). Each handler receives the
+ * event and a {@link ChannelEventContext} whose `channel` is the channel's own context. Handlers
+ * run after the event is written, so they observe it and never shape it. `committed` runs once
+ * per committed line, after them.
+ */
+export type ChannelEvents<TCtx = void> = {
+    readonly [T in AuthoringEventType]?: ChannelEventHandler<T, TCtx>;
+} & {
+    readonly committed?: ChannelCommitHandler<TCtx>;
+};
 /**
  * Input passed to a channel's `receive` callback when another channel or
  * schedule proactively routes a message to it.
@@ -152,8 +149,8 @@ export interface ChannelEvents<TCtx = void> {
 export type ReceiveInput<TReceiveTarget = Record<string, unknown>> = GenericReceiveInput<TReceiveTarget>;
 /**
  * The object passed to {@link defineChannel}. `routes` is required; `state`
- * seeds durable adapter state, `context` builds the per-step `channel` argument
- * for `events` and `deliver`, `events` handle session lifecycle, `receive`
+ * seeds durable adapter state, `context` builds the per-step channel context
+ * for `events` (as `ctx.channel`) and `deliver`, `events` handle session lifecycle, `receive`
  * accepts cross-channel handoffs, `fetchFile` stages remote file URLs, and
  * `metadata` projects observability data.
  *
@@ -173,7 +170,7 @@ export interface Channel<TState = undefined, TReceiveTarget = Record<string, unk
     readonly [CHANNEL_METADATA_TYPE]?: TMetadata;
     readonly routes: readonly RouteDefinition<TState>[];
     readonly cors?: ChannelCorsOptions;
-    readonly receive?: (input: ReceiveInput<TReceiveTarget>, ctx: ChannelReceiveContext<TState>) => Promise<Session>;
+    readonly receive?: (input: ReceiveInput<TReceiveTarget>, ctx: ChannelReceiveContext<TState>) => Promise<Delivery>;
     readonly turnPolicy?: TurnPolicy;
 }
 /**

package/dist/src/public/definitions/channel.js

@@ -1 +1 @@
-import{SessionStrandedError}from"#channel/session-stranded-error.js";import{createMetadataAudienceProjector}from"#channel/audience.js";import{CHANNEL_SENTINEL}from"#channel/compiled-channel.js";import{defaultDeliverResult}from"#channel/adapter.js";import{buildCallbackContext}from"#context/build-callback-context.js";import{mergeUploadPolicy}from"#public/channels/upload-policy.js";import{DELETE,GET,HEAD,OPTIONS,PATCH,POST,PUT,WS}from"#channel/routes.js";import{normalizeChannelCors}from"#channel/cors.js";import{HTTP_ADAPTER_KIND}from"#channel/http.js";const DISABLED_ROUTE_SENTINEL_KIND=`eve:disabled-channel`;function disableRoute(){return{kind:DISABLED_ROUTE_SENTINEL_KIND}}function isDisabledRouteSentinel(e){return typeof e==`object`&&!!e&&e.kind===DISABLED_ROUTE_SENTINEL_KIND}function defineChannel(e){let t=buildAdapter(e),n=normalizeChannelCors(e.cors);return{__kind:CHANNEL_SENTINEL,routes:e.routes,adapter:t,cors:n,receive:e.receive,turnPolicy:e.turnPolicy}}const eventTypes=Object.keys({"approval.candidate":null,"approval.settled":null,"context.cleared":null,"compaction.requested":null,"compaction.completed":null,"turn.started":null,"actions.requested":null,"action.partial":null,"action.result":null,"message.completed":null,"message.appended":null,"reasoning.appended":null,"reasoning.completed":null,"step.started":null,"step.completed":null,"input.requested":null,"input.resolved":null,"task.started":null,"task.settled":null,"turn.waiting":null,"turn.failed":null,"turn.completed":null,"turn.cancelled":null,"session.failed":null,"session.completed":null,"session.waiting":null,"authorization.required":null,"authorization.completed":null});function buildAdapter(e){let t=e.state!=null,n=e.context!=null,r=e.fetchFile!==void 0,i=e.metadata,a=i!==void 0,o=e.audience,s=e.uploadPolicy===void 0?void 0:mergeUploadPolicy(e.uploadPolicy),c=t||n||a||s!==void 0,l={},u=!1,d={kind:e.kindHint??`defineChannel`},f=e.events;for(let e of eventTypes){let t=f?.[e];t&&(u=!0,l[e]=(n,r)=>{let{session:i,...a}=r,o={...a,continuation:i?.continuation===void 0?void 0:{token:i.continuation.token,alias:e=>i.continuation?.alias(e)}};if(e===`session.failed`)return t(n,o);let s=buildCallbackContext();return t(n,o,s)})}return!c&&!u&&!r?{kind:e.kindHint??HTTP_ADAPTER_KIND,...o===void 0?void 0:{instrumentation:{audience:o}}}:{kind:e.kindHint??`defineChannel`,state:t?{...e.state}:{},fetchFile:e.fetchFile,uploadPolicy:s,instrumentation:i===void 0&&o===void 0?void 0:{...i===void 0?void 0:{metadata(e){let{audience:t,...n}=i(e);return n}},...o===void 0?i===void 0?void 0:{audience:createMetadataAudienceProjector(d,i)}:{audience:o}},createAdapterContext(t){let r=t.state,i=t.session;return{...n?e.context(r,i):{},state:r,ctx:t.ctx,session:i}},deliver(t,n){return e.deliver===void 0?defaultDeliverResult(t):e.deliver(t,n)},...l}}export{DELETE,GET,HEAD,OPTIONS,PATCH,POST,PUT,SessionStrandedError,WS,defineChannel,disableRoute,isDisabledRouteSentinel};
+import{attachClientContext,readClientContext}from"#internal/client-context.js";import{attachInputText,readInputText}from"#internal/input-text.js";import{SessionNotActiveError}from"#channel/session-not-active-error.js";import{SessionStrandedError}from"#channel/session-stranded-error.js";import{CHANNEL_SENTINEL}from"#channel/compiled-channel.js";import{defaultDeliverResult}from"#channel/adapter.js";import{snapshotOf}from"#protocol/session-projection/session-view.js";import{buildCallbackContext}from"#context/build-callback-context.js";import{currentView}from"#harness/session-machine/current.js";import{mergeUploadPolicy}from"#public/channels/upload-policy.js";import{DELETE,GET,HEAD,OPTIONS,PATCH,POST,PUT,WS}from"#channel/routes.js";import{removedEventKeyMessage}from"#public/definitions/removed-event-keys.js";import{authoringEventTypes}from"#protocol/session-events/authoring.js";import{normalizeChannelCors}from"#channel/cors.js";import{HTTP_ADAPTER_KIND}from"#channel/http.js";const DISABLED_ROUTE_SENTINEL_KIND=`eve:disabled-channel`;function disableRoute(){return{kind:DISABLED_ROUTE_SENTINEL_KIND}}function isDisabledRouteSentinel(e){return typeof e==`object`&&!!e&&e.kind===DISABLED_ROUTE_SENTINEL_KIND}function defineChannel(e){let t=buildAdapter(e),n=normalizeChannelCors(e.cors);return{__kind:CHANNEL_SENTINEL,routes:e.routes,adapter:t,cors:n,receive:e.receive,turnPolicy:e.turnPolicy}}const eventTypes=[...authoringEventTypes,`committed`];function buildAdapter(e){let t=e.state!=null,n=e.context!=null,r=e.fetchFile!==void 0,i=e.metadata,a=i!==void 0,o=e.audience,s=e.uploadPolicy===void 0?void 0:mergeUploadPolicy(e.uploadPolicy),c=t||n||a||s!==void 0||e.deliver!==void 0,l={},u=!1,d=e.events;for(let e of Object.keys(d??{})){let t=removedEventKeyMessage(e);if(t!==void 0)throw Error(`A channel handles ${t}`)}for(let e of eventTypes){let t=d?.[e];t&&(u=!0,l[e]=(e,n)=>{let{session:r,continuation:i,position:a,scope:o,view:s,...c}=n,l={...c,get continuation(){return n.continuation}},u={...buildCallbackContext(),channel:l,position:a??{index:0,line:0},view:snapshotOf(s??currentView())};return t(e,u)})}return!c&&!u&&!r?{kind:HTTP_ADAPTER_KIND,...o===void 0?void 0:{instrumentation:{audience:o}}}:{kind:`defineChannel`,state:t?{...e.state}:{},fetchFile:e.fetchFile,uploadPolicy:s,instrumentation:i===void 0&&o===void 0?void 0:{...i===void 0?void 0:{metadata(e){let{audience:t,...n}=i(e);return n}},...o===void 0?void 0:{audience:o}},createAdapterContext(t){let r=t.state,i={session:t.session,get continuation(){return t.continuation}};return{...n?e.context(r,i):{},state:r,ctx:t.ctx,session:i.session,get continuation(){return i.continuation}}},async deliver(t,n){let r=await e.deliver?.(t,n),i=defaultDeliverResult(r??t);if(i!==void 0)return attachClientContext(attachInputText(i,readInputText(t)),readClientContext(t))},...l}}export{DELETE,GET,HEAD,OPTIONS,PATCH,POST,PUT,SessionNotActiveError,SessionStrandedError,WS,defineChannel,disableRoute,isDisabledRouteSentinel};

package/dist/src/public/definitions/connections/dynamic.d.ts

@@ -1,23 +1,11 @@
 import type { McpClientConnectionDefinition } from "#public/definitions/connections/mcp.js";
 import type { OpenAPIConnectionDefinition } from "#public/definitions/connections/openapi.js";
-import { type DynamicResolveContext, type DynamicSentinel } from "#dynamic/definition.js";
-import type { ExactDefinition } from "#public/definitions/exact.js";
+import { type DefineDynamic } from "#dynamic/definition.js";
 /** One connection returned by a dynamic connection resolver. */
 export type DynamicConnectionDefinition = McpClientConnectionDefinition | OpenAPIConnectionDefinition;
 /** A runtime connection set whose keys become connection names. */
 export type DynamicConnectionSet = Readonly<Record<string, DynamicConnectionDefinition>>;
 /** Supported return value for a dynamic connection resolver. */
 export type DynamicConnectionResult = DynamicConnectionDefinition | DynamicConnectionSet | null;
-/** Trusted session identity and minimal channel metadata available to connection resolvers. */
-export interface DynamicConnectionResolveContext {
-    readonly session: DynamicResolveContext["session"];
-    readonly channel: Pick<DynamicResolveContext["channel"], "kind">;
-}
-/** Session and turn handlers supported by dynamic connections. */
-export type DynamicConnectionEvents = {
-    readonly [K in "session.started" | "turn.started"]?: (event: unknown, ctx: DynamicConnectionResolveContext) => DynamicConnectionResult | Promise<DynamicConnectionResult>;
-};
-/** Defines a runtime connection resolver for session and turn boundaries. */
-export declare function defineDynamic<const TEvents extends DynamicConnectionEvents>(definition: {
-    readonly events: ExactDefinition<TEvents, DynamicConnectionEvents>;
-}): DynamicSentinel<DynamicConnectionResult>;
+/** `defineDynamic()` for `agent/connections/`: one connection named after the file, or a map. */
+export declare const defineDynamic: DefineDynamic<DynamicConnectionResult>;

package/dist/src/public/definitions/connections/dynamic.js

@@ -1 +1 @@
-import{DYNAMIC_SENTINEL_KIND}from"#dynamic/definition.js";import{stampDefinitionKey}from"#internal/authored-definition/source-identity.js";function defineDynamic(e){let t={kind:DYNAMIC_SENTINEL_KIND,events:e.events};return stampDefinitionKey(t,`dynamic-connections:${Object.keys(e.events).join(`,`)}`),t}export{defineDynamic};
+import{defineDynamic as defineDynamic$1}from"#dynamic/definition.js";const defineDynamic=defineDynamic$1;export{defineDynamic};

package/dist/src/public/definitions/connections/events.d.ts

@@ -1,20 +1,20 @@
 import type { Session } from "#channel/session.js";
 import type { SessionAuthContext } from "#channel/types.js";
 /** Framework-owned origin captured when the authorized caller subscribes. */
-export interface Experimental_ConnectionEventOrigin {
+export interface ConnectionEventOrigin {
     readonly sessionId: string;
     readonly connectionName: string;
     readonly subscriptionId: string;
 }
-export interface Experimental_ConnectionEventContext {
-    readonly origin: Experimental_ConnectionEventOrigin;
+export interface ConnectionEventContext {
+    readonly origin: ConnectionEventOrigin;
     readonly deliveryId: string;
     /** The subscription creator's authenticated session identity. */
     readonly auth: SessionAuthContext | null;
     /** Attaches to an existing session; never creates a replacement session. */
     readonly attachSession: (sessionId: string) => Session;
 }
-export interface Experimental_ConnectionEvent {
+export interface ConnectionEvent {
     readonly eventId: string;
     readonly name: string;
     readonly timestamp: string;
@@ -22,18 +22,18 @@ export interface Experimental_ConnectionEvent {
     readonly cursor: string | null;
 }
 /** Opts a static Connect-backed MCP connection into managed webhook events. */
-export interface Experimental_ConnectionEvents {
+export interface ConnectionEvents {
     /** Called durably after verification and subscription binding checks. */
-    readonly onEvent: (input: Experimental_ConnectionEventContext & {
-        readonly event: Experimental_ConnectionEvent;
+    readonly onEvent: (input: ConnectionEventContext & {
+        readonly event: ConnectionEvent;
     }) => void | PromiseLike<void>;
     /** The upstream server could not deliver a contiguous event stream. */
-    readonly onGap?: (input: Experimental_ConnectionEventContext & {
+    readonly onGap?: (input: ConnectionEventContext & {
         readonly cursor: string | null;
         readonly truncated?: true;
     }) => void | PromiseLike<void>;
     /** The upstream subscription ended; no model turn starts automatically. */
-    readonly onTerminated?: (input: Experimental_ConnectionEventContext & {
+    readonly onTerminated?: (input: ConnectionEventContext & {
         readonly error: {
             readonly code: number;
             readonly message: string;

package/dist/src/public/definitions/connections/mcp.d.ts

@@ -1,4 +1,4 @@
-import type { Experimental_ConnectionEvents } from "#public/definitions/connections/events.js";
+import type { ConnectionEvents } from "#public/definitions/connections/events.js";
 import type { ConnectionAuthDefinition, HeadersDefinition, ToolFilterDefinition } from "#shared/connection-types.js";
 import type { ConnectionToolCallDefinition } from "#public/definitions/connections/tool-call.js";
 import type { Approval } from "#public/definitions/approval.js";
@@ -16,7 +16,9 @@ import type { Approval } from "#public/definitions/approval.js";
  */
 export interface McpClientConnectionDefinition {
     /** Opt-in Connect webhook callbacks. Enabling this does not subscribe. */
-    readonly experimental_events?: Experimental_ConnectionEvents;
+    readonly experimental?: {
+        readonly events?: ConnectionEvents;
+    };
     /**
      * The MCP server's HTTP endpoint URL.
      *
@@ -53,7 +55,7 @@ export interface McpClientConnectionDefinition {
      *
      * - `getToken`-only: covers static API keys, pre-provisioned
      *   JWTs, and out-of-band OAuth. Defaults to
-     *   `credentialOwner: "app"` when omitted.
+     *   `principalType: "app"` when omitted.
      * - Three-method form: provide `startAuthorization` and
      *   `completeAuthorization` together to opt into
      *   interactive OAuth authorization.

package/dist/src/public/definitions/connections/openapi.d.ts

@@ -55,7 +55,7 @@ export interface OpenAPIConnectionDefinition {
      * `Authorization: Bearer <token>`.
      *
      * - `getToken`-only: covers static API keys, pre-provisioned tokens,
-     *   and out-of-band OAuth. Defaults to `credentialOwner: "app"` when
+     *   and out-of-band OAuth. Defaults to `principalType: "app"` when
      *   omitted.
      * - Three-method form: provide `startAuthorization` and
      *   `completeAuthorization` together to opt into interactive OAuth.

package/dist/src/public/definitions/extension.d.ts

@@ -56,13 +56,11 @@ export interface NoConfigExtensionHandle {
  * const { apiKey } = extension.config;
  * ```
  *
- * The second argument is retained for source compatibility with compiled extension
- * declarations; instance bindings come from the loaded module graph, not its value.
  */
 export declare function defineExtension<const S extends StandardSchemaV1>(options: {
     readonly config: S;
-}, namespace?: string): ExtensionHandle<S>;
+}): ExtensionHandle<S>;
 export declare function defineExtension(options?: {
     readonly config?: undefined;
-}, namespace?: string): NoConfigExtensionHandle;
+}): NoConfigExtensionHandle;
 export {};

package/dist/src/public/definitions/extension.js

@@ -1 +1 @@
-const MOUNTED_EXTENSION=Symbol.for(`eve.mounted-extension`);function validateConfig(e,t){if(e===void 0)return{};let n=e[`~standard`].validate(t??{});if(n instanceof Promise)throw Error(`Extension config must validate synchronously; the config schema uses async validation, which is not supported at mount.`);if(n.issues!==void 0){let e=n.issues.map(e=>{let t=e.path?.map(e=>String(typeof e==`object`?e.key:e)).join(`.`);return t!==void 0&&t.length>0?`${t}: ${e.message}`:e.message}).join(`; `);throw Error(`Invalid extension config: ${e}`)}return n.value}function defineExtension(e,t){let n=e?.config,r,handle=(e=>(r=validateConfig(n,e),{[MOUNTED_EXTENSION]:!0}));return Object.defineProperty(handle,"schema",{value:n,enumerable:!0}),Object.defineProperty(handle,"config",{enumerable:!0,get(){return r??validateConfig(n,{})}}),handle}export{defineExtension};
+const MOUNTED_EXTENSION=Symbol.for(`eve.mounted-extension`);function validateConfig(e,t){if(e===void 0)return{};let n=e[`~standard`].validate(t??{});if(n instanceof Promise)throw Error(`Extension config must validate synchronously; the config schema uses async validation, which is not supported at mount.`);if(n.issues!==void 0){let e=n.issues.map(e=>{let t=e.path?.map(e=>String(typeof e==`object`?e.key:e)).join(`.`);return t!==void 0&&t.length>0?`${t}: ${e.message}`:e.message}).join(`; `);throw Error(`Invalid extension config: ${e}`)}return n.value}function defineExtension(e){let t=e?.config,n,handle=(e=>(n=validateConfig(t,e),{[MOUNTED_EXTENSION]:!0}));return Object.defineProperty(handle,"schema",{value:t,enumerable:!0}),Object.defineProperty(handle,"config",{enumerable:!0,get(){return n??validateConfig(t,{})}}),handle}export{defineExtension};

package/dist/src/public/definitions/hook.d.ts

@@ -1,53 +1,22 @@
-import type { HandleMessageStreamEvent } from "../../protocol/message.js";
+import type { AuthoringEventType } from "#protocol/session-events/authoring.js";
+import type { SessionEvent } from "../../protocol/session-event.js";
+import type { FactPosition } from "../../protocol/session-events/envelope.js";
+import type { Memo, Occurrence, SessionFrame } from "../../dynamic/definition.js";
 import type { SessionContext } from "./callback-context.js";
 import type { ExactDefinition } from "./exact.js";
-type ProtocolEvent<TType extends HandleMessageStreamEvent["type"]> = Extract<HandleMessageStreamEvent, {
+type ProtocolEvent<TType extends SessionEvent["type"]> = Extract<SessionEvent, {
     type: TType;
 }>;
 /**
- * Public event contract available to authored hooks.
+ * Public event contract available to authored hooks: the session's facts, the progress records
+ * a hook names explicitly, and the work events not yet moved to facts.
  *
- * The explicit map keeps hook compatibility independent from the internal
- * protocol union: new protocol events do not become extension hook events
- * until eve exposes them here.
+ * The explicit map keeps hook compatibility independent from the internal protocol union: new
+ * protocol events do not become extension hook events until eve exposes them here.
  */
-export interface HookEventMap {
-    readonly "action.input.appended": ProtocolEvent<"action.input.appended">;
-    readonly "action.partial": ProtocolEvent<"action.partial">;
-    readonly "action.result": ProtocolEvent<"action.result">;
-    readonly "approval.candidate": ProtocolEvent<"approval.candidate">;
-    readonly "approval.settled": ProtocolEvent<"approval.settled">;
-    readonly "actions.requested": ProtocolEvent<"actions.requested">;
-    readonly "agent.started": ProtocolEvent<"agent.started">;
-    readonly "authorization.completed": ProtocolEvent<"authorization.completed">;
-    readonly "authorization.required": ProtocolEvent<"authorization.required">;
-    readonly "compaction.completed": ProtocolEvent<"compaction.completed">;
-    readonly "compaction.requested": ProtocolEvent<"compaction.requested">;
-    readonly "context.cleared": ProtocolEvent<"context.cleared">;
-    readonly "history.imported": ProtocolEvent<"history.imported">;
-    readonly "input.requested": ProtocolEvent<"input.requested">;
-    readonly "input.resolved": ProtocolEvent<"input.resolved">;
-    readonly "message.appended": ProtocolEvent<"message.appended">;
-    readonly "message.completed": ProtocolEvent<"message.completed">;
-    readonly "message.received": ProtocolEvent<"message.received">;
-    readonly "reasoning.appended": ProtocolEvent<"reasoning.appended">;
-    readonly "reasoning.completed": ProtocolEvent<"reasoning.completed">;
-    readonly "result.completed": ProtocolEvent<"result.completed">;
-    readonly "session.completed": ProtocolEvent<"session.completed">;
-    readonly "session.failed": ProtocolEvent<"session.failed">;
-    readonly "session.started": ProtocolEvent<"session.started">;
-    readonly "session.waiting": ProtocolEvent<"session.waiting">;
-    readonly "step.completed": ProtocolEvent<"step.completed">;
-    readonly "step.failed": ProtocolEvent<"step.failed">;
-    readonly "step.started": ProtocolEvent<"step.started">;
-    readonly "task.settled": ProtocolEvent<"task.settled">;
-    readonly "task.started": ProtocolEvent<"task.started">;
-    readonly "turn.cancelled": ProtocolEvent<"turn.cancelled">;
-    readonly "turn.completed": ProtocolEvent<"turn.completed">;
-    readonly "turn.failed": ProtocolEvent<"turn.failed">;
-    readonly "turn.started": ProtocolEvent<"turn.started">;
-    readonly "turn.waiting": ProtocolEvent<"turn.waiting">;
-}
+export type HookEventMap = {
+    readonly [T in AuthoringEventType]: ProtocolEvent<T>;
+};
 /** Event type discriminators available to authored hooks. */
 export type HookEventType = keyof HookEventMap;
 /** Authored hook event keys, including the wildcard subscriber. */
@@ -55,69 +24,78 @@ export type HookEventKey = HookEventType | "*";
 /** Event received by a handler for one authored hook event key. */
 export type HookEvent<TKey extends HookEventKey = HookEventType> = TKey extends HookEventType ? HookEventMap[TKey] : HookEventMap[HookEventType];
 /**
- * Every hook handler receives this context.
- *
- * Extends {@link SessionContext} with agent and channel metadata.
- * `ctx` is always the last argument.
+ * Every hook handler receives this context: the session as of the commit the event is in, the
+ * handler's occurrence, and the ways a hook acts.
  */
-export interface HookContext extends SessionContext {
+export interface HookContext extends SessionContext, Omit<SessionFrame, "session"> {
+    readonly session: SessionContext["session"] & SessionFrame["session"];
     readonly agent: {
         readonly name: string;
         readonly nodeId?: string;
     };
-    readonly channel: {
-        readonly kind?: string;
-        readonly continuationToken?: string;
-    };
     /**
-     * Cancels the running turn. The event's remaining subscribers still run,
-     * then the turn settles like `session.cancel()`: `turn.cancelled`, then
-     * `session.waiting`. Returns `void` because the turn stops after the hook
-     * returns; call it before the handler's promise settles.
-     *
-     * eve logs a warning and ignores the call when the event cannot stop a
-     * running turn (`step.failed`, turn and session terminal events,
-     * `context.cleared`, `subagent.*`, and clear or compact requests) or when
-     * it arrives after the event's hooks returned.
+     * Where the event sits on the session's stream: the position of its line, and its index in
+     * that line. Positions never change, so a hook can record how far it has handled the stream.
+     */
+    readonly position: FactPosition;
+    /**
+     * This handler's run for this fact. Its `idempotencyKey` is the fact's position in the stream,
+     * so a retried step passes the same one.
+     */
+    readonly occurrence: Occurrence;
+    /** Keeps what `fn` returns per key, as in a dynamic value; see {@link Memo}. */
+    readonly memo: Memo;
+    /**
+     * Stops the running turn before its next model call; it settles `cancelled`, like
+     * `session.cancel()`. Can also stop the turn while its input is being admitted. Acts once on
+     * the turn, so asking again is safe; between turns without an incoming turn, it does nothing.
+     * Throws after the handler has settled.
      */
-    cancel(): void;
+    cancel(reason?: string): void;
 }
 /**
- * Side-effect-only handler for one accepted runtime stream event.
- *
- * `TEvent` is one variant of {@link HookEvent}. {@link StreamEventHooks}
- * infers it from the event key. The typed event is the first argument, `ctx`
- * is the last.
+ * Handler for one accepted session event. `TEvent` is one variant of {@link HookEvent}, which
+ * {@link StreamEventHooks} infers from the event key.
  */
 export type StreamEventHook<TEvent> = (event: TEvent, ctx: HookContext) => void | Promise<void>;
 /**
- * Map of stream-event subscribers an authored hook file may declare.
- *
- * `*` matches every accepted runtime stream event and runs after the
- * typed handler for that event (if any).
+ * Map of event handlers an authored hook file may declare. `*` runs for every fact the session
+ * commits, after the typed handler for that event (if any). Progress (streamed deltas and partial
+ * results) reaches a hook only through its own key, such as `content.delta`.
  */
 export type StreamEventHooks<TKey extends HookEventKey = HookEventKey> = {
     readonly [TKey_ in TKey]?: StreamEventHook<HookEvent<TKey_>>;
 };
 /**
- * Public hook definition authored in `agent/hooks/*.ts`.
- *
- * Hook files declare stream-event subscribers (under `events:`) that
- * fire after eve has accepted and durably recorded each event.
- * Handlers are observe-only: they cannot inject model context. To
- * contribute runtime model messages, use `defineDynamic` +
- * `defineInstructions` in `agent/instructions/`.
+ * Public hook definition authored in `agent/hooks/*.ts`: a map of event handlers, each called
+ * once for each matching fact after eve has durably recorded the commit.
  */
 export interface HookDefinition<TKey extends HookEventKey = HookEventKey> {
-    readonly events?: StreamEventHooks<TKey>;
+    readonly events: StreamEventHooks<TKey>;
 }
-type DefinedHookEventKeys<TDefinition extends HookDefinition> = Extract<keyof NonNullable<TDefinition["events"]>, HookEventKey>;
+type DefinedHookEventKeys<TDefinition extends HookDefinition> = Extract<keyof TDefinition["events"], HookEventKey>;
 /**
- * Identity-with-types helper. Returns the passed definition unchanged at
- * runtime while preserving its authored event keys behind the public
- * {@link HookDefinition} boundary and rejecting any key outside `events`.
- * Authors export
- * `defineHook({ events: { "session.started": (event, ctx) => { ... } } })`.
+ * Defines a hook. Each handler runs once for each matching fact a commit carries, before the next
+ * model call. A handler can call `ctx.cancel` or an external service. Pass
+ * `ctx.occurrence.idempotencyKey` to services that support idempotency. A retry does not run
+ * handlers again for facts already published. A handler that throws during a turn fails the turn;
+ * catch optional errors.
+ *
+ * ```ts
+ * export default defineHook({
+ *   events: {
+ *     async "model.settled"(_event, ctx) {
+ *       if (spentUsd(ctx.view) <= 50) return;
+ *       ctx.cancel("Session budget exceeded.");
+ *     },
+ *   },
+ * });
+ * ```
  */
 export declare function defineHook<const T extends HookDefinition>(definition: ExactDefinition<T, HookDefinition>): HookDefinition<DefinedHookEventKeys<T>>;
+/**
+ * Throws unless `value` is a hook: an object with an `events` map and nothing else. The definer,
+ * the compiler, and the runtime loader all use it.
+ */
+export declare function assertHookForm(value: unknown, subject: string): void;
 export {};

package/dist/src/public/definitions/hook.js

@@ -1 +1 @@
-function defineHook(e){return e}export{defineHook};
+function defineHook(e){return assertHookForm(e,`defineHook()`),e}function assertHookForm(e,t){if(typeof e!=`object`||!e)throw Error(`${t} takes an object with events handlers.`);let{events:n,...r}=e,i=Object.keys(r).filter(e=>e!==`kind`);if(i.length>0)throw Error(`${t} takes only events handlers; unknown key(s): ${i.join(`, `)}. A hook acts on a condition from a handler, such as "*", with ctx.cancel.`);if(typeof n!=`object`||!n)throw Error(`${t} requires events: an object of handlers keyed by event type.`)}export{assertHookForm,defineHook};