eve 0.50.0 → 0.51.0

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

@@ -1,87 +1,16 @@
-import type { AgentAddress, AgentIdentity } from "#harness/handles/store.js";
+import type { SubagentAuthorizationEvent, SubagentAuthorizationEventHookPayload } from "#channel/types.js";
+import type { WorkflowToolAgentRequest } from "#execution/tools/workflow/messages.js";
 import { type JsonValue } from "#shared/json.js";
 import type { TaskExecutorBinding } from "#tools/task.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.
- */
+/** Durable lifecycle status for one unit of background work. */
 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.
- */
+/** Executor-neutral identity shown for one task. */
 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;
-}
-export type SubagentTaskMetadata = TaskMetadata;
-/** Executor-neutral metadata retained by a non-subagent durable task. */
-export interface BackgroundTaskMetadata {
     readonly kind: string;
     readonly name: string;
+    readonly [key: string]: JsonValue | undefined;
 }
-export type DurableTaskMetadata = BackgroundTaskMetadata | TaskMetadata;
-export declare function createSubagentTaskMetadata(metadata: Omit<SubagentTaskMetadata, "kind" | "name"> & {
-    readonly name: string;
-}): SubagentTaskMetadata;
-export declare function readSubagentTaskMetadata(task: {
-    readonly executor?: TaskExecutorBinding | TaskExecutorState;
-    readonly metadata: DurableTaskMetadata;
-}): SubagentTaskMetadata | undefined;
-/**
- * Durable subagent executor binding payload: the child's stable identity and
- * private delivery address, copied from the parent's agent handle store at
- * delegation time. Every field derives deterministically from the
- * originating call (operation-hashed id, dispatch-chosen continuation
- * token), so a replayed delegation produces a deep-equal binding — the
- * equality the task run's `bind` replay check compares.
- */
-export interface SubagentExecutorData {
-    readonly address: AgentAddress;
-    readonly identity: AgentIdentity;
-}
-export declare function createSubagentExecutorBinding(executor: SubagentExecutorData): TaskExecutorBinding;
-export declare function readSubagentExecutor(executor: TaskExecutorBinding | TaskExecutorState | undefined): SubagentExecutorData | undefined;
-export declare function sameTaskMetadata(left: DurableTaskMetadata, right: DurableTaskMetadata): boolean;
-/** Private executor state retained for cancellation and address reconciliation. */
-export interface TaskExecutorState {
-    /** Write-once executor address recorded by the `bind` command. */
-    readonly binding?: TaskExecutorBinding;
-    readonly childSessionId?: string;
-    readonly childTurnId?: string;
-    /**
-     * Child-session verdict from the last settled turn: `parked` survived
-     * and can take another delivery, `terminal` ended with the turn.
-     */
-    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 declare function sameTaskMetadata(left: TaskMetadata, right: TaskMetadata): boolean;
 export type TaskOutput = {
     readonly type: "result";
     readonly data: JsonValue;
@@ -89,67 +18,28 @@ export type TaskOutput = {
     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.
- */
+/** An outstanding request carried opaquely by the task lifecycle. */
 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.
- */
+/** Reads valid provider usage without making task settlement depend on it. */
 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. */
+/** Reads the request identity from one opaque request. */
 export declare function readTaskInputRequestId(request: TaskInputRequest): string | undefined;
-/** Fields shared by every durable task view. */
 interface TaskViewBase {
     readonly taskId: string;
-    readonly metadata: DurableTaskMetadata;
-    /** 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 metadata: TaskMetadata;
+    /** Private executor state, excluded from model-visible JSON. */
+    readonly executor?: {
+        readonly binding?: TaskExecutorBinding;
+    };
+    /** Retained for accounting, excluded from model-visible JSON. */
     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;
@@ -175,171 +65,103 @@ export type TaskView = TaskViewBase & ({
     readonly inputRequests?: never;
     readonly lastOutput?: never;
 });
-/** Commands accepted by the durable task run's transition function. */
+/** Executor-neutral commands accepted by the durable task run. */
 export type TaskCommand = {
     readonly executor: TaskExecutorBinding;
     readonly kind: "bind";
 } | {
     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;
-}
-/** Intermediate progress sent by a running child to its parent agent. */
+/** Intermediate progress reported by an executor. */
 export interface TaskInboundUpdate {
     readonly callId: string;
-    /** Executor-neutral monotonic index within {@link updateEpoch}. */
     readonly updateIndex: number;
-    /** Executor-neutral epoch id used with {@link updateIndex} for update dedupe. */
     readonly updateEpoch: string;
     readonly kind: "task-update";
     readonly message: 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.
- */
+/** One workflow-executor request bound to its private answer hook. */
+export interface TaskInboundInputRequest {
+    readonly kind: "task-input-request";
+    readonly replyTo: string;
+    readonly requests: readonly TaskInputRequest[];
+    readonly sequence: number;
+    readonly stepIndex: number;
+    readonly turnId: string;
+}
+/** One human answer routed through the task that owns the blocked executor. */
 export interface TaskInboundAnswerInput {
     readonly auth?: unknown;
     readonly childContinuationToken: string;
     readonly childResponseUrl?: string;
-    readonly inputResponses: readonly TaskInputResponse[];
+    readonly inputResponses: readonly {
+        readonly optionId?: string;
+        readonly requestId: string;
+        readonly text?: string;
+    }[];
     readonly kind: "input-response";
     readonly taskId: string;
 }
-/** Everything a task run's inbound continuation hook may receive. */
-export type TaskRunInboundPayload = TaskCommandHookPayload | TaskInboundChildResult | TaskInboundInputRequest | TaskInboundTurnStarted | TaskInboundUpdate | TaskInboundAuthorizationEvent | TaskInboundAnswerInput;
-/** Namespaced run stream carrying appended `TaskView` records. */
+export type TaskRunInboundPayload = TaskCommandHookPayload | TaskInboundAnswerInput | TaskInboundUpdate;
+/** Generic task-owned request sent through the parent session payload. */
+interface TaskInputRequestDeliveryBase {
+    readonly replyTo: string;
+    readonly sequence: number;
+    readonly stepIndex: number;
+    readonly taskId: string;
+    readonly turnId: string;
+}
+export type TaskInputRequestDelivery = TaskInputRequestDeliveryBase & ({
+    readonly request: TaskInputRequest;
+    readonly requests?: never;
+} | {
+    readonly request?: never;
+    readonly requests: readonly TaskInputRequest[];
+});
+/**
+ * Child authorization event projected through the parent channel. Display
+ * only: the authorization callback completes against the child directly.
+ */
+export interface TaskAuthorizationEventDelivery {
+    readonly hookPayload: SubagentAuthorizationEventHookPayload;
+    readonly taskId: string;
+}
+/** Stable id shared by one authorization attempt's events, used to dedupe deliveries. */
+export declare function taskAuthorizationRequestId(event: SubagentAuthorizationEvent): string;
+/**
+ * Agent spawn or settlement a task-owned workflow tool run asks its parent to
+ * apply, forwarded after task admission. `replyTo` is the run's reply hook.
+ */
+export interface TaskAgentRequestDelivery {
+    readonly replyTo: string;
+    readonly request: WorkflowToolAgentRequest;
+    readonly taskId: string;
+}
 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

@@ -1 +1 @@
-import{isJsonObjectValue}from"#shared/json.js";function createSubagentTaskMetadata(e){return{...e,kind:`subagent`}}function readSubagentTaskMetadata(e){if(e.metadata.kind===`subagent`&&`agentId`in e.metadata)return e.metadata;let t=readSubagentExecutor(e.executor);if(t!==void 0)return{agentId:t.identity.id,kind:`subagent`,mode:t.address.kind===`agent/remote`?`remote`:`local`,name:t.identity.name}}function createSubagentExecutorBinding(e){let{address:t,identity:n}=e;return{data:{address:{...t},identity:{id:n.id,name:n.name,nodeId:n.nodeId}},kind:`subagent`}}function readSubagentExecutor(e){let t=e!==void 0&&`kind`in e?e:e?.binding;if(t?.kind!==`subagent`)return;let n=readAgentIdentity(t.data.identity),r=readAgentAddress(t.data.address);return n===void 0||r===void 0?void 0:{address:r,identity:n}}function readAgentIdentity(t){if(t===void 0||!isJsonObjectValue(t))return;let{id:n,name:r,nodeId:i}=t;return typeof n==`string`&&typeof r==`string`&&typeof i==`string`?{id:n,name:r,nodeId:i}:void 0}function readAgentAddress(t){if(t===void 0||!isJsonObjectValue(t))return;let{callbackBaseUrl:n,continuationToken:r,credentialResolver:i,kind:a,sessionId:o,url:s}=t;if(typeof o==`string`){if(a===`agent/local`||a===`agent/self`)return typeof r==`string`?{continuationToken:r,kind:a,sessionId:o}:void 0;if(a===`agent/remote`){let e=readCredentialResolver(i);if(i!==void 0&&e===void 0||typeof s!=`string`||typeof n!=`string`)return;let t={callbackBaseUrl:n,kind:a,sessionId:o,url:s};return e!==void 0&&(t.credentialResolver=e),t}}}function readCredentialResolver(t){if(t===void 0||!isJsonObjectValue(t))return;let{resolverId:n}=t;if(!(n!==void 0&&typeof n!=`string`))return n===void 0?{}:{resolverId:n}}function sameTaskMetadata(e,t){if(e.kind!==t.kind||e.name!==t.name)return!1;let n=`agentId`in e,r=`agentId`in t;return n===r&&(!n||!r||e.agentId===t.agentId&&e.mode===t.mode)}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(e){return e.type===`approval.candidate`||e.type===`approval.settled`?`${TASK_AUTHORIZATION_REQUEST_ID_PREFIX}:${e.data.requestId}`:`${TASK_AUTHORIZATION_REQUEST_ID_PREFIX}:${e.data.attemptId??e.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,createSubagentExecutorBinding,createSubagentTaskMetadata,isReadyTaskStatus,isTerminalTaskStatus,readSubagentExecutor,readSubagentTaskMetadata,readTaskInputRequestId,readTaskUsage,sameTaskMetadata,taskAuthorizationRequestId};
+import{jsonValuesEqual}from"#shared/json.js";function sameTaskMetadata(t,n){return jsonValuesEqual(t,n)}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}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_AUTHORIZATION_REQUEST_ID_PREFIX=`task:authorization`;function taskAuthorizationRequestId(e){return e.type===`approval.candidate`||e.type===`approval.settled`?`${TASK_AUTHORIZATION_REQUEST_ID_PREFIX}:${e.data.requestId}`:`${TASK_AUTHORIZATION_REQUEST_ID_PREFIX}:${e.data.attemptId??e.data.name}`}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,sameTaskMetadata,taskAuthorizationRequestId};

package/dist/src/tools/dynamic.d.ts

@@ -1,6 +1,7 @@
 import type { Approval } from "#approval/definition.js";
 import type { DynamicResolveContext, DynamicToolEventName } from "#dynamic/definition.js";
 import type { PublicToolInputSchema, PublicToolOutputSchema, ToolContext } from "#tools/definition.js";
+import type { TaskDelegated, TaskExec } from "#tools/task.js";
 import type { ToolModelOutput } from "#tools/model-output.js";
 /**
  * A single tool entry within a resolved dynamic tool set.
@@ -18,7 +19,8 @@ export interface DynamicToolEntry<TInput = Record<string, unknown>, TOutput = an
     readonly description: string;
     readonly inputSchema: PublicToolInputSchema<TInput>;
     readonly outputSchema?: PublicToolOutputSchema<TOutput>;
-    execute(input: TInput, ctx: ToolContext): TOutput | Promise<TOutput>;
+    readonly execution?: "background";
+    execute(input: TInput, ctx: ToolContext, task?: TaskExec): TOutput | TaskDelegated | Promise<TOutput | TaskDelegated>;
     readonly toModelOutput?: (output: TOutput) => ToolModelOutput | Promise<ToolModelOutput>;
     /**
      * Optional per-call approval gate, mirroring the authored-tool

package/dist/src/tools/framework/agent.d.ts

@@ -1,8 +1,24 @@
-export declare const agent: import("#tools/native-definition.js").NativeToolDefinition<{
+export declare const agent: import("#tools/definition.js").BackgroundToolDefinition<{
     agentId?: string | null | undefined;
     message: string;
     outputSchema?: {
         [x: string]: unknown;
     } | undefined;
-}, unknown>;
+}, {
+    agentId: string;
+    status: "working";
+    taskId: string;
+}> & {
+    execute(input: {
+        agentId?: string | null | undefined;
+        message: string;
+        outputSchema?: {
+            [x: string]: unknown;
+        } | undefined;
+    }, ctx: import("#tools/definition.js").ToolContext, task: import("#tools/definition.js").TaskExec): {
+        agentId: string;
+        status: "working";
+        taskId: string;
+    };
+};
 export default agent;

package/dist/src/tools/framework/agent.js

@@ -1 +1 @@
-import{AGENT_TOOL_DESCRIPTION,SUBAGENT_TOOL_INPUT_SCHEMA}from"#tools/framework/agent-contract.js";import{defineNativeTool}from"#tools/native-definition.js";const agent=defineNativeTool({description:AGENT_TOOL_DESCRIPTION,inputSchema:SUBAGENT_TOOL_INPUT_SCHEMA},{availability:[`root-session`],handling:{action:`self-agent`,kind:`dispatch`}});export{agent,agent as default};
+import{defineTool}from"#tools/definition.js";import{SUBAGENT_TASK_RECEIPT_OUTPUT_SCHEMA}from"#tools/framework/task-contract.js";import{AGENT_TOOL_DESCRIPTION,SUBAGENT_TOOL_INPUT_SCHEMA}from"#tools/framework/agent-contract.js";import{attachToolBehavior}from"#tools/behavior.js";const agent=attachToolBehavior(defineTool({description:`${AGENT_TOOL_DESCRIPTION} This call starts a background task and returns a task receipt immediately.`,execution:`background`,inputSchema:SUBAGENT_TOOL_INPUT_SCHEMA,outputSchema:SUBAGENT_TASK_RECEIPT_OUTPUT_SCHEMA,execute(){"use workflow";throw Error(`The framework "agent" tool was executed directly. It must be resolved through the runtime tool registry, which dispatches it to the shared subagent workflow.`)}}),{availability:[`root-session`],handling:{action:`self-agent`,kind:`dispatch`}});export{agent,agent as default};

package/dist/src/tools/framework/task-cancel.d.ts

@@ -8,13 +8,9 @@ export declare const taskCancel: import("#tools/native-definition.js").NativeToo
             type: "error" | "result";
         } | undefined;
         metadata: {
-            agentId: string;
-            kind: "subagent";
-            mode: "local" | "remote";
-            name: string;
-        } | {
-            data?: Record<string, unknown> | undefined;
+            agentId?: string | undefined;
             kind: string;
+            mode?: "local" | "remote" | undefined;
             name: string;
         };
         status: "cancelled" | "completed" | "failed" | "input_required" | "working";

package/dist/src/tools/framework/task-contract.d.ts

@@ -1,6 +1,8 @@
 import { z } from "#compiled/zod/index.js";
 export declare const TASK_CANCEL_TOOL_NAME = "task_cancel";
 export declare const TASK_UPDATE_TOOL_NAME = "task_update";
+/** Framework task-control tool names lowered by the runtime. */
+export declare const TASK_TOOL_NAMES: ReadonlySet<string>;
 export declare const TASK_CANCEL_INPUT_SCHEMA: z.ZodObject<{
     taskIds: z.ZodArray<z.ZodString>;
 }, z.core.$strict>;
@@ -9,49 +11,40 @@ export declare const TASK_UPDATE_INPUT_SCHEMA: z.ZodObject<{
 }, z.core.$strict>;
 /** Strict model-visible task projection. */
 export declare const TASK_VIEW_JSON_SCHEMA: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    metadata: z.ZodUnion<readonly [z.ZodObject<{
-        agentId: z.ZodString;
-        kind: z.ZodLiteral<"subagent">;
-        mode: z.ZodEnum<{
+    metadata: z.ZodObject<{
+        agentId: z.ZodOptional<z.ZodString>;
+        kind: z.ZodString;
+        mode: z.ZodOptional<z.ZodEnum<{
             local: "local";
             remote: "remote";
-        }>;
+        }>>;
         name: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
-        kind: z.ZodString;
-        name: z.ZodString;
-    }, z.core.$strip>]>;
+    }, z.core.$strip>;
     taskId: z.ZodString;
     status: z.ZodLiteral<"working">;
 }, z.core.$strip>, z.ZodObject<{
-    metadata: z.ZodUnion<readonly [z.ZodObject<{
-        agentId: z.ZodString;
-        kind: z.ZodLiteral<"subagent">;
-        mode: z.ZodEnum<{
+    metadata: z.ZodObject<{
+        agentId: z.ZodOptional<z.ZodString>;
+        kind: z.ZodString;
+        mode: z.ZodOptional<z.ZodEnum<{
             local: "local";
             remote: "remote";
-        }>;
-        name: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
-        kind: z.ZodString;
+        }>>;
         name: z.ZodString;
-    }, z.core.$strip>]>;
+    }, z.core.$strip>;
     taskId: z.ZodString;
     inputRequests: z.ZodReadonly<z.ZodArray<z.ZodType<import("../../shared/json.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("../../shared/json.ts").JsonValue, unknown>>>>;
     status: z.ZodLiteral<"input_required">;
 }, z.core.$strip>, z.ZodObject<{
-    metadata: z.ZodUnion<readonly [z.ZodObject<{
-        agentId: z.ZodString;
-        kind: z.ZodLiteral<"subagent">;
-        mode: z.ZodEnum<{
+    metadata: z.ZodObject<{
+        agentId: z.ZodOptional<z.ZodString>;
+        kind: z.ZodString;
+        mode: z.ZodOptional<z.ZodEnum<{
             local: "local";
             remote: "remote";
-        }>;
-        name: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
-        kind: z.ZodString;
+        }>>;
         name: z.ZodString;
-    }, z.core.$strip>]>;
+    }, z.core.$strip>;
     taskId: z.ZodString;
     lastOutput: z.ZodObject<{
         data: z.ZodType<import("../../shared/json.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("../../shared/json.ts").JsonValue, unknown>>;
@@ -59,18 +52,15 @@ export declare const TASK_VIEW_JSON_SCHEMA: z.ZodDiscriminatedUnion<[z.ZodObject
     }, z.core.$strip>;
     status: z.ZodLiteral<"completed">;
 }, z.core.$strip>, z.ZodObject<{
-    metadata: z.ZodUnion<readonly [z.ZodObject<{
-        agentId: z.ZodString;
-        kind: z.ZodLiteral<"subagent">;
-        mode: z.ZodEnum<{
+    metadata: z.ZodObject<{
+        agentId: z.ZodOptional<z.ZodString>;
+        kind: z.ZodString;
+        mode: z.ZodOptional<z.ZodEnum<{
             local: "local";
             remote: "remote";
-        }>;
+        }>>;
         name: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
-        kind: z.ZodString;
-        name: z.ZodString;
-    }, z.core.$strip>]>;
+    }, z.core.$strip>;
     taskId: z.ZodString;
     lastOutput: z.ZodObject<{
         data: z.ZodType<import("../../shared/json.ts").JsonValue, unknown, z.core.$ZodTypeInternals<import("../../shared/json.ts").JsonValue, unknown>>;
@@ -78,18 +68,15 @@ export declare const TASK_VIEW_JSON_SCHEMA: z.ZodDiscriminatedUnion<[z.ZodObject
     }, z.core.$strip>;
     status: z.ZodLiteral<"failed">;
 }, z.core.$strip>, z.ZodObject<{
-    metadata: z.ZodUnion<readonly [z.ZodObject<{
-        agentId: z.ZodString;
-        kind: z.ZodLiteral<"subagent">;
-        mode: z.ZodEnum<{
+    metadata: z.ZodObject<{
+        agentId: z.ZodOptional<z.ZodString>;
+        kind: z.ZodString;
+        mode: z.ZodOptional<z.ZodEnum<{
             local: "local";
             remote: "remote";
-        }>;
+        }>>;
         name: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
-        kind: z.ZodString;
-        name: z.ZodString;
-    }, z.core.$strip>]>;
+    }, z.core.$strip>;
     taskId: z.ZodString;
     status: z.ZodLiteral<"cancelled">;
 }, z.core.$strip>], "status">;
@@ -103,19 +90,15 @@ export declare const TASK_VIEW_OUTPUT_SCHEMA: z.ZodObject<{
             result: "result";
         }>;
     }, z.core.$strip>>;
-    metadata: z.ZodUnion<readonly [z.ZodObject<{
-        agentId: z.ZodString;
-        kind: z.ZodLiteral<"subagent">;
-        mode: z.ZodEnum<{
+    metadata: z.ZodObject<{
+        agentId: z.ZodOptional<z.ZodString>;
+        kind: z.ZodString;
+        mode: z.ZodOptional<z.ZodEnum<{
             local: "local";
             remote: "remote";
-        }>;
-        name: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
-        data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        kind: z.ZodString;
+        }>>;
         name: z.ZodString;
-    }, z.core.$strip>]>;
+    }, z.core.$strip>;
     status: z.ZodEnum<{
         cancelled: "cancelled";
         completed: "completed";
@@ -135,19 +118,15 @@ export declare const TASK_VIEWS_OUTPUT_SCHEMA: z.ZodObject<{
                 result: "result";
             }>;
         }, z.core.$strip>>;
-        metadata: z.ZodUnion<readonly [z.ZodObject<{
-            agentId: z.ZodString;
-            kind: z.ZodLiteral<"subagent">;
-            mode: z.ZodEnum<{
+        metadata: z.ZodObject<{
+            agentId: z.ZodOptional<z.ZodString>;
+            kind: z.ZodString;
+            mode: z.ZodOptional<z.ZodEnum<{
                 local: "local";
                 remote: "remote";
-            }>;
-            name: z.ZodString;
-        }, z.core.$strip>, z.ZodObject<{
-            data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-            kind: z.ZodString;
+            }>>;
             name: z.ZodString;
-        }, z.core.$strip>]>;
+        }, z.core.$strip>;
         status: z.ZodEnum<{
             cancelled: "cancelled";
             completed: "completed";