eve 0.37.0 → 0.37.1

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).
 

package/docs/tools/human-in-the-loop.md

@@ -109,7 +109,9 @@ semantics.
 
 The run picks back up exactly where it parked. Because the pause is durable, nothing is held in memory while it waits — the process can restart and the parked turn survives.
 
-For approval requests, unrelated follow-up text does not deny the tool call — and it does not wait behind it either. The message runs as an ordinary turn while the approval stays pending and answerable; a later structured answer still resolves the original tool call. Text that exactly matches an option (like `approve`) still resolves the request directly.
+When a background subagent requests input, eve emits the same `input.requested` event on its parent session. Answering through that parent session routes the response directly to the blocked child without invoking the parent model.
+
+For approval requests, unrelated follow-up text does not deny the tool call. eve keeps the approval pending and holds that text until the approval is answered, then replays it as the next message in the session.
 
 See [Sessions, runs & streaming](/docs/concepts/sessions-runs-and-streaming) for the full event and resume contract that this builds on.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eve",
-  "version": "0.37.0",
+  "version": "0.37.1",
   "private": false,
   "description": "Filesystem-first framework for durable backend AI agents that run anywhere.",
   "keywords": [
@@ -231,6 +231,11 @@
       "import": "./dist/src/public/channels/auth.js",
       "default": "./dist/src/public/channels/auth.js"
     },
+    "./channels/mcp": {
+      "types": "./dist/src/public/channels/mcp.d.ts",
+      "import": "./dist/src/public/channels/mcp.js",
+      "default": "./dist/src/public/channels/mcp.js"
+    },
     "./channels/slack": {
       "types": "./dist/src/public/channels/slack/index.d.ts",
       "import": "./dist/src/public/channels/slack/index.js",
@@ -310,6 +315,7 @@
     "@chat-adapter/state-memory": "4.34.0",
     "@chat-adapter/twilio": "4.34.0",
     "@clack/core": "1.3.1",
+    "@modelcontextprotocol/server": "2.0.0",
     "@nuxt/kit": "^4.0.0",
     "@opentelemetry/context-async-hooks": "2.6.1",
     "@opentelemetry/core": "2.6.1",

package/dist/src/execution/route-proxied-deliver-step.js

@@ -1 +0,0 @@
-import{readDurableSession,replaceDurableSessionSnapshot}from"#execution/durable-session-store.js";import{resumeHook}from"#internal/workflow/runtime.js";import{retireProxyInputRequests}from"#harness/proxy-input-requests.js";import{coalesceDeliverPayloads}from"#execution/deliver-payloads.js";import{routeDeliverPayload}from"#execution/subagent-hitl-proxy.js";async function routeProxiedDeliverStep(o){"use step";let s=await readDurableSession(o.sessionState),c=!(`delivery`in o),l=`delivery`in o?o.delivery:{auth:o.auth,kind:`deliver`,payloads:[o.payload]},u=new Map((l.deliveryMetadata??[]).map(e=>[e.payloadIndex,e])),d=[],f=[],p=new Map,m;for(let[e,t]of l.payloads.entries()){let n=routeDeliverPayload({payload:t,state:s.state});m??=n.parentAction;let r=u.get(e);if(n.forSelf!==void 0){let e=d.length;d.push(n.forSelf),r!==void 0&&f.push({...r,payloadIndex:e})}for(let[e,t]of n.forChildren.entries()){let i=p.get(t.childContinuationToken)??{metadata:[],payloads:[],retireRequestIds:[]},a=i.payloads.length;i.payloads.push(t.payload),i.retireRequestIds.push(...t.retireRequestIds),r!==void 0&&n.forSelf===void 0&&e===0&&i.metadata.push({...r,payloadIndex:a}),p.set(t.childContinuationToken,i)}}for(let[e,t]of p)await resumeHook(e,{auth:l.auth,caller:l.caller,deliveryMetadata:t.metadata.length===0?void 0:t.metadata,kind:`deliver`,payloads:t.payloads,requestId:l.requestId,payload:coalesceDeliverPayloads(t.payloads)}),s=retireProxyInputRequests(s,t.retireRequestIds);let h=p.size===0?o.sessionState:replaceDurableSessionSnapshot({session:s,state:o.sessionState});return m===void 0?{kind:`continue`,remainder:d.length===0?void 0:c?coalesceDeliverPayloads(d):{...l,deliveryMetadata:f.length===0?void 0:f,payloads:d},sessionState:h}:{...m,sessionState:h}}export{routeProxiedDeliverStep};