eve 0.83.3 → 0.84.0

package/dist/src/instrumentation/lifecycle.d.ts

@@ -1,24 +1,30 @@
+import type { Cause } from "#protocol/session-events/envelope.js";
+import type { ModelOutcome } from "#protocol/session-events/families/model.js";
+import type { Capability } from "#protocol/session-events/families/call.js";
+import type { DeliverySettledData } from "#protocol/session-events/families/delivery.js";
+import type { InteractionOption, InteractionOutcome, InteractionRequest } from "#protocol/session-events/families/interaction.js";
+import type { ResponseValue } from "#protocol/session-events/families/response.js";
+import type { CallOutcome } from "#protocol/session-events/families/call.js";
+import type { SessionOutcome } from "#protocol/session-events/families/session.js";
+import type { TurnOutcome } from "#protocol/session-events/families/turn.js";
 import type * as memory from "#instrumentation/memory.js";
 import type { InstrumentationStateSlot } from "#instrumentation/state.js";
-import type { RuntimeTraceContext } from "#protocol/message.js";
+import type { TraceContext } from "#protocol/session-events/families/session.js";
 import type { ChannelAudience } from "#shared/channel-audience.js";
 import type { InstrumentationDecision } from "#shared/instrumentation-decision.js";
 import type { TraceCaptureContext, TraceCapturePolicy } from "#shared/trace-policy.js";
 /**
- * Stable eve identity for one model attempt. Retries share `stepIndex` and
- * differ by `attemptIndex`, so `step.attempt.*` fires once per attempt while
- * protocol `step.*` events and the resolver hook fire once per step.
+ * Identifies one attempt of a model run. Compaction can run outside a turn.
  */
-export interface InstrumentationAttemptScope {
+export interface InstrumentationScope {
     readonly traceSessionId?: string;
     readonly channelAudience?: ChannelAudience;
-    readonly attemptId: string;
-    readonly attemptIndex: number;
+    readonly runId: string;
+    readonly attempt: number;
     readonly functionId?: string;
-    readonly rootSessionId?: string;
+    readonly rootSessionId: string;
     readonly sessionId: string;
-    readonly stepIndex: number;
-    readonly turnId: string;
+    readonly turnId?: string;
 }
 /** The model SDK operation an attempt runs through. */
 export interface InstrumentationOperationRef {
@@ -76,35 +82,22 @@ export type InstrumentationContentPart = {
     readonly input: unknown;
     readonly toolName: string;
 };
-/**
- * How one tool call ended.
- *
- * `type` survives a provider that declined content, so whether the tool errored
- * is answerable without seeing what it returned.
- */
-export type InstrumentationToolOutput = {
-    readonly type: "result";
-    readonly output?: unknown;
-} | {
-    readonly type: "error";
-    readonly error?: unknown;
-};
 /**
  * Every event carries an `idempotencyKey` naming the operation it is about: a
  * start and its terminal share one, and two operations never collide.
  *
  * Every part is identity eve reconstructs on replay — session and turn ids,
- * `scope.attemptId` (itself `session:turn:step:attempt`), AI SDK step number,
+ * run id and retry attempt, AI SDK step number,
  * and durable runtime-action call ids. A provider writing rows can use the key
  * as its row id and be idempotent by construction.
  */
 export declare function sessionIdempotencyKey(sessionId: string): string;
 export declare function turnIdempotencyKey(sessionId: string, turnId: string): string;
-export declare function attemptIdempotencyKey(scope: InstrumentationAttemptScope): string;
+export declare function attemptIdempotencyKey(scope: InstrumentationScope): string;
 /** Identifies one provider call, including retries, within an AI SDK step. */
-export declare function modelCallIdempotencyKey(scope: InstrumentationAttemptScope, stepNumber: number, callIndex: number): string;
-export declare function toolCallIdempotencyKey(scope: InstrumentationAttemptScope, callId: string, stepNumber: number): string;
-export declare function inputIdempotencyKey(sessionId: string, turnId: string, requestId: string): string;
+export declare function modelCallIdempotencyKey(scope: InstrumentationScope, stepNumber: number, callIndex: number): string;
+export declare function toolCallIdempotencyKey(scope: InstrumentationScope, callId: string, stepNumber: number): string;
+export declare function inputIdempotencyKey(sessionId: string, turnId: string | undefined, interactionId: string): string;
 export declare function channelDeliveryIdempotencyKey(sessionId: string, deliveryId: string): string;
 export interface InstrumentationChannelDeliveryRef {
     readonly channelAudience?: ChannelAudience;
@@ -117,14 +110,15 @@ export interface InstrumentationChannelDeliveryRef {
 /** Known framework delivery input; adapter-specific fields are never projected. */
 export interface InstrumentationChannelDeliveryInput {
     readonly context?: readonly string[];
-    readonly inputResponses?: readonly InstrumentationInputResponse[];
+    readonly answers?: readonly InstrumentationAnswer[];
     readonly message?: unknown;
     readonly outputSchema?: unknown;
 }
 interface InstrumentationChannelDeliveryScope {
     readonly traceSessionId?: string;
     readonly agentName?: string;
-    readonly delivery: InstrumentationChannelDeliveryRef;
+    readonly delivery?: InstrumentationChannelDeliveryRef;
+    readonly deliveryId: string;
     readonly idempotencyKey: string;
     readonly rootSessionId: string;
     readonly sequence?: number;
@@ -132,73 +126,59 @@ interface InstrumentationChannelDeliveryScope {
     readonly traceSeed?: InstrumentationTraceSeed;
     readonly turnId?: string;
 }
-export interface InstrumentationChannelDeliveryStartedEvent extends InstrumentationChannelDeliveryScope {
-    readonly parentTraceContext?: InstrumentationTraceContext;
-    readonly type: "channel.delivery.started";
-    /** Content. Absent unless this provider's trace policy records this direction. */
+export interface InstrumentationDeliveryConsumedEvent extends InstrumentationChannelDeliveryScope {
+    readonly type: "delivery.consumed";
     readonly input?: InstrumentationChannelDeliveryInput;
 }
-export type InstrumentationChannelDeliveryOutcome = "cancelled" | "completed" | "failed";
-export interface InstrumentationChannelDeliveryTerminalEvent extends InstrumentationChannelDeliveryScope {
-    readonly type: "channel.delivery.cancelled" | "channel.delivery.completed" | "channel.delivery.failed";
-    /** Content. Absent unless this provider's trace policy records this direction. */
-    readonly error?: unknown;
-    readonly errorCode?: string;
-    readonly outcome: InstrumentationChannelDeliveryOutcome;
-}
-/** Framework-owned reason an agent suspended for user input. */
-export type InstrumentationInputKind = "question" | "session-limit" | "tool-approval";
-export interface InstrumentationInputOption {
-    readonly description?: string;
-    readonly id: string;
-    readonly label: string;
-    readonly style?: "danger" | "default" | "primary";
-}
-/** User-facing input request content projected without runtime-owned types. */
-export interface InstrumentationInputRequest {
-    readonly allowFreeform?: boolean;
-    readonly display?: "confirmation" | "select" | "text";
-    readonly options?: readonly InstrumentationInputOption[];
-    readonly prompt: string;
-}
-/** User response content projected without runtime-owned types. */
-export interface InstrumentationInputResponse {
-    readonly optionId?: string;
-    readonly text?: string;
-}
-export type InstrumentationInputOutcome = "answered" | "approved" | "cancelled" | "denied" | "failed" | "ignored" | "invalid";
-export interface InstrumentationInputRequestedEvent {
-    readonly type: "input.requested";
-    readonly action: {
+export interface InstrumentationDeliverySettledEvent extends DeliverySettledData {
+    readonly type: "delivery.settled";
+    readonly idempotencyKey: string;
+    readonly sessionId: string;
+}
+/** What a person is asked for: an approval, a question, or the budget prompt (never a sign-in). */
+export type InstrumentationInteractionKind = InteractionRequest["kind"];
+export type InstrumentationInteractionOption = InteractionOption;
+/** User-facing input request content. */
+export type InstrumentationInteractionRequest = Pick<InteractionRequest, "allowFreeform" | "display" | "options" | "prompt" | "title">;
+/** What a person answered. */
+export type InstrumentationAnswer = ResponseValue;
+/** How the request settled, as its `interaction.settled` says. */
+export type InstrumentationInteractionOutcome = InteractionOutcome;
+/** A person was asked: the session's `interaction.opened`, never a sign-in. */
+export interface InstrumentationInteractionOpenedEvent {
+    readonly type: "interaction.opened";
+    /** The call the request is about: the call an approval gates, or the call that asked. */
+    readonly call?: {
         readonly callId: string;
         readonly name: string;
     };
     readonly idempotencyKey: string;
-    readonly kind: InstrumentationInputKind;
+    readonly interactionId: string;
+    readonly kind: InstrumentationInteractionKind;
     /** Content. Absent unless this provider's trace policy records this direction. */
-    readonly request?: InstrumentationInputRequest;
-    readonly requestId: string;
-    readonly scope: InstrumentationAttemptScope;
+    readonly request?: InstrumentationInteractionRequest;
+    readonly scope: InstrumentationScope;
 }
-export interface InstrumentationInputResolvedEvent {
-    readonly type: "input.resolved";
+/** The request settled: the session's `interaction.settled`. */
+export interface InstrumentationInteractionSettledEvent {
+    readonly type: "interaction.settled";
     readonly error?: unknown;
     readonly idempotencyKey: string;
-    readonly kind: InstrumentationInputKind;
-    readonly outcome: InstrumentationInputOutcome;
-    readonly requestId: string;
+    readonly kind: InstrumentationInteractionKind;
+    readonly interactionId: string;
+    readonly outcome: InstrumentationInteractionOutcome;
     /** Content. Absent unless this provider's trace policy records this direction. */
-    readonly response?: InstrumentationInputResponse;
-    readonly scope: InstrumentationAttemptScope;
+    readonly answer?: InstrumentationAnswer;
+    readonly scope: InstrumentationScope;
 }
 /** Runtime action call IDs are durable and unique within one session. */
-export declare function actionIdempotencyKey(sessionId: string, turnId: string, callId: string): string;
-export interface InstrumentationStepAttemptStartedEvent {
-    readonly type: "step.attempt.started";
+export declare function actionIdempotencyKey(sessionId: string, turnId: string | undefined, callId: string): string;
+export interface InstrumentationModelStartedEvent {
+    readonly type: "model.started";
     readonly idempotencyKey: string;
     readonly operation: InstrumentationOperationRef;
     readonly runtimeContext?: Readonly<Record<string, unknown>>;
-    readonly scope: InstrumentationAttemptScope;
+    readonly scope: InstrumentationScope;
 }
 export interface InstrumentationSessionStartedEvent {
     readonly traceSessionId?: string;
@@ -216,7 +196,7 @@ export interface InstrumentationSessionStartedEvent {
     readonly title?: string;
     readonly traceSeed?: InstrumentationTraceSeed;
 }
-export type InstrumentationTraceContext = RuntimeTraceContext;
+export type InstrumentationTraceContext = TraceContext;
 export interface InstrumentationTraceSeed extends InstrumentationTraceContext {
     readonly decision?: InstrumentationDecision;
 }
@@ -237,28 +217,19 @@ export interface InstrumentationParentLineage {
     readonly subagentName?: string;
     readonly turnId: string;
 }
-/**
- * A session transition that carries no failure.
- *
- * `session.waiting` sits here rather than with the failed shape because it is
- * not terminal: the session suspends awaiting input or approval and may resume
- * with a new turn.
- */
-export interface InstrumentationSessionSettledEvent {
-    readonly type: "session.completed" | "session.waiting";
-    readonly idempotencyKey: string;
-    readonly sessionId: string;
-    readonly turnId?: string;
-}
-export interface InstrumentationSessionFailedEvent {
-    readonly type: "session.failed";
-    /** Content. Absent unless this provider's trace policy records this direction. */
+/** How a session ended, as its `session.ended` says. */
+export type InstrumentationSessionOutcome = SessionOutcome;
+/** The session ended: its `session.ended`. */
+export interface InstrumentationSessionEndedEvent {
+    readonly type: "session.ended";
+    readonly outcome: InstrumentationSessionOutcome;
+    /** A failed session's error. Content: absent unless this provider records outputs. */
     readonly error?: unknown;
     readonly idempotencyKey: string;
     readonly sessionId: string;
+    /** The turn that failed it, when one did; otherwise the session's latest turn. */
     readonly turnId?: string;
 }
-export type InstrumentationSessionTransitionEvent = InstrumentationSessionSettledEvent | InstrumentationSessionFailedEvent;
 export interface InstrumentationTurnStartedEvent {
     readonly traceSessionId?: string;
     readonly type: "turn.started";
@@ -273,54 +244,37 @@ export interface InstrumentationTurnStartedEvent {
     readonly sessionId: string;
     readonly turnId: string;
 }
-/**
- * A turn that ended without a failure.
- *
- * `turn.cancelled` sits here rather than with the failed shape because
- * cancellation is not an error: the harness settles a cancelled turn as
- * `turn.cancelled` → `session.waiting`, with no failure surfaced anywhere.
- */
+/** How a turn ended, as its `turn.settled` says. */
+export type InstrumentationTurnOutcome = TurnOutcome;
+/** The turn ended: its `turn.settled`. A cancelled turn is no failure. */
 export interface InstrumentationTurnSettledEvent {
-    readonly type: "turn.cancelled" | "turn.completed";
-    readonly idempotencyKey: string;
-    readonly sessionId: string;
-    readonly turnId: string;
-}
-export interface InstrumentationTurnFailedEvent {
-    readonly type: "turn.failed";
-    /** Content. Absent unless this provider's trace policy records this direction. */
+    readonly type: "turn.settled";
+    readonly outcome: InstrumentationTurnOutcome;
+    /** A failed turn's error. Content: absent unless this provider records outputs. */
     readonly error?: unknown;
     readonly idempotencyKey: string;
     readonly sessionId: string;
     readonly turnId: string;
 }
-export type InstrumentationTurnTerminalEvent = InstrumentationTurnSettledEvent | InstrumentationTurnFailedEvent;
-export interface InstrumentationStepAttemptCompletedEvent {
-    readonly type: "step.attempt.completed";
+export interface InstrumentationModelRetriedEvent {
+    readonly type: "model.retried";
     readonly idempotencyKey: string;
-    readonly scope: InstrumentationAttemptScope;
-}
-export interface InstrumentationStepAttemptFailedEvent {
-    readonly type: "step.attempt.failed";
-    /** Content. Absent unless this provider's trace policy records this direction. */
+    readonly scope: InstrumentationScope;
     readonly error?: unknown;
-    readonly idempotencyKey: string;
-    readonly scope: InstrumentationAttemptScope;
 }
-export type InstrumentationStepAttemptTerminalEvent = InstrumentationStepAttemptCompletedEvent | InstrumentationStepAttemptFailedEvent;
 /**
- * Provider metadata for one completed attempt, as reported by the AI SDK
- * (`StepResult.providerMetadata`). Carries Vercel AI Gateway cost and session
- * affinity routing data when the request went through the gateway; absent for
- * other providers. When the trace policy omits outputs, only the gateway's
- * `cost`, `generationId`, and `routing` fields remain.
+ * How a model run ended, as its `model.settled` says, except that a run its turn's cancellation
+ * cut is `cancelled` rather than `interrupted`: it stopped on purpose, not as a failure.
  */
-export interface InstrumentationStepAttemptMetadataEvent {
-    readonly type: "step.attempt.metadata";
+export type InstrumentationModelOutcome = ModelOutcome | "cancelled";
+export interface InstrumentationModelSettledEvent {
+    readonly type: "model.settled";
+    readonly outcome: InstrumentationModelOutcome;
     readonly idempotencyKey: string;
-    readonly scope: InstrumentationAttemptScope;
-    readonly providerMetadata: Readonly<Record<string, unknown>>;
+    readonly scope: InstrumentationScope;
+    readonly error?: unknown;
 }
+export type InstrumentationModelTerminalEvent = InstrumentationModelRetriedEvent | InstrumentationModelSettledEvent;
 export interface InstrumentationModelCallStartedEvent {
     readonly type: "model.call.started";
     readonly idempotencyKey: string;
@@ -328,68 +282,74 @@ export interface InstrumentationModelCallStartedEvent {
     readonly input?: InstrumentationModelInput;
     readonly model: InstrumentationModelRef;
     readonly runtimeContext?: Readonly<Record<string, unknown>>;
-    readonly scope: InstrumentationAttemptScope;
+    readonly scope: InstrumentationScope;
 }
 export interface InstrumentationModelCallCompletedEvent {
-    readonly type: "model.call.completed";
+    readonly type: "model.call.settled";
+    readonly outcome: "completed";
+    /**
+     * Provider metadata, as reported by the AI SDK. Carries Vercel AI Gateway cost and session
+     * affinity routing data when the request went through the gateway; absent for other providers.
+     * When the trace policy omits outputs, only the gateway's `cost`, `generationId`, and `routing`
+     * fields remain.
+     */
+    readonly providerMetadata?: Readonly<Record<string, unknown>>;
     /** Content. Absent unless this provider's trace policy records this direction. */
     readonly content?: readonly InstrumentationContentPart[];
     readonly finishReason: string;
     readonly idempotencyKey: string;
     readonly responseModelId?: string;
     readonly responseId?: string;
-    readonly scope: InstrumentationAttemptScope;
+    readonly scope: InstrumentationScope;
     readonly usage: InstrumentationUsage;
 }
 export interface InstrumentationModelCallFailedEvent {
-    readonly type: "model.call.failed";
+    readonly type: "model.call.settled";
+    readonly outcome: "failed";
     /** Content. Absent unless this provider's trace policy records this direction. */
     readonly error?: unknown;
     readonly idempotencyKey: string;
-    readonly scope: InstrumentationAttemptScope;
+    readonly scope: InstrumentationScope;
 }
 export type InstrumentationModelCallTerminalEvent = InstrumentationModelCallCompletedEvent | InstrumentationModelCallFailedEvent;
-/** How eve runs the tool call. */
-export type InstrumentationToolCallKind = "load-skill" | "remote-agent-call" | "subagent-call" | "tool-call";
-export interface InstrumentationToolCallStartedEvent {
+/**
+ * A call was requested: the session's `call.requested`, or a tool a channel runs directly (with
+ * `invokeTool`), which no session stream records.
+ */
+export interface InstrumentationCallRequestedEvent {
     /** Durable dispatch metadata, when this call is owned by eve's tool loop. */
-    readonly kind?: InstrumentationToolCallKind;
-    readonly isWorkflowTool?: boolean;
-    readonly frameworkTool?: boolean;
+    readonly capability: Capability;
+    readonly frameworkTool: boolean;
     readonly startedAtMs?: number;
-    readonly type: "tool.call.started";
+    readonly type: "call.requested";
     readonly callId: string;
     readonly idempotencyKey: string;
+    /** Content. Absent unless this provider's trace policy records inputs. */
     readonly input: unknown;
-    readonly scope: InstrumentationAttemptScope;
+    readonly scope: InstrumentationScope;
     readonly toolName: string;
 }
-export interface InstrumentationToolCallCompletedEvent {
-    readonly outcome?: InstrumentationToolCallOutcome;
+/** How a call ended, as its `call.settled` says. */
+export type InstrumentationCallOutcome = CallOutcome;
+/** The call settled: the session's `call.settled`, or a direct call's end. */
+export interface InstrumentationCallSettledEvent {
+    readonly type: "call.settled";
+    readonly outcome: InstrumentationCallOutcome;
+    /** A completed call's output. Content: absent unless this provider records outputs. */
+    readonly output?: unknown;
+    /** Why it didn't complete. Content: absent unless this provider records outputs. */
+    readonly error?: unknown;
+    readonly errorCode?: string;
     readonly usage?: InstrumentationUsage;
+    readonly reason?: string;
+    readonly cause?: Cause;
     readonly acceptedAtMs?: number;
     readonly completedAtMs?: number;
-    readonly type: "tool.call.completed";
     /** How long the tool's `execute` ran, in milliseconds, when the publisher measured it. */
     readonly durationMs?: number;
     readonly idempotencyKey: string;
-    readonly output: InstrumentationToolOutput;
-    readonly scope: InstrumentationAttemptScope;
-}
-export interface InstrumentationToolCallFailedEvent {
-    readonly outcome?: Exclude<InstrumentationToolCallOutcome, "completed">;
-    readonly usage?: InstrumentationUsage;
-    readonly acceptedAtMs?: number;
-    readonly errorCode?: string;
-    readonly completedAtMs?: number;
-    readonly type: "tool.call.failed";
-    /** Content. Absent unless this provider's trace policy records this direction. */
-    readonly error?: unknown;
-    readonly idempotencyKey: string;
-    readonly scope: InstrumentationAttemptScope;
+    readonly scope: InstrumentationScope;
 }
-export type InstrumentationToolCallTerminalEvent = InstrumentationToolCallCompletedEvent | InstrumentationToolCallFailedEvent;
-export type InstrumentationToolCallOutcome = "abandoned" | "cancelled" | "completed" | "failed" | "rejected";
 /** The second argument to every handler. */
 export interface InstrumentationHandlerContext {
     /** Durable state scoped to this provider and this operation. */
@@ -412,33 +372,7 @@ export interface InstrumentationProviderDefinition {
     /** Provider-specific event admission and directional content policy. */
     readonly tracePolicy?: TraceCapturePolicy;
     readonly events?: {
-        readonly "channel.delivery.started"?: InstrumentationEventHandler<InstrumentationChannelDeliveryStartedEvent>;
-        readonly "channel.delivery.cancelled"?: InstrumentationEventHandler<InstrumentationChannelDeliveryTerminalEvent>;
-        readonly "channel.delivery.completed"?: InstrumentationEventHandler<InstrumentationChannelDeliveryTerminalEvent>;
-        readonly "channel.delivery.failed"?: InstrumentationEventHandler<InstrumentationChannelDeliveryTerminalEvent>;
-        readonly "step.attempt.started"?: InstrumentationEventHandler<InstrumentationStepAttemptStartedEvent>;
-        readonly "step.attempt.completed"?: InstrumentationEventHandler<InstrumentationStepAttemptCompletedEvent>;
-        readonly "step.attempt.failed"?: InstrumentationEventHandler<InstrumentationStepAttemptFailedEvent>;
-        readonly "step.attempt.metadata"?: InstrumentationEventHandler<InstrumentationStepAttemptMetadataEvent>;
-        readonly "model.call.started"?: InstrumentationEventHandler<InstrumentationModelCallStartedEvent>;
-        readonly "model.call.completed"?: InstrumentationEventHandler<InstrumentationModelCallCompletedEvent>;
-        readonly "model.call.failed"?: InstrumentationEventHandler<InstrumentationModelCallFailedEvent>;
-        readonly "memory.operation.started"?: InstrumentationEventHandler<memory.InstrumentationMemoryOperationStartedEvent>;
-        readonly "memory.operation.completed"?: InstrumentationEventHandler<memory.InstrumentationMemoryOperationCompletedEvent>;
-        readonly "memory.operation.failed"?: InstrumentationEventHandler<memory.InstrumentationMemoryOperationFailedEvent>;
-        readonly "input.requested"?: InstrumentationEventHandler<InstrumentationInputRequestedEvent>;
-        readonly "input.resolved"?: InstrumentationEventHandler<InstrumentationInputResolvedEvent>;
-        readonly "session.completed"?: InstrumentationEventHandler<InstrumentationSessionSettledEvent>;
-        readonly "session.failed"?: InstrumentationEventHandler<InstrumentationSessionFailedEvent>;
-        readonly "session.started"?: InstrumentationEventHandler<InstrumentationSessionStartedEvent>;
-        readonly "session.waiting"?: InstrumentationEventHandler<InstrumentationSessionSettledEvent>;
-        readonly "tool.call.started"?: InstrumentationEventHandler<InstrumentationToolCallStartedEvent>;
-        readonly "tool.call.completed"?: InstrumentationEventHandler<InstrumentationToolCallCompletedEvent>;
-        readonly "tool.call.failed"?: InstrumentationEventHandler<InstrumentationToolCallFailedEvent>;
-        readonly "turn.cancelled"?: InstrumentationEventHandler<InstrumentationTurnSettledEvent>;
-        readonly "turn.completed"?: InstrumentationEventHandler<InstrumentationTurnSettledEvent>;
-        readonly "turn.failed"?: InstrumentationEventHandler<InstrumentationTurnFailedEvent>;
-        readonly "turn.started"?: InstrumentationEventHandler<InstrumentationTurnStartedEvent>;
+        readonly [K in InstrumentationEvent["type"]]?: InstrumentationEventHandler<InstrumentationEvent<K>>;
     };
     /** Drains anything buffered. Driven by the runtime, not by the bus. */
     readonly flush?: () => void | PromiseLike<void>;
@@ -455,15 +389,18 @@ export interface InstrumentationDispatchGroups {
 }
 export type InstrumentationHooksInput = readonly InstrumentationProviderInput[] | InstrumentationDispatchGroups;
 /** Events that pair a start with its terminal under one `idempotencyKey`. */
-export type InstrumentationCorrelatedEvent = InstrumentationChannelDeliveryStartedEvent | InstrumentationChannelDeliveryTerminalEvent | InstrumentationInputRequestedEvent | InstrumentationInputResolvedEvent | memory.InstrumentationMemoryOperationStartedEvent | memory.InstrumentationMemoryOperationTerminalEvent | InstrumentationModelCallStartedEvent | InstrumentationModelCallTerminalEvent | InstrumentationToolCallStartedEvent | InstrumentationToolCallTerminalEvent;
-export type InstrumentationPointEvent = InstrumentationStepAttemptStartedEvent | InstrumentationStepAttemptMetadataEvent | InstrumentationStepAttemptTerminalEvent | InstrumentationSessionStartedEvent | InstrumentationSessionTransitionEvent | InstrumentationTurnStartedEvent | InstrumentationTurnTerminalEvent;
-export type InstrumentationEvent = InstrumentationCorrelatedEvent | InstrumentationPointEvent;
+export type InstrumentationCorrelatedEvent = InstrumentationDeliveryConsumedEvent | InstrumentationDeliverySettledEvent | InstrumentationInteractionOpenedEvent | InstrumentationInteractionSettledEvent | memory.InstrumentationMemoryOperationStartedEvent | memory.InstrumentationMemoryOperationTerminalEvent | InstrumentationModelCallStartedEvent | InstrumentationModelCallTerminalEvent | InstrumentationCallRequestedEvent | InstrumentationCallSettledEvent;
+export type InstrumentationPointEvent = InstrumentationModelStartedEvent | InstrumentationModelTerminalEvent | InstrumentationSessionStartedEvent | InstrumentationSessionEndedEvent | InstrumentationTurnStartedEvent | InstrumentationTurnSettledEvent;
+type LifecycleEvent = InstrumentationCorrelatedEvent | InstrumentationPointEvent;
+export type InstrumentationEvent<K extends LifecycleEvent["type"] = LifecycleEvent["type"]> = Extract<LifecycleEvent, {
+    readonly type: K;
+}>;
 /** Trusted framework operation for activating context around AI SDK execution. */
 export type InstrumentationContextRunner = <T>(operation: InstrumentationExecutionOperation, execute: () => PromiseLike<T>) => PromiseLike<T>;
 /** Stable identity supplied only to a trusted framework context runner. */
 export type InstrumentationExecutionOperation = {
     readonly idempotencyKey: string;
-    readonly scope: InstrumentationAttemptScope;
+    readonly scope: InstrumentationScope;
     readonly type: "tool.call";
     readonly callId?: string;
     readonly toolName?: string;
@@ -474,7 +411,7 @@ export type InstrumentationExecutionOperation = {
     readonly failed?: boolean;
 } | {
     readonly idempotencyKey: string;
-    readonly scope: InstrumentationAttemptScope;
+    readonly scope: InstrumentationScope;
     readonly type: "model.call";
 } | memory.InstrumentationMemoryExecutionOperation;
 /** Provider-neutral hook operations consumed by the AI SDK bridge. */

package/dist/src/instrumentation/lifecycle.js

@@ -1 +1 @@
-import{createInstrumentationDispatcher}from"#instrumentation/dispatch.js";function sessionIdempotencyKey(e){return`session:${e}`}function turnIdempotencyKey(e,t){return`turn:${e}:${t}`}function attemptIdempotencyKey(e){return`step:${e.attemptId}`}function modelCallIdempotencyKey(e,t,n){return`model:${e.attemptId}:${String(t)}:${String(n)}`}function toolCallIdempotencyKey(e,t,n){return`tool:${e.attemptId}:${t}:${String(n)}`}function inputIdempotencyKey(e,t,n){return`input:${e}:${t}:${n}`}function channelDeliveryIdempotencyKey(e,t){return`channel-delivery:${e}:${t}`}function actionIdempotencyKey(e,t,n){return`action:${e}:${t}:${n}`}const INSTRUMENTATION_PRINCIPAL_TYPES=[`anonymous`,`app`,`local-dev`,`none`,`other`,`runtime`,`service`,`unknown`,`user`];function isInstrumentationPrincipalType(e){return INSTRUMENTATION_PRINCIPAL_TYPES.some(t=>t===e)}function createInstrumentationHooks(e,t={}){return createInstrumentationDispatcher(e,t)}export{INSTRUMENTATION_PRINCIPAL_TYPES,actionIdempotencyKey,attemptIdempotencyKey,channelDeliveryIdempotencyKey,createInstrumentationHooks,inputIdempotencyKey,isInstrumentationPrincipalType,modelCallIdempotencyKey,sessionIdempotencyKey,toolCallIdempotencyKey,turnIdempotencyKey};
+import{createInstrumentationDispatcher}from"#instrumentation/dispatch.js";function sessionIdempotencyKey(e){return`session:${e}`}function turnIdempotencyKey(e,t){return`turn:${e}:${t}`}function attemptIdempotencyKey(e){return`model-run:${e.sessionId}:${e.runId}:${e.attempt}`}function modelCallIdempotencyKey(e,t,n){return`model:${e.sessionId}:${e.runId}:${e.attempt}:${String(t)}:${String(n)}`}function toolCallIdempotencyKey(e,t,n){return`tool:${e.sessionId}:${e.runId}:${e.attempt}:${t}:${String(n)}`}function inputIdempotencyKey(e,t,n){return`input:${e}:${t}:${n}`}function channelDeliveryIdempotencyKey(e,t){return`channel-delivery:${e}:${t}`}function actionIdempotencyKey(e,t,n){return`action:${e}:${t}:${n}`}const INSTRUMENTATION_PRINCIPAL_TYPES=[`anonymous`,`app`,`local-dev`,`none`,`other`,`runtime`,`service`,`unknown`,`user`];function isInstrumentationPrincipalType(e){return INSTRUMENTATION_PRINCIPAL_TYPES.some(t=>t===e)}function createInstrumentationHooks(e,t={}){return createInstrumentationDispatcher(e,t)}export{INSTRUMENTATION_PRINCIPAL_TYPES,actionIdempotencyKey,attemptIdempotencyKey,channelDeliveryIdempotencyKey,createInstrumentationHooks,inputIdempotencyKey,isInstrumentationPrincipalType,modelCallIdempotencyKey,sessionIdempotencyKey,toolCallIdempotencyKey,turnIdempotencyKey};

package/dist/src/instrumentation/memory.d.ts

@@ -33,14 +33,16 @@ export interface InstrumentationMemoryOperationStartedEvent extends Instrumentat
     readonly type: "memory.operation.started";
 }
 export interface InstrumentationMemoryOperationCompletedEvent extends InstrumentationMemoryOperationEvent {
-    readonly type: "memory.operation.completed";
+    readonly type: "memory.operation.settled";
+    readonly outcome: "completed";
     /** The number of records the operation returned or changed, when known. */
     readonly recordCount?: number;
     /** Content. Absent unless this provider's trace policy records inputs. */
     readonly outputRecords?: readonly InstrumentationMemoryRecord[];
 }
 export interface InstrumentationMemoryOperationFailedEvent extends InstrumentationMemoryOperationEvent {
-    readonly type: "memory.operation.failed";
+    readonly type: "memory.operation.settled";
+    readonly outcome: "failed";
     /** Content. Absent unless this provider's trace policy records outputs. */
     readonly error?: unknown;
 }

package/dist/src/instrumentation/memory.js

@@ -1 +1 @@
-function createMemoryInstrumentation(e){return{async execute(t,n){let{hooks:r,rootSessionId:i,traceSessionId:a}=e.resolveContext(),o={...t,rootSessionId:i,traceSessionId:a,sessionId:e.sessionId};await r.publish({...o,type:`memory.operation.started`});try{let t=await e.runInContext({...o,type:`memory.operation`},n);return await r.publish({...o,outputRecords:t.outputRecords,recordCount:t.recordCount,type:`memory.operation.completed`}),t.value}catch(e){throw await r.publish({...o,error:e,type:`memory.operation.failed`}),e}}}}async function instrumentMemoryOperation(e,t,n){return e===void 0?(await n()).value:await e.execute(typeof t==`function`?t():t,n)}export{createMemoryInstrumentation,instrumentMemoryOperation};
+function createMemoryInstrumentation(e){return{async execute(t,n){let{hooks:r,rootSessionId:i,traceSessionId:a}=e.resolveContext(),o={...t,rootSessionId:i,traceSessionId:a,sessionId:e.sessionId};await r.publish({...o,type:`memory.operation.started`});try{let t=await e.runInContext({...o,type:`memory.operation`},n);return await r.publish({outcome:`completed`,...o,outputRecords:t.outputRecords,recordCount:t.recordCount,type:`memory.operation.settled`}),t.value}catch(e){throw await r.publish({outcome:`failed`,...o,error:e,type:`memory.operation.settled`}),e}}}}async function instrumentMemoryOperation(e,t,n){return e===void 0?(await n()).value:await e.execute(typeof t==`function`?t():t,n)}export{createMemoryInstrumentation,instrumentMemoryOperation};

package/dist/src/instrumentation/native-events.d.ts

@@ -1,14 +1,15 @@
-import type { InstrumentationAttemptScope, InstrumentationHooks, InstrumentationParentLineage, InstrumentationTraceContext } from "#instrumentation/lifecycle.js";
-import type { ResolvedInputBatch } from "#harness/input-request-resolution.js";
+import type { DeliverHookPayload } from "#channel/types.js";
+import type { InstrumentationScope, InstrumentationHooks, InstrumentationParentLineage, InstrumentationTraceContext } from "#instrumentation/lifecycle.js";
 import type { HandleEventFn } from "#harness/types.js";
 import type { ChannelAudience } from "#shared/channel-audience.js";
 export interface CreateInstrumentationHandleEventInput {
+    readonly deliveryInput?: DeliverHookPayload;
     readonly isFrameworkTool?: (name: string) => boolean;
+    readonly functionId?: string;
     readonly traceSessionId?: string;
     readonly agentName?: string;
     readonly channelKind?: string;
     readonly channelAudience?: ChannelAudience;
-    readonly getAttemptScope?: () => InstrumentationAttemptScope | undefined;
     readonly handleEvent?: HandleEventFn;
     readonly hooks?: InstrumentationHooks;
     readonly parentLineage?: InstrumentationParentLineage;
@@ -17,13 +18,19 @@ export interface CreateInstrumentationHandleEventInput {
     readonly scheduleId?: string;
     readonly sessionId: string;
     readonly title?: string;
+}
+/** Where an attempt is in its session: its turn, its step, and which try at the step it is. */
+export interface AttemptPlace {
+    readonly runId: string;
     readonly turnId?: string;
+    readonly stepIndex?: number;
+    readonly attempt: number;
 }
-/** Publishes eve-native lifecycle transitions after durable event acceptance. */
+/** An attempt's scope: the session it runs in, and its place. */
+export declare function attemptScopeOf(session: Pick<CreateInstrumentationHandleEventInput, "channelAudience" | "functionId" | "rootSessionId" | "sessionId" | "traceSessionId">, { runId, attempt, stepIndex, turnId }: AttemptPlace): InstrumentationScope;
+/**
+ * Publishes each committed fact's instrumentation events once the publication folds it. The
+ * events are a function of the fact and the tables after it: a call's or a request's attempt is
+ * its run's current one, the attempt that produced it.
+ */
 export declare function createInstrumentationHandleEvent(input: CreateInstrumentationHandleEventInput): HandleEventFn | undefined;
-/** Publishes accepted input resolutions against their original request scope. */
-export declare function publishInputResolutions(input: {
-    readonly batch: ResolvedInputBatch;
-    readonly hooks: InstrumentationHooks;
-    readonly sessionId: string;
-}): Promise<void>;