eve 0.36.0 → 0.37.1

package/dist/src/setup/scaffold/create/web-template.js

@@ -4988,7 +4988,6 @@ const betterAuthSession: AuthFn<Request> = async (request) => {
   return {
     attributes,
     authenticator: "better-auth:vercel",
-    issuer: "https://vercel.com",
     principalId: session.user.id,
     principalType: "user",
   };

package/dist/src/shared/agent-definition.d.ts

@@ -180,6 +180,13 @@ export interface AgentExperimentalDefinition {
      * When unset, delegated children run as one-shot tasks.
      */
     readonly subagentPersistentSessions?: boolean;
+    /**
+     * Runs this agent's delegated subagent calls as durable background tasks.
+     * The originating tool call returns a task receipt immediately and the
+     * model manages the work through the `task_*` framework tools. Implies
+     * persistent-session children for subagent dispatch. Root agents only.
+     */
+    readonly tasks?: boolean;
     /**
      * Durable Workflow runtime configuration. Root agents may use this to select
      * the Workflow world backing sessions and runs.

package/dist/src/shared/sandbox-network-policy.d.ts

@@ -1,4 +1,4 @@
-import type * as Vercel from "#compiled/@vercel/sandbox/index.js";
+import type * as Vercel from "#compiled/@vercel/sandbox-stable/index.js";
 /**
  * Firewall network policy applied to a live sandbox session.
  *

package/dist/src/svelte/index.js

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

package/dist/src/svelte/use-eve-agent.js

@@ -1,3 +1,3 @@
-import { t as useEveAgent } from "../chunks/use-eve-agent-COmP-H8R.js";
+import { t as useEveAgent } from "../chunks/use-eve-agent-DbKUBhl-.js";
 
 export { useEveAgent };

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

@@ -0,0 +1,88 @@
+import { z } from "#compiled/zod/index.js";
+import type { JsonValue } from "#shared/json.js";
+import type { TaskView } from "#tasks/types.js";
+/** Model-visible task shape. Unlisted private fields are stripped by zod. */
+declare const taskViewJsonSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    metadata: z.ZodObject<{
+        agentId: z.ZodString;
+        kind: z.ZodLiteral<"subagent">;
+        mode: z.ZodEnum<{
+            local: "local";
+            remote: "remote";
+        }>;
+        name: z.ZodString;
+    }, z.core.$strip>;
+    taskId: z.ZodString;
+    status: z.ZodLiteral<"working">;
+}, z.core.$strip>, z.ZodObject<{
+    metadata: z.ZodObject<{
+        agentId: z.ZodString;
+        kind: z.ZodLiteral<"subagent">;
+        mode: z.ZodEnum<{
+            local: "local";
+            remote: "remote";
+        }>;
+        name: z.ZodString;
+    }, z.core.$strip>;
+    taskId: z.ZodString;
+    inputRequests: z.ZodReadonly<z.ZodArray<z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>;
+    status: z.ZodLiteral<"input_required">;
+}, z.core.$strip>, z.ZodObject<{
+    metadata: z.ZodObject<{
+        agentId: z.ZodString;
+        kind: z.ZodLiteral<"subagent">;
+        mode: z.ZodEnum<{
+            local: "local";
+            remote: "remote";
+        }>;
+        name: z.ZodString;
+    }, z.core.$strip>;
+    taskId: z.ZodString;
+    lastOutput: z.ZodObject<{
+        data: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+        type: z.ZodLiteral<"result">;
+    }, z.core.$strip>;
+    status: z.ZodLiteral<"completed">;
+}, z.core.$strip>, z.ZodObject<{
+    metadata: z.ZodObject<{
+        agentId: z.ZodString;
+        kind: z.ZodLiteral<"subagent">;
+        mode: z.ZodEnum<{
+            local: "local";
+            remote: "remote";
+        }>;
+        name: z.ZodString;
+    }, z.core.$strip>;
+    taskId: z.ZodString;
+    lastOutput: z.ZodObject<{
+        data: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
+        type: z.ZodLiteral<"error">;
+    }, z.core.$strip>;
+    status: z.ZodLiteral<"failed">;
+}, z.core.$strip>, z.ZodObject<{
+    metadata: z.ZodObject<{
+        agentId: z.ZodString;
+        kind: z.ZodLiteral<"subagent">;
+        mode: z.ZodEnum<{
+            local: "local";
+            remote: "remote";
+        }>;
+        name: z.ZodString;
+    }, z.core.$strip>;
+    taskId: z.ZodString;
+    status: z.ZodLiteral<"cancelled">;
+}, z.core.$strip>], "status">;
+/**
+ * Model-visible task view, inferred from {@link taskViewJsonSchema}.
+ *
+ * This is the public projection of `TaskView` (#tasks/types.js), not a
+ * replacement for it: the durable view additionally carries private
+ * `executor` and `usage`, and its module must stay zod-free because it is
+ * bundled into workflow bodies.
+ */
+type TaskViewJson = z.infer<typeof taskViewJsonSchema>;
+/** Projects a task view into the JSON value carried by tool results. */
+export declare function taskViewToJson(view: TaskView): TaskViewJson;
+/** Projects many views into one `{ tasks }` tool output. */
+export declare function taskViewsToJson(views: readonly TaskView[]): JsonValue;
+export {};

package/dist/src/tasks/json.js

@@ -0,0 +1 @@
+import{z}from"#compiled/zod/index.js";import{jsonValueSchema}from"#shared/json-schemas.js";const taskMetadataJsonSchema=z.object({agentId:z.string(),kind:z.literal(`subagent`),mode:z.enum([`local`,`remote`]),name:z.string()}),taskOutputJsonSchema=z.object({data:jsonValueSchema,type:z.enum([`result`,`error`])}),taskViewJsonBaseShape={metadata:taskMetadataJsonSchema,taskId:z.string()},taskViewJsonSchema=z.discriminatedUnion(`status`,[z.object({...taskViewJsonBaseShape,status:z.literal(`working`)}),z.object({...taskViewJsonBaseShape,inputRequests:z.array(jsonValueSchema).readonly(),status:z.literal(`input_required`)}),z.object({...taskViewJsonBaseShape,lastOutput:taskOutputJsonSchema.extend({type:z.literal(`result`)}),status:z.literal(`completed`)}),z.object({...taskViewJsonBaseShape,lastOutput:taskOutputJsonSchema.extend({type:z.literal(`error`)}),status:z.literal(`failed`)}),z.object({...taskViewJsonBaseShape,status:z.literal(`cancelled`)})]);function taskViewToJson(e){return taskViewJsonSchema.parse(e)}function taskViewsToJson(e){return{tasks:e.map(e=>taskViewToJson(e))}}export{taskViewToJson,taskViewsToJson};

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/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-Bi5fRxcZ.js";
 
 export { defaultMessageReducer, useEveAgent };

package/dist/src/vue/use-eve-agent.js

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

package/docs/channels/eve.mdx

@@ -45,6 +45,20 @@ curl -X POST https://<deployment>/eve/v1/session \
 # {"ok":true,"sessionId":"wrun_A","status":"accepted"}
 ```
 
+Authenticated callers that may retry a create request can pass their own `operationId` for
+create-once semantics. The same operation under the same authenticated principal returns the
+active session it already created instead of dispatching the input again. The first accepted
+payload wins; retries with different input still return that first session. Anonymous callers
+cannot use `operationId`, and operation ownership expires when the session is no longer resumable.
+
+```bash
+curl -X POST https://<deployment>/eve/v1/session \
+  -H "Authorization: Bearer <token>" \
+  -H "Content-Type: application/json" \
+  -d '{"message":"What is the weather in Paris?","operationId":"order-4213-research"}'
+# {"ok":true,"sessionId":"wrun_A","status":"accepted"} — retries return the same sessionId
+```
+
 The first request requires `message`. A follow-up request accepts exactly one of
 `message` or `inputResponses`; use the latter to answer a pending HITL request:
 

package/docs/guides/client/streaming.mdx

@@ -126,7 +126,7 @@ If you support refresh while an authorization prompt is pending, keep the sessio
 
 ## Reconnection
 
-HTTP connections can end before a run does. The client reconnects from the number of events already consumed, so long turns continue without replaying events. It stops at a turn boundary, when aborted, or when the stream can no longer make progress.
+HTTP connections can end before a run does. The client reconnects from the number of events already consumed, so long turns continue without replaying events. By default, a turn response keeps reconnecting until it reaches a turn boundary or is aborted, including while the turn is paused for authorization. A manually opened `session.stream()` eventually stops after repeated empty streams when it can no longer make progress.
 
 If your consumer persists events, key on `event.meta.id`. It is stable across reconnects and rewinds, so an overlapping replay is safe to ingest twice. See [the event envelope](../../concepts/sessions-runs-and-streaming#the-event-envelope).