eve 0.68.0 → 0.69.0

package/dist/src/channel/task-card.d.ts

@@ -0,0 +1,121 @@
+import type { TaskCancelReason, UnstampedMessageStreamEvent } from "#protocol/message.js";
+import type { ChannelAudience } from "#shared/channel-audience.js";
+import type { JsonObject } from "#shared/json.js";
+/** How one of the turn's calls stands. */
+export type TaskCardStatus = "working" | "completed" | "failed" | "cancelled";
+/** What a blocked task waits on: a person's approval, answer, or sign-in. */
+export interface TaskCardBlocker {
+    readonly kind: "approval" | "authorization" | "input";
+    /**
+     * The request's prompt or the connection's name. Only in a private
+     * conversation, since a request can be sent to one person alone.
+     */
+    readonly label?: string;
+}
+/** One task call in a turn's task card. */
+export interface TaskCardTask {
+    /** The call's id; a resumable task called twice in a turn has two rows. */
+    readonly id: string;
+    readonly taskId: string;
+    readonly kind: "agent" | "tool";
+    /** The tool or agent name. */
+    readonly name: string;
+    /**
+     * The tool's start label, or the name. An agent's is `researcher: brief`,
+     * or the brief alone for a call to the agent's own copy.
+     */
+    readonly title: string;
+    /** `blocked` while the task waits on a person; see {@link TaskCardTask.blockedOn}. */
+    readonly status: TaskCardStatus | "blocked";
+    readonly blockedOn?: TaskCardBlocker;
+    /**
+     * The first sentence of the result once settled. A failure's line appears
+     * only in a private conversation, since error text can carry internals.
+     */
+    readonly summary?: string;
+    /**
+     * Why a cancelled task stopped: `task_cancel` when the model no longer
+     * needed it. Absent when the task's run stopped on its own.
+     */
+    readonly cancelReason?: TaskCancelReason;
+    readonly startedAt: string;
+    readonly settledAt?: string;
+}
+/**
+ * One of the turn's own tool calls that doesn't run as a task, such as a call
+ * to an app's `plan` tool whose input a renderer shows as rows.
+ */
+export interface TaskCardAction {
+    /** The call's id. */
+    readonly id: string;
+    /** The tool name. */
+    readonly name: string;
+    /** The tool's start label, or the name. */
+    readonly title: string;
+    readonly status: TaskCardStatus;
+    /** The call's input, when its JSON is at most 4,096 characters. */
+    readonly input?: Readonly<Record<string, unknown>>;
+    readonly startedAt: string;
+    readonly settledAt?: string;
+}
+/**
+ * One turn's own tool calls: the tasks it started, and its other actions,
+ * each in call order. `blocked` while any task waits on a person, `working`
+ * while the turn or any other task works, then `finished`.
+ */
+export interface TaskCardView {
+    readonly turnId: string;
+    readonly state: "working" | "blocked" | "finished";
+    readonly tasks: readonly TaskCardTask[];
+    readonly actions: readonly TaskCardAction[];
+}
+/** One call as a channel tracks it: plain JSON, kept in the channel's state. */
+interface TrackedCall {
+    readonly callId: string;
+    readonly name: string;
+    readonly title: string;
+    readonly status: TaskCardStatus;
+    readonly startedAt: string;
+    readonly input?: JsonObject;
+    readonly settledAt?: string;
+    readonly task?: {
+        readonly id: string;
+        readonly kind: "agent" | "tool";
+        readonly summary?: string;
+        readonly cancelReason?: TaskCancelReason;
+        /** Open requests and sign-ins the task waits on, oldest first. */
+        readonly blockers?: readonly (TaskCardBlocker & {
+            readonly id: string;
+        })[];
+    };
+}
+/** One turn's calls as a channel tracks them from its session's own events. */
+export interface TaskCardTurn {
+    readonly calls: readonly TrackedCall[];
+    readonly ended: boolean;
+}
+type TurnChanges = Readonly<Record<string, TaskCardTurn>>;
+/**
+ * Folds one of the session's events into the turns' tracked calls, including
+ * the requests a task's run relays through the session. Returns each turn it
+ * changed, by turn id; none when the event changes no card.
+ */
+export declare function trackTaskCardEvent(turns: Readonly<Record<string, TaskCardTurn>>, event: UnstampedMessageStreamEvent, at: string): TurnChanges;
+/**
+ * Splits a turn's card when the turn starts a task after every task on the
+ * card settled, which happens when the turn's caller keeps talking to an open
+ * turn. The settled calls end as their own finished card; the calls still
+ * working, including the one starting, open a new card. Returns nothing while
+ * any of the card's tasks works.
+ */
+export declare function closeSettledTasks(turn: TaskCardTurn, callId: string): {
+    readonly closed: TaskCardTurn;
+    readonly open: TaskCardTurn;
+} | undefined;
+/** The view a renderer draws one turn's card from. */
+export declare function taskCardView(turnId: string, turn: TaskCardTurn, options: {
+    readonly audience: ChannelAudience;
+}): TaskCardView;
+/** The names of a turn's working tasks, for a status such as `Waiting on researcher...`. */
+export declare function workingTaskNames(turn: TaskCardTurn | undefined): readonly string[];
+export {};

package/dist/src/channel/task-card.js

@@ -0,0 +1 @@
+import{isTaskControlTool}from"#protocol/task-tools.js";import{actionRequestName}from"#shared/action-request-name.js";import{firstSentence,normalizePresentationText}from"#shared/presentation-text.js";function trackTaskCardEvent(e,t,n){switch(t.type){case`input.requested`:{let{requests:n,taskId:r}=t.data;if(r===void 0)return{};let i=n.map(e=>blocker(e.requestId,e.kind===`question`?`input`:`approval`,e.prompt));return updateBlockers(e,r,e=>[...e,...i])}case`input.resolved`:{let n=new Set(t.data.resolutions.map(e=>e.requestId));return updateBlockers(e,void 0,e=>e.filter(e=>!n.has(e.id)))}case`authorization.required`:{let{taskId:n}=t.data;if(n===void 0)return{};let r=authorizationId(t.data),i=t.data.authorization?.displayName??t.data.name;return updateBlockers(e,n,e=>[...e.filter(e=>e.id!==r),blocker(r,`authorization`,i)])}case`authorization.completed`:{let n=authorizationId(t.data);return updateBlockers(e,t.data.taskId,e=>e.filter(e=>e.id!==n))}default:{let r=trackTurnEvent(e,t,n);return r===void 0?{}:{[r.turnId]:r.turn}}}}function blocker(e,t,n){let r=presentationText(n)?.slice(0,200);return r===void 0?{id:e,kind:t}:{id:e,kind:t,label:r}}function authorizationId(e){return e.attemptId??e.candidateId??e.name}function updateBlockers(e,t,n){let r={};for(let[i,a]of Object.entries(e))for(let e of a.calls){if(e.task===void 0||e.status!==`working`||t!==void 0&&e.task.id!==t)continue;let o=e.task.blockers??[],s=n(o);if(s.length===o.length&&s.every((e,t)=>e.id===o[t].id))continue;let c={...e.task,blockers:s};r[i]=replaceCall(r[i]??a,{...e,task:c})}return r}function trackTurnEvent(e,t,n){switch(t.type){case`actions.requested`:{let{turnId:r}=t.data,i=e[r]??{calls:[],ended:!1},a=new Set(i.calls.map(e=>e.callId)),o=t.data.actions.filter(e=>!a.has(e.callId)&&(e.kind!==`tool-call`||!isTaskControlTool(e.toolName)&&e.parentCallId===void 0));if(o.length===0)return;let s=o.map(e=>requestedCall(e,t.data.presentation?.[e.callId]?.label,n));return{turn:{...i,calls:bounded([...i.calls,...s])},turnId:r}}case`action.result`:{let{turnId:r}=t.data,i=e[r],a=i?.calls.find(e=>e.callId===t.data.result.callId);if(i===void 0||a===void 0||a.task!==void 0)return;let o=actionStatus(t.data.status);return{turn:replaceCall(i,{...a,settledAt:n,status:o}),turnId:r}}case`task.started`:{let{callId:r,kind:i,name:a,taskId:o,turnId:s}=t.data,c=e[s]??{calls:[],ended:!1},l=c.calls.find(e=>e.callId===r)??{callId:r,name:a,startedAt:n,status:`working`,title:a};return{turn:replaceCall(c,{callId:l.callId,name:l.name,startedAt:l.startedAt,status:`working`,task:{id:o,kind:i},title:l.title}),turnId:s}}case`task.settled`:{let{callId:r,status:i,turnId:a}=t.data,o=e[a],s=o?.calls.find(e=>e.callId===r);if(o===void 0||s?.task===void 0)return;let c={id:s.task.id,kind:s.task.kind},l=taskSummary(t.data);l!==void 0&&(c.summary=l);let u=t.data.cancel?.reason;return u!==void 0&&(c.cancelReason=u),{turn:replaceCall(o,{...s,settledAt:n,status:i,task:c}),turnId:a}}case`turn.completed`:case`turn.failed`:case`turn.cancelled`:{let n=e[t.data.turnId];return n===void 0||n.ended?void 0:{turn:{...n,ended:!0},turnId:t.data.turnId}}default:return}}function closeSettledTasks(e,t){let n=e.calls.filter(e=>e.task!==void 0&&e.callId!==t);if(!(n.length===0||n.some(e=>e.status===`working`)))return{closed:{calls:e.calls.filter(e=>e.status!==`working`),ended:!0},open:{calls:e.calls.filter(e=>e.status===`working`),ended:!1}}}function taskCardView(e,t,n){let r=[],i=[];for(let e of t.calls)e.task===void 0?i.push(toAction(e)):r.push(toTask(e,e.task,n.audience));return{actions:i,state:r.some(e=>e.status===`blocked`)?`blocked`:!t.ended||r.some(e=>e.status===`working`)?`working`:`finished`,tasks:r,turnId:e}}function workingTaskNames(e){return(e?.calls??[]).filter(e=>e.task!==void 0&&e.status===`working`).map(e=>e.name)}function requestedCall(e,t,n){let r=actionRequestName(e),i={callId:e.callId,name:r,startedAt:n,status:`working`,title:presentationText(t)??r},a=boundedInput(e.input);return a!==void 0&&(i.input=a),i}function toAction(e){let t={id:e.callId,name:e.name,startedAt:e.startedAt,status:e.status,title:e.title};return e.input!==void 0&&(t.input=e.input),e.settledAt!==void 0&&(t.settledAt=e.settledAt),t}function toTask(e,t,n){let r={id:e.callId,kind:t.kind,name:e.name,startedAt:e.startedAt,status:e.status,taskId:t.id,title:e.title},i=n===`private`,a=e.status===`working`?t.blockers?.at(-1):void 0;a!==void 0&&(r.status=`blocked`,r.blockedOn=i&&a.label!==void 0?{kind:a.kind,label:a.label}:{kind:a.kind});let o=e.status!==`failed`||i;return t.summary!==void 0&&o&&(r.summary=t.summary),t.cancelReason!==void 0&&(r.cancelReason=t.cancelReason),e.settledAt!==void 0&&(r.settledAt=e.settledAt),r}function replaceCall(e,t){let n=e.calls.some(e=>e.callId===t.callId)?e.calls.map(e=>e.callId===t.callId?t:e):[...e.calls,t];return{...e,calls:bounded(n)}}function bounded(e){let t=e.length-100;return t<=0?e:e.filter(e=>t>0&&e.status!==`working`?(--t,!1):!0)}function actionStatus(e){switch(e){case`completed`:case`cancelled`:return e;default:return`failed`}}function boundedInput(e){if(typeof e==`object`&&e&&!Array.isArray(e))return JSON.stringify(e).length<=4096?e:void 0}function taskSummary(e){switch(e.status){case`completed`:return brief(resultText(e.output));case`failed`:return brief(e.error?.message);default:return}}function resultText(e){if(typeof e==`string`)return e;if(typeof e!=`object`||!e||Array.isArray(e))return;let t=e;return t.message??t.text??t.summary}function brief(e){return typeof e==`string`?firstSentence(e):void 0}function presentationText(e){if(e===void 0)return;let t=normalizePresentationText(e);return t===``?void 0:t}export{closeSettledTasks,taskCardView,trackTaskCardEvent,workingTaskNames};

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

@@ -1,17 +1,16 @@
 import type { UserContent } from "ai";
+import type { LegacyRemoteAgentCaller } from "#execution/legacy-remote-agent/protocol.js";
 import type { SessionInboxAddress } from "#execution/session-inbox/address.js";
 import type { MessageStreamEvent, UnstampedMessageStreamEvent } from "#protocol/message.js";
 import type { CancelTurnResult as ProtocolCancelTurnResult } from "#protocol/cancel-turn.js";
 import type { RuntimeSubagentChildResult, RuntimeSubagentDispatchFailure, RuntimeToolResultActionResult } from "#shared/action-types.js";
 import type { InputRequest, InputResponse } from "#shared/input.js";
-import type { ToolInputResponseResponder } from "#tools/definition.js";
 import type { ChannelAdapter } from "#channel/adapter.js";
 import type { AgentLimitsDefinition } from "#shared/agent-definition.js";
 import type { JsonObject } from "#shared/json.js";
 import type { InstrumentationDecision } from "#shared/instrumentation-decision.js";
 import type { ForwardedTraceAssertion } from "#shared/forwarded-trace-policy.js";
 import type { ConversationContext } from "#shared/conversation-context.js";
-import type { TaskAgentRequestDelivery, TaskAuthorizationEventDelivery, TaskInputRequestDelivery, TaskView } from "#tasks/types.js";
 export type { ContextAccessor } from "#context/key.js";
 export type { ChannelInstrumentationProjection } from "#channel/instrumentation.js";
 import type { ChannelInstrumentationProjection } from "#channel/instrumentation.js";
@@ -19,10 +18,6 @@ export type RunSessionLimits = Pick<AgentLimitsDefinition, "maxInputTokensPerSes
 /** Identifies the session turn to cancel. */
 export interface CancelTurnInput {
     readonly sessionId: string;
-    /** Framework task whose queued child deliveries should be discarded. */
-    readonly taskId?: string;
-    /** Cancels every nonterminal task owned by the session. */
-    readonly tasks?: boolean;
     /** Limits the request to the turn the caller observed. */
     readonly turnId?: string;
 }
@@ -113,11 +108,8 @@ export interface SessionAuthContext {
 }
 /** Framework-internal caller waiting for one delegated conversation turn. */
 export interface TurnCaller {
-    readonly activityObserver?: ActivityObserverConfig;
     readonly callId: string;
     readonly subagentName: string;
-    /** Present when this turn is the executor for a durable background task. */
-    readonly taskId?: string;
     readonly replyTo: {
         readonly kind: "hook";
         readonly token: string;
@@ -141,26 +133,11 @@ export interface TurnCaller {
  */
 export interface DeliverPayload {
     readonly inputResponses?: readonly InputResponse[];
-    /** Authenticated identity associated with an internal forwarded input response. */
-    readonly responder?: ToolInputResponseResponder;
     readonly message?: string | UserContent;
     readonly context?: readonly string[];
     readonly outputSchema?: JsonObject;
-    /** Framework-only task envelopes consumed before adapter/model delivery. */
-    readonly task?: {
-        /** Task HITL input-request batches for the parent's pre-model router. */
-        readonly inputRequests?: readonly TaskInputRequestDelivery[];
-        /** Agent spawn/settlement requests a task-owned workflow run needs the parent to apply. */
-        readonly agentRequests?: readonly TaskAgentRequestDelivery[];
-        /** Task child authorization events re-emitted through the parent channel. */
-        readonly authorizationEvents?: readonly TaskAuthorizationEventDelivery[];
-        /** Terminal views cached before task-run retention expires. */
-        readonly views?: readonly TaskView[];
-    };
     readonly [key: string]: unknown;
 }
-/** Controls background task wake timing and whether partial results require a report. */
-export type TaskDeliveryPolicy = "cohort" | "auto";
 /** Controls how a channel message interacts with an active turn. */
 export type TurnPolicy = "steer" | "queue";
 /** Default policy for message sends produced by current channel surfaces. */
@@ -175,18 +152,9 @@ export type SessionCommand = {
     readonly payload: DeliverPayload;
     readonly delivery?: ChannelDeliveryMetadata;
     readonly requestId?: string;
-    /**
-     * Replay-stable identity for one task-owned child delivery; lets the
-     * parent inbox dedupe retried durable-step deliveries. See
-     * {@link DeliverHookPayload.taskDeliveryId}.
-     */
-    readonly taskDeliveryId?: string;
     readonly turnPolicy?: TurnPolicy;
-    readonly taskDeliveryPolicy?: TaskDeliveryPolicy;
 } | {
     readonly kind: "cancel";
-    readonly taskId?: string;
-    readonly tasks?: boolean;
     readonly turnId?: string;
 } | {
     readonly kind: "compact";
@@ -245,19 +213,9 @@ export interface DeliverHookPayload {
     readonly deliveryMetadata?: readonly ChannelDeliveryMetadataEntry[];
     /** Inbound channel request id used only for workflow attributes. */
     readonly requestId?: string;
-    /**
-     * Replay-stable identity for one task-owned child delivery. Task-run steps
-     * derive it from deterministic inputs (task id, event kind, sequence) so the
-     * parent inbox can drop the duplicate when a durable step retries after
-     * `resumeHook` already succeeded.
-     */
-    readonly taskDeliveryId?: string;
-    /** All source notifications when the session queue combines task results. */
-    readonly taskDeliveryIds?: readonly string[];
     readonly kind: "deliver";
     readonly payloads: readonly DeliverPayload[];
     readonly turnPolicy?: TurnPolicy;
-    readonly taskDeliveryPolicy?: TaskDeliveryPolicy;
 }
 /** Internal deadline signal sent through the stable session command inbox. */
 export interface SessionTimeoutHookPayload {
@@ -293,6 +251,8 @@ export interface SubagentInputRequestEvent {
     readonly requests: readonly InputRequest[];
     readonly sequence: number;
     readonly stepIndex: number;
+    /** The task that asks, when a task's run forwards the request. */
+    readonly taskId?: string;
     readonly turnId: string;
 }
 /**
@@ -304,6 +264,11 @@ export interface SubagentInputRequestEvent {
  * `input.requested` handler and the parent's runtime loop.
  */
 export interface SubagentInputRequestHookPayload {
+    readonly remote?: import("#eve-channel/support.js").RemoteAgentBinding & {
+        readonly sessionId: string;
+    };
+    /** Independent source when several requests share an answer destination. */
+    readonly inputSource?: string;
     readonly callId: string;
     readonly childContinuationToken: string;
     readonly childSessionId: string;
@@ -342,18 +307,9 @@ export type HookPayload = ClearSessionHookPayload | CompactSessionHookPayload |
  * this as its first turn's caller; each continuation supplies the caller for
  * that turn.
  */
-export interface ActivitySinkV1 {
-    readonly url: string;
-    readonly version: 1;
-}
-export interface ActivityObserverConfig {
-    readonly sink: ActivitySinkV1;
-    readonly workIdentity?: import("#protocol/activity.js").ActivityWorkIdentityV1;
-}
 export interface SessionCallback {
     readonly callId: string;
     readonly subagentName: string;
-    readonly taskId?: string;
     readonly token: string;
     readonly url: string;
 }
@@ -385,10 +341,7 @@ export interface SessionCapabilities {
  * subagent tool wrapper).
  */
 export interface RunInput {
-    readonly taskDeliveryPolicy?: TaskDeliveryPolicy;
     readonly adapter: ChannelAdapter<any>;
-    /** Framework task that owns this run, when the run is a task executor. */
-    readonly taskId?: string;
     /**
      * Registered channel name for root sessions started from an authored
      * channel route. Framework runs omit this and use their framework
@@ -430,8 +383,8 @@ export interface RunInput {
      * caller for their own turn.
      */
     readonly callback?: SessionCallback;
-    /** Private collector capability and current work lineage. */
-    readonly activityObserver?: ActivityObserverConfig;
+    /** Set when {@link callback} belongs to a remote agent protocol 1 caller. */
+    readonly legacyRemoteAgentCaller?: LegacyRemoteAgentCaller;
     /**
      * Session continuation token for delivery and hook creation. Channels can
      * add a continuation address during the first turn via
@@ -464,6 +417,8 @@ export interface RunInput {
         readonly message?: string | UserContent;
         readonly context?: readonly string[];
         readonly outputSchema?: JsonObject;
+        /** Channel payload state for the first delivery, as later deliveries carry it. */
+        readonly state?: unknown;
     };
     /** Observability correlation only; never grants delegated-session privileges. */
     readonly conversationId?: string;