eve 0.37.0 → 0.38.0

package/dist/src/tasks/session-index.d.ts

@@ -0,0 +1,48 @@
+import type { HarnessSession, SessionStateMap } from "#harness/types.js";
+import type { TaskMetadata, TaskView } from "#tasks/types.js";
+/**
+ * Session-state key for the parent's live-task index.
+ *
+ * The parent session stores only this index; the mutable task record
+ * lives in the dedicated durable task run. The PR #1190 spike found the
+ * session-state boundary unworkable for task state itself: session state
+ * threads through step results, while callback routes and child
+ * executors must update tasks without holding the current snapshot.
+ */
+export declare const SESSION_TASKS_STATE_KEY = "eve.tasks";
+/**
+ * One task owned by this session. Immutable model-safe metadata keeps the
+ * task-to-agent join available before the task run publishes its first view.
+ *
+ * `taskInboxToken` is the private routing credential for the task run's
+ * inbound hook. It must never render into model context, history, task
+ * views, or compaction summaries — the model addresses tasks by
+ * `taskId` only, and lookup verifies ownership through this index.
+ */
+export interface SessionTaskIndexEntry {
+    readonly taskId: string;
+    readonly taskRunId: string;
+    /** Immutable fallback once the owning workflow run expires. */
+    readonly terminalView?: TaskView;
+    readonly taskInboxToken: string;
+    readonly createdByStepIndex?: number;
+    readonly createdByTurnId: string;
+    readonly metadata: TaskMetadata;
+    readonly operationId: string;
+}
+/**
+ * Reads and validates the task index from session state.
+ *
+ * A present but invalid index throws: treating corruption as absence
+ * would silently orphan every live task's routing credential.
+ */
+export declare function getSessionTaskIndex(state: SessionStateMap | undefined): readonly SessionTaskIndexEntry[];
+/** Caches one terminal view beside its task-run address. */
+export declare function cacheTerminalTaskView(state: SessionStateMap | undefined, view: TaskView): SessionStateMap | undefined;
+/** Finds one owned task; `undefined` enforces parent-session ownership. */
+export declare function findSessionTaskEntry(state: SessionStateMap | undefined, taskId: string): SessionTaskIndexEntry | undefined;
+/**
+ * Records one task, replacing any entry with the same id so replayed
+ * creation for the same originating call stays idempotent.
+ */
+export declare function recordSessionTask(session: HarnessSession, entry: SessionTaskIndexEntry): HarnessSession;

package/dist/src/tasks/session-index.js

@@ -0,0 +1 @@
+import{z}from"#compiled/zod/index.js";const SESSION_TASKS_STATE_KEY=`eve.tasks`,taskMetadataSchema=z.strictObject({agentId:z.string().min(1),kind:z.literal(`subagent`),mode:z.enum([`local`,`remote`]),name:z.string().min(1)}),taskViewBaseShape={executor:z.strictObject({childSessionId:z.string().min(1).optional(),childTurnId:z.string().min(1).optional(),lifecycle:z.enum([`parked`,`terminal`]).optional()}).optional(),metadata:taskMetadataSchema,taskId:z.string().min(1),usage:z.strictObject({cacheReadTokens:z.number().nonnegative(),cacheWriteTokens:z.number().nonnegative(),inputTokens:z.number().nonnegative(),outputTokens:z.number().nonnegative()}).optional()},taskViewSchema=z.discriminatedUnion(`status`,[z.strictObject({...taskViewBaseShape,lastOutput:z.strictObject({data:z.custom(),type:z.literal(`result`)}),status:z.literal(`completed`)}),z.strictObject({...taskViewBaseShape,lastOutput:z.strictObject({data:z.custom(),type:z.literal(`error`)}),status:z.literal(`failed`)}),z.strictObject({...taskViewBaseShape,status:z.literal(`cancelled`)})]),sessionTaskIndexEntrySchema=z.strictObject({taskInboxToken:z.string().min(1),createdByStepIndex:z.number().int().nonnegative().optional(),createdByTurnId:z.string().min(1),metadata:taskMetadataSchema,operationId:z.string().min(1),taskId:z.string().min(1),taskRunId:z.string().min(1),terminalView:taskViewSchema.optional()}),sessionTaskIndexSchema=z.strictObject({tasks:z.array(sessionTaskIndexEntrySchema)}).refine(e=>new Set(e.tasks.map(e=>e.taskId)).size===e.tasks.length,{message:`Task ids must be unique.`}).refine(e=>e.tasks.every(e=>e.terminalView===void 0||e.terminalView.taskId===e.taskId&&sameTaskMetadata(e.terminalView.metadata,e.metadata)),{message:`Cached terminal views must match their task index entry.`});function getSessionTaskIndex(e){let n=e?.[SESSION_TASKS_STATE_KEY];if(n===void 0)return[];let r=sessionTaskIndexSchema.safeParse(n);if(!r.success)throw Error(`Corrupt task index under session state key "${SESSION_TASKS_STATE_KEY}": ${r.error.message}`);return r.data.tasks}function cacheTerminalTaskView(e,n){if(!isValidTerminalView(n))throw Error(`Cannot cache invalid terminal task "${n.taskId}".`);let r=getSessionTaskIndex(e),i=r.findIndex(e=>e.taskId===n.taskId);if(i<0)return e;if(!sameTaskMetadata(r[i].metadata,n.metadata))throw Error(`Task view metadata does not match index entry "${n.taskId}".`);let a=[...r];return a[i]={...a[i],terminalView:n},{...e,[SESSION_TASKS_STATE_KEY]:{tasks:a}}}function isValidTerminalView(e){if(e.inputRequests!==void 0)return!1;switch(e.status){case`completed`:return e.lastOutput?.type===`result`;case`failed`:return e.lastOutput?.type===`error`;case`cancelled`:return e.lastOutput===void 0;case`working`:return!1}}function sameTaskMetadata(e,t){return e.agentId===t.agentId&&e.kind===t.kind&&e.mode===t.mode&&e.name===t.name}function findSessionTaskEntry(e,t){return getSessionTaskIndex(e).find(e=>e.taskId===t)}function recordSessionTask(e,n){let r=[...getSessionTaskIndex(e.state).filter(e=>e.taskId!==n.taskId),n];return{...e,state:{...e.state,[SESSION_TASKS_STATE_KEY]:{tasks:r}}}}export{SESSION_TASKS_STATE_KEY,cacheTerminalTaskView,findSessionTaskEntry,getSessionTaskIndex,recordSessionTask};

package/dist/src/tasks/task-id.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Derives the stable task id for one originating subagent call.
+ *
+ * Reuses the agent-handle operation-id derivation —
+ * `hash(parentSessionId, parentTurnId, callId)` — so replayed creation
+ * for the same call yields the same task without new machinery, and a
+ * task can never be confused with a child session id or continuation
+ * token.
+ *
+ * Lives apart from the pure task modules because the derivation needs
+ * `node:crypto`, which workflow bodies reject; ids are only ever minted
+ * inside dispatch steps.
+ */
+export declare function deriveTaskId(input: {
+    readonly callId: string;
+    readonly parentSessionId: string;
+    readonly parentTurnId: string;
+}): string;
+/**
+ * Derives the task run's private inbox token.
+ *
+ * Deterministic on purpose: a durable replay of the dispatch step must
+ * re-derive the same token so the duplicate task run loses the hook
+ * claim and exits instead of splitting the lifecycle across two runs.
+ * Unguessable in practice: the parent session's continuation token is
+ * itself a private capability, and the derived token never renders to
+ * the model.
+ */
+export declare function deriveTaskInboxToken(input: {
+    readonly parentContinuationToken: string;
+    readonly taskId: string;
+}): string;
+/** Reads the non-secret task id embedded in a private task inbox token. */
+export declare function readTaskIdFromInboxToken(token: string): string | undefined;

package/dist/src/tasks/task-id.js

@@ -0,0 +1 @@
+import{createHash}from"node:crypto";import{deriveAgentOperationId}from"#harness/handles/operation-id.js";function deriveTaskId(e){return`task_${deriveAgentOperationId(e).slice(0,24)}`}function deriveTaskInboxToken(t){return`task:${t.taskId}:${createHash(`sha256`).update(`${t.taskId}\0${t.parentContinuationToken}`).digest(`hex`).slice(0,32)}`}function readTaskIdFromInboxToken(e){return/^task:(task_[^:]+):[a-f0-9]{32}$/.exec(e)?.[1]}export{deriveTaskId,deriveTaskInboxToken,readTaskIdFromInboxToken};

package/dist/src/tasks/transitions.d.ts

@@ -0,0 +1,23 @@
+import type { TaskCommand, TaskView } from "#tasks/types.js";
+/**
+ * Outcome of applying one command to a task view.
+ *
+ * - `accepted`: the state changed; the new view must be appended.
+ * - `noop`: the command is recognized and benign (idempotent cancel,
+ *   stale answer); nothing changed and nothing is appended.
+ * - `rejected`: the command is invalid for the current status; the
+ *   reason is diagnostic only.
+ */
+type TaskTransitionResult = {
+    readonly outcome: "accepted";
+    readonly view: TaskView;
+} | {
+    readonly outcome: "noop";
+    readonly view: TaskView;
+} | {
+    readonly outcome: "rejected";
+    readonly view: TaskView;
+    readonly reason: string;
+};
+export declare function applyTaskTransition(view: TaskView, command: TaskCommand): TaskTransitionResult;
+export {};

package/dist/src/tasks/transitions.js

@@ -0,0 +1 @@
+import{isTerminalTaskStatus,readTaskInputRequestId}from"#tasks/types.js";function terminalView(e,t,n){let r={executor:t.lifecycle===void 0?e.executor:{...e.executor,lifecycle:t.lifecycle},metadata:e.metadata,taskId:e.taskId};switch(t.usage!==void 0&&(r.usage=t.usage),n.status){case`completed`:return{...r,lastOutput:n.lastOutput,status:`completed`};case`failed`:return{...r,lastOutput:n.lastOutput,status:`failed`};case`cancelled`:return{...r,status:`cancelled`}}}function applyTaskTransition(n,r){if(isTerminalTaskStatus(n.status)){if(r.kind===`settle-executor`){let e={...n.executor,lifecycle:`terminal`};if(sameUsage(n.usage,r.usage)&&n.executor?.lifecycle===`terminal`)return{outcome:`noop`,view:n};let t={...n,executor:e};return{outcome:`accepted`,view:r.usage===void 0?t:{...t,usage:r.usage}}}return r.kind===`cancel`&&n.status===`cancelled`?{outcome:`noop`,view:n}:{outcome:`rejected`,reason:`Task "${n.taskId}" is already ${n.status}; "${r.kind}" cannot change a terminal task.`,view:n}}switch(r.kind){case`complete`:return{outcome:`accepted`,view:terminalView(n,r,{lastOutput:{data:r.data,type:`result`},status:`completed`})};case`fail`:case`reject-dispatch`:return{outcome:`accepted`,view:terminalView(n,r,{lastOutput:{data:r.data,type:`error`},status:`failed`})};case`cancel`:return{outcome:`accepted`,view:terminalView(n,r,{status:`cancelled`})};case`settle-executor`:return{outcome:`rejected`,reason:`Task "${n.taskId}" is not terminal; usage settles with its terminal command.`,view:n};case`require-authorization`:{let e={blockedOn:`authorization`,requestId:r.requestId};return n.status===`input_required`?n.inputRequests.some(e=>readTaskInputRequestId(e)===r.requestId)?{outcome:`noop`,view:n}:{outcome:`accepted`,view:{...n,inputRequests:[...n.inputRequests,e]}}:{outcome:`accepted`,view:{inputRequests:[e],executor:n.executor,metadata:n.metadata,status:`input_required`,taskId:n.taskId}}}case`require-input`:return isValidInputRequestBatch(r.inputRequests)?{outcome:`accepted`,view:{inputRequests:r.inputRequests,executor:n.executor,metadata:n.metadata,status:`input_required`,taskId:n.taskId}}:{outcome:`rejected`,reason:`Task "${n.taskId}" received an invalid input request batch.`,view:n};case`ready`:return{outcome:`accepted`,view:n};case`answered`:{if(n.status!==`input_required`)return{outcome:`noop`,view:n};let e=new Set(r.requestIds),i=n.inputRequests,a=i.filter(n=>{let r=readTaskInputRequestId(n);return r===void 0||!e.has(r)});return a.length===i.length?{outcome:`noop`,view:n}:a.length>0?{outcome:`accepted`,view:{inputRequests:a,executor:n.executor,metadata:n.metadata,status:`input_required`,taskId:n.taskId}}:{outcome:`accepted`,view:{executor:n.executor,metadata:n.metadata,status:`working`,taskId:n.taskId}}}case`start-turn`:return r.taskId===n.taskId?n.executor?.childSessionId!==void 0&&n.executor.childSessionId!==r.childSessionId?{outcome:`rejected`,reason:`Task child session "${r.childSessionId}" does not match "${n.executor.childSessionId}".`,view:n}:n.executor?.childSessionId===r.childSessionId&&n.executor.childTurnId===r.childTurnId?{outcome:`noop`,view:n}:{outcome:`accepted`,view:{...n,executor:{...n.executor,childSessionId:r.childSessionId,childTurnId:r.childTurnId}}}:{outcome:`rejected`,reason:`Task turn identity "${r.taskId}" does not match "${n.taskId}".`,view:n}}}function isValidInputRequestBatch(e){if(e.length===0)return!1;let n=e.map(readTaskInputRequestId);return n.every(e=>e!==void 0&&e.length>0)&&new Set(n).size===n.length}function sameUsage(e,t){return e===void 0||t===void 0?e===t:e?.cacheReadTokens===t.cacheReadTokens&&e.cacheWriteTokens===t.cacheWriteTokens&&e.inputTokens===t.inputTokens&&e.outputTokens===t.outputTokens}export{applyTaskTransition};

package/dist/src/tasks/types.d.ts

@@ -0,0 +1,295 @@
+import type { JsonValue } from "#shared/json.js";
+import type { SubagentAuthorizationEvent } from "#channel/types.js";
+/**
+ * Task lifecycle contract for `experimental.tasks`.
+ *
+ * A task is one durable unit of delegated work owned by a parent session.
+ * The durable task run is the single writer for lifecycle transitions
+ * (see `#execution/tasks/child/workflow.js`); every other path submits
+ * commands and reads views. This module is dependency-free on
+ * purpose: it is bundled into workflow bodies, which reject Node.js
+ * builtins and heavyweight validators.
+ */
+/**
+ * Task lifecycle status.
+ *
+ * `completed`, `failed`, and `cancelled` are terminal and final.
+ * `input_required` is not terminal but is ready for parent action; the
+ * child must wake its parent rather than deadlock while waiting for input.
+ */
+export type TaskStatus = "working" | "input_required" | "completed" | "failed" | "cancelled";
+/**
+ * Immutable identity of the delegated work behind a task.
+ *
+ * `agentId` is parent-controlled and exists before the child acknowledges its
+ * private address, so the durable task can bind to persistent identity before
+ * the dispatch side effect runs.
+ */
+export interface TaskMetadata {
+    /** Stable model-visible identity of the persistent child session. */
+    readonly agentId: string;
+    readonly kind: "subagent";
+    readonly mode: "local" | "remote";
+    /** Authored subagent name the parent dispatched. */
+    readonly name: string;
+}
+/** Private executor state retained for cancellation and address reconciliation. */
+export interface TaskExecutorState {
+    readonly childSessionId?: string;
+    readonly childTurnId?: string;
+    readonly lifecycle?: "parked" | "terminal";
+}
+/**
+ * Terminal task output. Failure is the state (`failed`); the `error`
+ * output is its consequence — a `failed` task always carries one.
+ * This intentionally diverges from MCP, which reserves `failed` for
+ * protocol-level errors.
+ */
+export type TaskOutput = {
+    readonly type: "result";
+    readonly data: JsonValue;
+} | {
+    readonly type: "error";
+    readonly data: JsonValue;
+};
+/**
+ * One outstanding request forwarded from a blocked child. Carried
+ * opaquely: the task layer routes the batch, the input contract owns
+ * its shape.
+ */
+export type TaskInputRequest = JsonValue;
+/**
+ * Provider token usage a child turn reported. Structural on purpose: it
+ * mirrors `TokenUsage` (#shared/token-usage.js) without importing its
+ * zod-backed module into a workflow-bundled file.
+ */
+export interface TaskUsage {
+    readonly cacheReadTokens: number;
+    readonly cacheWriteTokens: number;
+    readonly inputTokens: number;
+    readonly outputTokens: number;
+}
+/**
+ * Validates one wire-carried usage value into {@link TaskUsage}.
+ * Anything malformed is dropped rather than rejected: retention is
+ * best-effort and must never fail a lifecycle transition.
+ */
+export declare function readTaskUsage(value: unknown): TaskUsage | undefined;
+/**
+ * One human answer to an outstanding request. Structural on purpose: it
+ * mirrors the input contract's `InputResponse` without importing its
+ * zod-backed module into a workflow-bundled file.
+ */
+export interface TaskInputResponse {
+    readonly optionId?: string;
+    readonly requestId: string;
+    readonly text?: string;
+}
+/** Stable task blocker id shared by one authorization attempt's events. */
+export declare function taskAuthorizationRequestId(event: SubagentAuthorizationEvent): string;
+/** Reads the `requestId` of one opaque outstanding request. */
+export declare function readTaskInputRequestId(request: TaskInputRequest): string | undefined;
+/** Fields shared by every durable task view. */
+interface TaskViewBase {
+    readonly taskId: string;
+    readonly metadata: TaskMetadata;
+    /** Private executor state; deliberately excluded from model-visible JSON. */
+    readonly executor?: TaskExecutorState;
+    /**
+     * Provider usage the child reported at settlement; present when the
+     * terminal command carried it. Retained for later accounting only —
+     * budgets stay best-effort until a reservation model lands — and
+     * deliberately excluded from model-visible task views (tasks/json.ts).
+     */
+    readonly usage?: TaskUsage;
+}
+/**
+ * Full durable task view discriminated by lifecycle status.
+ *
+ * The task run appends one per accepted command; readers always observe a
+ * complete view, never a delta. A view never contains routing credentials,
+ * continuation tokens, or authorization capabilities.
+ *
+ * Completed and failed tasks carry their corresponding output, cancelled
+ * tasks carry no output, and only input-required tasks carry requests.
+ */
+export type TaskView = TaskViewBase & ({
+    readonly status: "working";
+    readonly inputRequests?: never;
+    readonly lastOutput?: never;
+} | {
+    readonly status: "input_required";
+    readonly inputRequests: readonly TaskInputRequest[];
+    readonly lastOutput?: never;
+} | {
+    readonly status: "completed";
+    readonly inputRequests?: never;
+    readonly lastOutput: Extract<TaskOutput, {
+        type: "result";
+    }>;
+} | {
+    readonly status: "failed";
+    readonly inputRequests?: never;
+    readonly lastOutput: Extract<TaskOutput, {
+        type: "error";
+    }>;
+} | {
+    readonly status: "cancelled";
+    readonly inputRequests?: never;
+    readonly lastOutput?: never;
+});
+/** Commands accepted by the durable task run's transition function. */
+export type TaskCommand = {
+    readonly kind: "complete";
+    readonly data: JsonValue;
+    readonly lifecycle?: "parked" | "terminal";
+    readonly usage?: TaskUsage;
+} | {
+    readonly kind: "fail";
+    readonly data: JsonValue;
+    readonly lifecycle?: "parked" | "terminal";
+    readonly usage?: TaskUsage;
+}
+/** Terminal dispatch rejection for a task that was never indexed by its parent. */
+ | {
+    readonly kind: "reject-dispatch";
+    readonly data: JsonValue;
+    readonly lifecycle?: never;
+    readonly usage?: never;
+} | {
+    readonly kind: "cancel";
+    readonly lifecycle?: "parked" | "terminal";
+    readonly usage?: TaskUsage;
+}
+/** Retains a late executor settlement without changing task terminal status. */
+ | {
+    readonly kind: "settle-executor";
+    readonly usage?: TaskUsage;
+} | {
+    readonly kind: "require-authorization";
+    readonly requestId: string;
+} | {
+    readonly kind: "require-input";
+    readonly inputRequests: readonly TaskInputRequest[];
+} | {
+    readonly kind: "ready";
+}
+/**
+ * Clears the listed requests from the outstanding batch. Bound to
+ * ids rather than unbound like the former `resume`, so an answer can
+ * only ever release the batch it was written against.
+ */
+ | {
+    readonly kind: "answered";
+    readonly requestIds: readonly string[];
+} | {
+    readonly kind: "start-turn";
+    readonly childSessionId: string;
+    readonly childTurnId: string;
+    readonly taskId: string;
+};
+/** Hook payload envelope commanding a durable task run. */
+export interface TaskCommandHookPayload {
+    readonly kind: "task-command";
+    readonly command: TaskCommand;
+}
+/**
+ * Structural shapes of the child wire payloads a task run consumes.
+ *
+ * These mirror the existing parent-notification contracts (the local
+ * `notifyDelegatedParentStep`, the subagent adapter's HITL forwarding,
+ * and the remote callback route) without importing their zod-backed
+ * modules: this file is bundled into workflow bodies. The wire itself
+ * is unchanged — delegated dispatch only points it at the task run's
+ * hook instead of the parent turn's inbox.
+ */
+export interface TaskInboundChildResult {
+    readonly kind: "runtime-action-result";
+    readonly results: readonly {
+        readonly isError?: boolean;
+        readonly outcome?: {
+            readonly kind: "parked" | "terminal";
+            readonly result: {
+                readonly kind: "succeeded";
+                readonly output: JsonValue;
+            } | {
+                readonly error: JsonValue;
+                readonly kind: "failed";
+            } | {
+                readonly kind: "cancelled";
+            };
+            /**
+             * Provider usage this turn added. Retained on the terminal task
+             * view ({@link TaskView.usage}); folding it into parent
+             * budgets is deferred until a reservation model lands.
+             */
+            readonly usageDelta?: unknown;
+        };
+        readonly output: JsonValue;
+    }[];
+}
+/**
+ * Arrives when the delegated child emits `input.requested`. After dispatch is
+ * acknowledged, the task run exposes the batch in an `input_required`
+ * view and forwards the request to the parent session.
+ */
+export interface TaskInboundInputRequest {
+    readonly callId: string;
+    readonly childContinuationToken: string;
+    readonly childSessionId: string;
+    readonly kind: "subagent-input-request";
+    readonly event: {
+        readonly requests: readonly TaskInputRequest[];
+        readonly sequence: number;
+        readonly stepIndex: number;
+        readonly turnId: string;
+    };
+    readonly subagentName: string;
+}
+/**
+ * Arrives when a delegated child turn starts and its session and turn ids are
+ * known. The task run records those ids for executor addressing; this payload
+ * does not itself make the task ready or wake the parent.
+ */
+export interface TaskInboundTurnStarted {
+    readonly childSessionId: string;
+    readonly childTurnId: string;
+    readonly kind: "turn-started";
+    readonly taskId: string;
+}
+/**
+ * Arrives when the delegated child emits `authorization.required` or
+ * `authorization.completed`. The former exposes an authorization blocker in
+ * the task view; the latter clears it. The event is forwarded separately
+ * to the parent and is never copied into the view.
+ */
+export interface TaskInboundAuthorizationEvent {
+    readonly callId: string;
+    readonly childSessionId: string;
+    readonly kind: "authorization-event";
+    readonly event: SubagentAuthorizationEvent;
+    readonly subagentName: string;
+}
+/**
+ * Human answers routed to the task run rather than straight to the
+ * child. The run owns both the delivery and the state change, so the
+ * batch it clears is exactly the batch it forwarded — the parent can no
+ * longer unblock the child while the run still believes it is blocked.
+ */
+export interface TaskInboundAnswerInput {
+    readonly auth?: unknown;
+    readonly childContinuationToken: string;
+    readonly childResponseUrl?: string;
+    readonly inputResponses: readonly TaskInputResponse[];
+    readonly kind: "input-response";
+    readonly taskId: string;
+}
+/** Everything a task run's inbound continuation hook may receive. */
+export type TaskRunInboundPayload = TaskCommandHookPayload | TaskInboundChildResult | TaskInboundInputRequest | TaskInboundTurnStarted | TaskInboundAuthorizationEvent | TaskInboundAnswerInput;
+/** Namespaced run stream carrying appended `TaskView` records. */
+export declare const TASK_VIEW_STREAM_NAMESPACE = "eve.task";
+/** True when the status can never change again. */
+export declare function isTerminalTaskStatus(status: TaskStatus): boolean;
+/** True when a transition into this status should wake the parent. */
+export declare function isReadyTaskStatus(status: TaskStatus): boolean;
+export {};

package/dist/src/tasks/types.js

@@ -0,0 +1 @@
+function readTaskUsage(e){if(typeof e!=`object`||!e||Array.isArray(e))return;let t=readUsageAxis(e,`cacheReadTokens`),n=readUsageAxis(e,`cacheWriteTokens`),r=readUsageAxis(e,`inputTokens`),i=readUsageAxis(e,`outputTokens`);if(!(t===void 0||n===void 0||r===void 0||i===void 0))return{cacheReadTokens:t,cacheWriteTokens:n,inputTokens:r,outputTokens:i}}function readUsageAxis(e,t){let n=Reflect.get(e,t);return typeof n==`number`&&Number.isFinite(n)&&n>=0?n:void 0}const TASK_AUTHORIZATION_REQUEST_ID_PREFIX=`task:authorization`;function taskAuthorizationRequestId(t){return t.type===`approval.candidate`||t.type===`approval.settled`?`${TASK_AUTHORIZATION_REQUEST_ID_PREFIX}:${t.data.requestId}`:`${TASK_AUTHORIZATION_REQUEST_ID_PREFIX}:${t.data.attemptId??t.data.name}`}function readTaskInputRequestId(e){if(typeof e!=`object`||!e||Array.isArray(e))return;let t=Reflect.get(e,`requestId`);return typeof t==`string`?t:void 0}const TASK_VIEW_STREAM_NAMESPACE=`eve.task`;function isTerminalTaskStatus(e){return e===`completed`||e===`failed`||e===`cancelled`}function isReadyTaskStatus(e){return e===`input_required`||isTerminalTaskStatus(e)}export{TASK_VIEW_STREAM_NAMESPACE,isReadyTaskStatus,isTerminalTaskStatus,readTaskInputRequestId,readTaskUsage,taskAuthorizationRequestId};

package/dist/src/tasks/wire.d.ts

@@ -0,0 +1,26 @@
+import type { TaskCommand, TaskRunInboundPayload } from "#tasks/types.js";
+/**
+ * Translates one inbound hook payload into a lifecycle command.
+ *
+ * The child wire is unchanged by `experimental.tasks`; delegated
+ * dispatch hands children the task run's hook token, so the payloads
+ * that used to resume the parent turn arrive here instead:
+ *
+ * - a settled child turn (local notification or remote callback)
+ *   carries an explicit outcome — its result status decides
+ *   `complete`, `fail`, or `cancel`;
+ * - a forwarded HITL batch marks the task `input_required` with the
+ *   outstanding requests;
+ * - `authorization.required` also blocks the task (the child cannot
+ *   proceed without the parent's user) under a reserved request id, and
+ *   `authorization.completed` clears exactly that id. Authorization
+ *   payloads never enter the view — only the fact that the child is
+ *   blocked does.
+ *
+ * `input-response` is deliberately absent: the run must forward the
+ * answers to the child before it may record them, so it builds that
+ * command itself rather than translating one here.
+ *
+ * Returns `undefined` for unrecognized payloads, which the run ignores.
+ */
+export declare function translateTaskInboundPayload(payload: TaskRunInboundPayload): TaskCommand | undefined;

package/dist/src/tasks/wire.js

@@ -0,0 +1 @@
+import{readTaskUsage,taskAuthorizationRequestId}from"#tasks/types.js";function translateTaskInboundPayload(n){switch(n.kind){case`task-command`:return n.command;case`runtime-action-result`:{let t=n.results[0];if(t===void 0)return;if(t.outcome!==void 0){let n=readTaskUsage(t.outcome.usageDelta);switch(t.outcome.result.kind){case`succeeded`:return withUsage({data:t.output,kind:`complete`,lifecycle:t.outcome.kind},n);case`failed`:return withUsage({data:t.output,kind:`fail`,lifecycle:t.outcome.kind},n);case`cancelled`:return withUsage({kind:`cancel`,lifecycle:t.outcome.kind},n)}}return}case`subagent-input-request`:return{inputRequests:n.event.requests,kind:`require-input`};case`turn-started`:return{childSessionId:n.childSessionId,childTurnId:n.childTurnId,kind:`start-turn`,taskId:n.taskId};case`authorization-event`:{let e=taskAuthorizationRequestId(n.event);return n.event.type===`authorization.required`?{kind:`require-authorization`,requestId:e}:{kind:`answered`,requestIds:[e]}}default:return}}function withUsage(e,t){return t===void 0?e:{...e,usage:t}}export{translateTaskInboundPayload};

package/dist/src/tracing/install-instrumentation-runtime.d.ts

@@ -1,6 +1,6 @@
 import { type InstrumentationProviderDefinition } from "#harness/instrumentation/lifecycle.js";
 import { type InstrumentationRuntime } from "#harness/instrumentation/runtime.js";
-import type { CollectedOtel } from "#tracing/otel-declaration.js";
+import type { CollectedOtel, RuntimeContextResolver } from "#tracing/otel-declaration.js";
 /**
  * Installs the process instrumentation runtime around a collected pipeline.
  *
@@ -15,5 +15,6 @@ export declare function installInstrumentationRuntime(input: {
     readonly collected: CollectedOtel;
     readonly frameworkVersion: string;
     readonly providers: readonly InstrumentationProviderDefinition[];
+    readonly runtimeContextResolvers?: readonly RuntimeContextResolver[];
     readonly serviceName: string;
 }): InstrumentationRuntime;

package/dist/src/tracing/install-instrumentation-runtime.js

@@ -1 +1 @@
-import{createLogger,formatError}from"#internal/logging.js";import{ContextAgentTraceStateStore}from"#tracing/agent-trace-context-store.js";import{registerInstrumentationRuntime}from"#harness/instrumentation/runtime.js";import{trace}from"#compiled/@opentelemetry/api/index.js";import{createInstrumentationHooks}from"#harness/instrumentation/lifecycle.js";import{hasSessionRelease}from"#tracing/local-traces.js";import{createAgentOtelInstrumentation}from"#tracing/agent-otel-provider.js";import{registerOtelPipeline}from"#tracing/otel-registration.js";const log=createLogger(`tracing.install-instrumentation-runtime`);function installInstrumentationRuntime(e){let t=[],a=[],o,s,c,runInContext=(e,t)=>t();if(e.collected.declared){o=registerOtelPipeline({pipeline:e.collected.pipeline,serviceName:e.serviceName});let r=createAgentOtelInstrumentation({frameworkVersion:e.frameworkVersion,idGenerator:o.idGenerator,recordInputs:e.collected.settings.recordInputs,recordOutputs:e.collected.settings.recordOutputs,stateStore:new ContextAgentTraceStateStore,tracer:trace.getTracer(`eve.agent`,e.frameworkVersion)});t.push({...r.hook,stateNamespace:`internal:otel`}),s=r.prepareSessionTrace,c=r.prepareTurnTrace,runInContext=r.runInContext;let i=e.collected.pipeline.spanProcessors.filter(isSpanProcessor).filter(hasSessionRelease);i.length>0&&a.push(sessionReleaseProvider(i))}let l=[...t,...e.providers,...a],u;return registerInstrumentationRuntime({forceFlush:()=>settleAll([...o===void 0?[]:[o.forceFlush],...l.map(e=>()=>e.flush?.())]),hooks:createInstrumentationHooks({parallel:e.providers,serialAfter:a,serialBefore:t}),otelSettings:e.collected.declared?e.collected.settings:void 0,prepareSessionTrace:s,prepareTurnTrace:c,runInContext,shutdown:()=>(u??=settleAll([...o===void 0?[]:[o.shutdown],...l.map(e=>()=>e.shutdown?.())]),u)})}function isSpanProcessor(e){return e!==`auto`}function sessionReleaseProvider(e){let release=async t=>{await Promise.all(e.map(e=>e.releaseSession(t.sessionId)))};return{events:{"session.completed":release,"session.failed":release},name:`eve.session-release`,stateNamespace:`internal:session-release`}}async function settleAll(e){let n=await Promise.allSettled(e.map(async e=>e()));for(let e of n)e.status===`rejected`&&log.warn(`instrumentation drain failed`,{error:formatError(e.reason)})}export{installInstrumentationRuntime};
+import{createLogger,formatError}from"#internal/logging.js";import{ContextAgentTraceStateStore}from"#tracing/agent-trace-context-store.js";import{registerInstrumentationRuntime}from"#harness/instrumentation/runtime.js";import{trace}from"#compiled/@opentelemetry/api/index.js";import{createInstrumentationHooks}from"#harness/instrumentation/lifecycle.js";import{hasSessionRelease}from"#tracing/local-traces.js";import{createAgentOtelInstrumentation}from"#tracing/agent-otel-provider.js";import{registerOtelPipeline}from"#tracing/otel-registration.js";const log=createLogger(`tracing.install-instrumentation-runtime`);function installInstrumentationRuntime(e){let t=[],a=[],o,s,c,runInContext=(e,t)=>t();if(e.collected.declared){o=registerOtelPipeline({pipeline:e.collected.pipeline,serviceName:e.serviceName});let r=createAgentOtelInstrumentation({frameworkVersion:e.frameworkVersion,idGenerator:o.idGenerator,recordInputs:e.collected.settings.recordInputs,recordOutputs:e.collected.settings.recordOutputs,stateStore:new ContextAgentTraceStateStore,tracer:trace.getTracer(`eve.agent`,e.frameworkVersion)});t.push({...r.hook,stateNamespace:`internal:otel`}),s=r.prepareSessionTrace,c=r.prepareTurnTrace,runInContext=r.runInContext;let i=e.collected.pipeline.spanProcessors.filter(isSpanProcessor).filter(hasSessionRelease);i.length>0&&a.push(sessionReleaseProvider(i))}let l=[...t,...e.providers,...a],u;return registerInstrumentationRuntime({forceFlush:()=>settleAll([...o===void 0?[]:[o.forceFlush],...l.map(e=>()=>e.flush?.())]),hooks:createInstrumentationHooks({parallel:e.providers,serialAfter:a,serialBefore:t}),otelSettings:e.collected.declared?e.collected.settings:void 0,prepareSessionTrace:s,prepareTurnTrace:c,runtimeContextResolvers:e.runtimeContextResolvers,runInContext,shutdown:()=>(u??=settleAll([...o===void 0?[]:[o.shutdown],...l.map(e=>()=>e.shutdown?.())]),u)})}function isSpanProcessor(e){return e!==`auto`}function sessionReleaseProvider(e){let release=async t=>{await Promise.all(e.map(e=>e.releaseSession(t.sessionId)))};return{events:{"session.completed":release,"session.failed":release},name:`eve.session-release`,stateNamespace:`internal:session-release`}}async function settleAll(e){let n=await Promise.allSettled(e.map(async e=>e()));for(let e of n)e.status===`rejected`&&log.warn(`instrumentation drain failed`,{error:formatError(e.reason)})}export{installInstrumentationRuntime};

package/dist/src/tracing/otel-declaration.d.ts

@@ -1,5 +1,7 @@
 import type { PropagatorOrName, SamplerOrName, SpanExporter, SpanProcessor, SpanProcessorOrName } from "#compiled/@vercel/otel/index.js";
 import { type InstrumentationProvider } from "#public/instrumentation/provider.js";
+import type { InstrumentationRuntimeContextInput } from "#public/instrumentation/index.js";
+import type { JsonObject } from "#shared/json.js";
 import type { ResolvedContentOptions } from "#tracing/content-attributes.js";
 /**
  * The process-wide OpenTelemetry settings, declared by `otel()`.
@@ -8,9 +10,11 @@ import type { ResolvedContentOptions } from "#tracing/content-attributes.js";
  * one tracer provider, so it has one resource, one sampler, and one propagator
  * set. Destinations are the plural half and live in `otelIntegration()`.
  *
- * `contextManager` and `instrumentations` are deliberately absent: eve's span
- * nesting depends on the former, and the latter cannot reach anything eve
- * imported before setup ran.
+ * `contextManager` is deliberately absent: eve's span nesting depends on it.
+ * `instrumentations` is accepted so providers can opt into Node auto-
+ * instrumentations (e.g. `@opentelemetry/auto-instrumentations-node`); the
+ * packages patch modules eve already imported, so their effects are limited
+ * to code loaded after registration.
  */
 export interface OtelOptions {
     /**
@@ -38,6 +42,15 @@ export interface OtelOptions {
     readonly sampler?: SamplerOrName;
     /** Composed into one propagator. All inject; the first to extract wins. */
     readonly propagators?: readonly PropagatorOrName[];
+    /**
+     * OpenTelemetry `Instrumentation` instances passed through to
+     * `registerOTel`. Use them to patch Node.js built-ins (HTTP, DNS, fs, etc.)
+     * for automatic spans around outbound work. Disabled by default because eve
+     * already imports the model SDK before registration, so patching cannot
+     * reach it — but code loaded after registration (tool modules, connection
+     * clients) will be instrumented.
+     */
+    readonly instrumentations?: readonly unknown[];
 }
 /**
  * What one destination records of the conversation itself.
@@ -60,6 +73,17 @@ export interface OtelIntegrationOptions extends ContentOptions {
     readonly spanProcessors?: readonly SpanProcessor[];
     /** Wrapped in eve's batching processor and appended after `spanProcessors`. */
     readonly traceExporter?: SpanExporter;
+    /**
+     * Contributes runtime context that the AI SDK merges into telemetry spans
+     * for each model call. Child spans inherit the values, so a destination can
+     * stamp channel or auth identity onto every span in the turn.
+     *
+     * Synchronous: the harness collects from every destination before the model
+     * call, so a return that is not a plain object is dropped (warning-only).
+     * Keys beginning with `eve.` are reserved and dropped. Return `undefined`
+     * to contribute nothing.
+     */
+    readonly runtimeContext?: (input: InstrumentationRuntimeContextInput) => JsonObject | undefined;
 }
 declare const OTEL_DECLARATION: unique symbol;
 declare const OTEL_INTEGRATION: unique symbol;
@@ -76,6 +100,7 @@ export interface OtelIntegration extends InstrumentationProvider {
     readonly [OTEL_INTEGRATION]: true;
     /** Resolved from `ContentOptions`, so the union does not re-apply defaults. */
     readonly content: ResolvedContentOptions;
+    readonly runtimeContext?: (input: InstrumentationRuntimeContextInput) => JsonObject | undefined;
     readonly spanProcessors: readonly SpanProcessorOrName[];
 }
 /**
@@ -105,6 +130,7 @@ export declare function isOtelDeclaration(value: unknown): value is OtelDeclarat
 export declare function isOtelIntegration(value: unknown): value is OtelIntegration;
 /** The one pipeline a process can register. @internal */
 export interface OtelPipeline {
+    readonly instrumentations?: readonly unknown[];
     readonly propagators?: readonly PropagatorOrName[];
     readonly resource?: Readonly<Record<string, unknown>>;
     readonly sampler?: SamplerOrName;
@@ -123,6 +149,8 @@ export interface OtelHarnessSettings {
     readonly recordOutputs?: boolean;
 }
 /** @internal */
+export type RuntimeContextResolver = (input: InstrumentationRuntimeContextInput) => JsonObject | undefined;
+/** @internal */
 export interface CollectedOtel {
     /**
      * Whether anything declared OpenTelemetry. False means eve should leave the
@@ -130,6 +158,7 @@ export interface CollectedOtel {
      */
     readonly declared: boolean;
     readonly pipeline: OtelPipeline;
+    readonly runtimeContextResolvers: readonly RuntimeContextResolver[];
     readonly settings: OtelHarnessSettings;
 }
 /**

package/dist/src/tracing/otel-declaration.js

@@ -1 +1 @@
-import{PROVIDER}from"#public/instrumentation/provider.js";import{batchSpanProcessor}from"#tracing/batch-span-processor.js";import{contentFilteringProcessor}from"#tracing/content-span-processor.js";import{vercelRuntimeSpanProcessor}from"#tracing/vercel-runtime-span-exporter.js";const OTEL_DECLARATION=Symbol.for(`eve.instrumentation.otel`),OTEL_INTEGRATION=Symbol.for(`eve.instrumentation.otel-integration`);function otel(t={}){return{[OTEL_DECLARATION]:!0,[PROVIDER]:!0,options:t}}function otelIntegration(r={}){let i={recordInputs:r.recordInputs===!0,recordOutputs:r.recordOutputs===!0},o=r.spanProcessors??[],s=r.traceExporter===void 0?o:[...o,batchSpanProcessor(r.traceExporter)];return{[OTEL_INTEGRATION]:!0,[PROVIDER]:!0,content:i,spanProcessors:i.recordInputs&&i.recordOutputs?s:s.map(e=>contentFilteringProcessor(e,i))}}function agentRunsIntegration(t={}){let i=resolveContentOptions(t);return{[OTEL_INTEGRATION]:!0,[PROVIDER]:!0,content:i,spanProcessors:i.recordInputs&&i.recordOutputs?[`auto`]:[contentFilteringProcessor(vercelRuntimeSpanProcessor(),i)]}}function resolveContentOptions(e){return{recordInputs:e.recordInputs===!0,recordOutputs:e.recordOutputs===!0}}function isOtelDeclaration(e){return typeof e==`object`&&!!e&&e[OTEL_DECLARATION]===!0}function isOtelIntegration(e){return typeof e==`object`&&!!e&&e[OTEL_INTEGRATION]===!0}function collectOtelPipeline(e){let t=[],n,r=!1,i=!1,a=!1;for(let o of e){if(isOtelIntegration(o)){r=!0,i||=o.content.recordInputs,a||=o.content.recordOutputs,t.push(...o.spanProcessors);continue}if(isOtelDeclaration(o)){if(n!==void 0)throw Error("Instrumentation declares `otel()` more than once. One process has one OpenTelemetry tracer provider, so it has one resource, one sampler, and one propagator set — declare them in a single `otel()`.");r=!0,n=o}}let o=n?.options??{};return{declared:r,pipeline:{propagators:o.propagators,resource:o.resource,sampler:o.sampler,spanProcessors:t},settings:{functionId:o.functionId,recordInputs:i,recordOutputs:a,traceChannelRequests:o.traceChannelRequests===!0}}}export{agentRunsIntegration,collectOtelPipeline,isOtelDeclaration,isOtelIntegration,otel,otelIntegration,resolveContentOptions};
+import{PROVIDER}from"#public/instrumentation/provider.js";import{batchSpanProcessor}from"#tracing/batch-span-processor.js";import{contentFilteringProcessor}from"#tracing/content-span-processor.js";import{vercelRuntimeSpanProcessor}from"#tracing/vercel-runtime-span-exporter.js";const OTEL_DECLARATION=Symbol.for(`eve.instrumentation.otel`),OTEL_INTEGRATION=Symbol.for(`eve.instrumentation.otel-integration`);function otel(t={}){return{[OTEL_DECLARATION]:!0,[PROVIDER]:!0,options:t}}function otelIntegration(r={}){let i={recordInputs:r.recordInputs===!0,recordOutputs:r.recordOutputs===!0},o=r.spanProcessors??[],s=r.traceExporter===void 0?o:[...o,batchSpanProcessor(r.traceExporter)];return{[OTEL_INTEGRATION]:!0,[PROVIDER]:!0,content:i,runtimeContext:r.runtimeContext,spanProcessors:i.recordInputs&&i.recordOutputs?s:s.map(e=>contentFilteringProcessor(e,i))}}function agentRunsIntegration(t={}){let i=resolveContentOptions(t);return{[OTEL_INTEGRATION]:!0,[PROVIDER]:!0,content:i,spanProcessors:i.recordInputs&&i.recordOutputs?[`auto`]:[contentFilteringProcessor(vercelRuntimeSpanProcessor(),i)]}}function resolveContentOptions(e){return{recordInputs:e.recordInputs===!0,recordOutputs:e.recordOutputs===!0}}function isOtelDeclaration(e){return typeof e==`object`&&!!e&&e[OTEL_DECLARATION]===!0}function isOtelIntegration(e){return typeof e==`object`&&!!e&&e[OTEL_INTEGRATION]===!0}function collectOtelPipeline(e){let t=[],n=[],r,i=!1,a=!1,o=!1;for(let s of e){if(isOtelIntegration(s)){i=!0,a||=s.content.recordInputs,o||=s.content.recordOutputs,t.push(...s.spanProcessors),s.runtimeContext!==void 0&&n.push(s.runtimeContext);continue}if(isOtelDeclaration(s)){if(r!==void 0)throw Error("Instrumentation declares `otel()` more than once. One process has one OpenTelemetry tracer provider, so it has one resource, one sampler, and one propagator set — declare them in a single `otel()`.");i=!0,r=s}}let s=r?.options??{};return{declared:i,pipeline:{instrumentations:s.instrumentations,propagators:s.propagators,resource:s.resource,sampler:s.sampler,spanProcessors:t},runtimeContextResolvers:n,settings:{functionId:s.functionId,recordInputs:a,recordOutputs:o,traceChannelRequests:s.traceChannelRequests===!0}}}export{agentRunsIntegration,collectOtelPipeline,isOtelDeclaration,isOtelIntegration,otel,otelIntegration,resolveContentOptions};

package/dist/src/tracing/otel-registration.js

@@ -1 +1 @@
-import{context,propagation,trace}from"#compiled/@opentelemetry/api/index.js";import{registerOTel}from"#compiled/@vercel/otel/index.js";import{AgentSpanIdGenerator}from"#tracing/agent-span-id-generator.js";const REGISTRATION_SPAN_NAME=`eve.otel.registration`,REPLAY_DEDUPLICATION_LIMIT=1e5;var RegistrationMarkerPropagator=class{#e=!1;extract(e){return e}fields(){return[]}inject(){this.#e=!0}isInstalled(){return this.#e=!1,propagation.inject(context.active(),{},{set:()=>{}}),this.#e}},PrivateSpanFilteringProcessor=class{endedSpans=new Set;forwardedSpans=new Set;pendingByParent=new Map;processors;startedSpans=new Set;constructor(e){this.processors=e}async forceFlush(){await Promise.all(this.processors.map(e=>e.forceFlush()))}onEnd(e){if(isRegistrationSpan(e))return;let t=spanIdentity(e);if(t!==void 0){if(this.endedSpans.has(t))return;if(this.endedSpans.size>=REPLAY_DEDUPLICATION_LIMIT){let e=this.endedSpans.values().next().value;e!==void 0&&this.endedSpans.delete(e)}this.endedSpans.add(t)}let n=parentIdentity(e);if(n!==void 0&&this.startedSpans.has(n)&&!this.forwardedSpans.has(n)){let t=this.pendingByParent.get(n)??[];t.push(e),this.pendingByParent.set(n,t);return}this.forward(e,t)}onStart(e,t){if(isRegistrationSpan(e))return;let n=spanIdentity(e);n!==void 0&&addBounded(this.startedSpans,n);for(let n of this.processors)n.onStart(e,t)}async shutdown(){await Promise.all(this.processors.map(e=>e.shutdown()))}forward(e,t){for(let t of this.processors)t.onEnd(e);if(t===void 0)return;addBounded(this.forwardedSpans,t);let n=this.pendingByParent.get(t);if(n!==void 0){this.pendingByParent.delete(t);for(let e of n)this.forward(e,spanIdentity(e))}}};function registerOtelPipeline(e){let{pipeline:t}=e,n=new AgentSpanIdGenerator,i=new RegistrationMarkerPropagator,a={attributes:t.resource,autoDetectResources:!1,idGenerator:n,instrumentations:[],propagators:[...t.propagators??[`none`],i],serviceName:e.serviceName,spanProcessors:t.spanProcessors.map(e=>isSpanProcessor(e)?new PrivateSpanFilteringProcessor([e]):e)};registerOTel(t.sampler===void 0?a:{...a,traceSampler:t.sampler});let o=globalTracerUses(n),s=i.isInstalled();if((!o||!s)&&rollbackRegistration({ownsPropagator:s,ownsTracer:o}),!o)throw Error("eve could not register OpenTelemetry because another runtime already owns the global tracer provider. Remove the other `registerOTel` call, or move its exporters into eve's `otelIntegration({ spanProcessors: [...] })`.");if(!s)throw Error("eve could not register OpenTelemetry because another runtime already owns the global propagator. Remove the other global propagator registration and declare propagators through eve's `otel()` instead.");let c=runtimeTracerProvider();if(typeof c.forceFlush!=`function`||typeof c.shutdown!=`function`)throw rollbackRegistration({ownsPropagator:s,ownsTracer:o}),Error(`The registered OpenTelemetry tracer provider has no lifecycle methods.`);return{forceFlush:()=>c.forceFlush(),idGenerator:n,shutdown:()=>c.shutdown()}}function rollbackRegistration(e){if(e.ownsPropagator&&propagation.disable(),!e.ownsTracer)return;let r=runtimeTracerProvider();if(typeof r.shutdown==`function`)try{r.shutdown().catch(()=>{})}catch{}trace.disable()}function runtimeTracerProvider(){let e=trace.getTracerProvider();return e.getDelegate?.()??e}function globalTracerUses(e){let t=e.allocateSpanId();return e.withSpanId(t,()=>trace.getTracer(`eve.registration`).startSpan(REGISTRATION_SPAN_NAME)).spanContext().spanId===t}function isRegistrationSpan(e){return typeof e==`object`&&!!e&&`name`in e&&e.name===REGISTRATION_SPAN_NAME}function spanIdentity(e){if(typeof e!=`object`||!e||!(`spanContext`in e)||typeof e.spanContext!=`function`)return;let t=e.spanContext();return typeof t.traceId==`string`&&typeof t.spanId==`string`?`${t.traceId}:${t.spanId}`:void 0}function parentIdentity(e){if(typeof e!=`object`||!e||!(`parentSpanContext`in e))return;let t=e.parentSpanContext;return typeof t?.traceId==`string`&&typeof t.spanId==`string`?`${t.traceId}:${t.spanId}`:void 0}function addBounded(e,t){if(e.size>=REPLAY_DEDUPLICATION_LIMIT){let t=e.values().next().value;t!==void 0&&e.delete(t)}e.add(t)}function isSpanProcessor(e){return e!==`auto`}export{registerOtelPipeline};
+import{createRequire}from"node:module";import{context,propagation,trace}from"#compiled/@opentelemetry/api/index.js";import{registerOTel}from"#compiled/@vercel/otel/index.js";import{AgentSpanIdGenerator}from"#tracing/agent-span-id-generator.js";const REGISTRATION_SPAN_NAME=`eve.otel.registration`,REPLAY_DEDUPLICATION_LIMIT=1e5,require=createRequire(import.meta.url);var RegistrationMarkerPropagator=class{#e=!1;extract(e){return e}fields(){return[]}inject(){this.#e=!0}isInstalled(){return this.#e=!1,propagation.inject(context.active(),{},{set:()=>{}}),this.#e}},PrivateSpanFilteringProcessor=class{endedSpans=new Set;forwardedSpans=new Set;pendingByParent=new Map;processors;startedSpans=new Set;constructor(e){this.processors=e}async forceFlush(){await Promise.all(this.processors.map(e=>e.forceFlush()))}onEnd(e){if(isRegistrationSpan(e))return;let t=spanIdentity(e);if(t!==void 0){if(this.endedSpans.has(t))return;if(this.endedSpans.size>=REPLAY_DEDUPLICATION_LIMIT){let e=this.endedSpans.values().next().value;e!==void 0&&this.endedSpans.delete(e)}this.endedSpans.add(t)}let n=parentIdentity(e);if(n!==void 0&&this.startedSpans.has(n)&&!this.forwardedSpans.has(n)){let t=this.pendingByParent.get(n)??[];t.push(e),this.pendingByParent.set(n,t);return}this.forward(e,t)}onStart(e,t){if(isRegistrationSpan(e))return;let n=spanIdentity(e);n!==void 0&&addBounded(this.startedSpans,n);for(let n of this.processors)n.onStart(e,t)}async shutdown(){await Promise.all(this.processors.map(e=>e.shutdown()))}forward(e,t){for(let t of this.processors)t.onEnd(e);if(t===void 0)return;addBounded(this.forwardedSpans,t);let n=this.pendingByParent.get(t);if(n!==void 0){this.pendingByParent.delete(t);for(let e of n)this.forward(e,spanIdentity(e))}}};function registerOtelPipeline(e){let{pipeline:t}=e,n=captureOptionalPeerTracerProxy(),r=new AgentSpanIdGenerator,i=new RegistrationMarkerPropagator,a={attributes:t.resource,autoDetectResources:!1,idGenerator:r,instrumentations:t.instrumentations??[],propagators:[...t.propagators??[`none`],i],serviceName:e.serviceName,spanProcessors:t.spanProcessors.map(e=>isSpanProcessor(e)?new PrivateSpanFilteringProcessor([e]):e)};registerOTel(t.sampler===void 0?a:{...a,traceSampler:t.sampler});let o=globalTracerUses(r),s=i.isInstalled();if((!o||!s)&&rollbackRegistration({ownsPropagator:s,ownsTracer:o}),!o)throw Error("eve could not register OpenTelemetry because another runtime already owns the global tracer provider. Remove the other `registerOTel` call, or move its exporters into eve's `otelIntegration({ spanProcessors: [...] })`.");if(!s)throw Error("eve could not register OpenTelemetry because another runtime already owns the global propagator. Remove the other global propagator registration and declare propagators through eve's `otel()` instead.");let c=runtimeTracerProvider();if(typeof c.forceFlush!=`function`||typeof c.shutdown!=`function`)throw rollbackRegistration({ownsPropagator:s,ownsTracer:o}),Error(`The registered OpenTelemetry tracer provider has no lifecycle methods.`);return n?.setDelegate(c),{forceFlush:()=>c.forceFlush(),idGenerator:r,shutdown:()=>c.shutdown()}}function captureOptionalPeerTracerProxy(){try{let e=require("@opentelemetry/api"),t=e.trace.getTracerProvider();return t instanceof e.ProxyTracerProvider?t:void 0}catch{return}}function rollbackRegistration(e){if(e.ownsPropagator&&propagation.disable(),!e.ownsTracer)return;let t=runtimeTracerProvider();if(typeof t.shutdown==`function`)try{t.shutdown().catch(()=>{})}catch{}trace.disable()}function runtimeTracerProvider(){let e=trace.getTracerProvider();return e.getDelegate?.()??e}function globalTracerUses(e){let t=e.allocateSpanId();return e.withSpanId(t,()=>trace.getTracer(`eve.registration`).startSpan(REGISTRATION_SPAN_NAME)).spanContext().spanId===t}function isRegistrationSpan(e){return typeof e==`object`&&!!e&&`name`in e&&e.name===REGISTRATION_SPAN_NAME}function spanIdentity(e){if(typeof e!=`object`||!e||!(`spanContext`in e)||typeof e.spanContext!=`function`)return;let t=e.spanContext();return typeof t.traceId==`string`&&typeof t.spanId==`string`?`${t.traceId}:${t.spanId}`:void 0}function parentIdentity(e){if(typeof e!=`object`||!e||!(`parentSpanContext`in e))return;let t=e.parentSpanContext;return typeof t?.traceId==`string`&&typeof t.spanId==`string`?`${t.traceId}:${t.spanId}`:void 0}function addBounded(e,t){if(e.size>=REPLAY_DEDUPLICATION_LIMIT){let t=e.values().next().value;t!==void 0&&e.delete(t)}e.add(t)}function isSpanProcessor(e){return e!==`auto`}export{registerOtelPipeline};

package/dist/src/vue/index.js

@@ -1,3 +1,3 @@
-import { n as defaultMessageReducer, t as useEveAgent } from "../chunks/use-eve-agent-CnppTEFk.js";
+import { n as defaultMessageReducer, t as useEveAgent } from "../chunks/use-eve-agent-Dt8Y5QtW.js";
 
 export { defaultMessageReducer, useEveAgent };

package/dist/src/vue/use-eve-agent.d.ts

@@ -5,7 +5,7 @@ import type { EveAgentReducer } from "#client/reducer.js";
 import type { ClientSession } from "#client/session.js";
 import { type EveMessageData } from "#client/message-reducer.js";
 import type { MessageStreamEvent } from "#protocol/message.js";
-import type { ClientAuth, HeadersValue, RespondTurnOptions, SendTurnOptions, ClientSessionState } from "#client/types.js";
+import type { CancelSessionResult, ClientAuth, HeadersValue, RespondTurnOptions, SendTurnOptions, ClientSessionState } from "#client/types.js";
 export type { PrepareSend };
 /**
  * Lifecycle phase of a `useEveAgent` session: `"ready"` (idle), `"submitted"`
@@ -25,6 +25,8 @@ export type UseEveAgentSnapshot<TData> = EveAgentStoreSnapshot<TData>;
  * Reactive return value from `useEveAgent`.
  */
 export interface UseEveAgentReturn<TData> {
+    /** Request durable cancellation of the active turn while continuing to receive its events. */
+    readonly cancel: () => Promise<CancelSessionResult>;
     /** Projected state: the reducer folds every stream event into this value. */
     readonly data: ComputedRef<TData>;
     /** Last transport-level error, or `undefined` when healthy. */
@@ -41,8 +43,6 @@ export interface UseEveAgentReturn<TData> {
     readonly session: ComputedRef<ClientSessionState | undefined>;
     /** Lifecycle phase: `"ready"` (idle), `"submitted"` (request sent, awaiting first event), `"streaming"` (events arriving), or `"error"`. */
     readonly status: ComputedRef<UseEveAgentStatus>;
-    /** Abort the in-flight request. */
-    readonly stop: () => void;
 }
 /**
  * Configuration for creating or binding a Vue eve agent session.