@cursor/bdk 0.2.1 → 0.2.3

package/src/internal/event-mapper.ts

@@ -5,7 +5,7 @@
  */
 
 import type { InteractionUpdate as SdkInteractionUpdate, ToolCall } from "@cursor/sdk";
-import type { SessionEventPayload, TurnUsage } from "../types.js";
+import type { ActionCall, ActionResult, SessionEventPayload, TurnUsage } from "../types.js";
 
 const CUSTOM_TOOLS_PROVIDER = "custom-user-tools";
 /** Authored server tools on cloud turns; keep in sync with `SERVER_TOOLS_MCP_SERVER_NAME`. */
@@ -39,7 +39,8 @@ type NestedTaskUpdate =
       modelCallId: string;
     }
   | { type: "step-started"; stepId: number }
-  | { type: "step-completed"; stepId: number; stepDurationMs: number };
+  | { type: "step-completed"; stepId: number; stepDurationMs: number }
+  | { type: "tool-requests-listed"; callCount: number };
 
 type ToolCallDeltaUpdate = {
   type: "tool-call-delta";
@@ -48,8 +49,13 @@ type ToolCallDeltaUpdate = {
   taskUpdate: NestedTaskUpdate;
 };
 
-/** SDK updates plus nested task deltas once the SDK exposes them. */
-type InteractionUpdate = SdkInteractionUpdate | ToolCallDeltaUpdate;
+type ToolRequestsListedUpdate = {
+  type: "tool-requests-listed";
+  callCount: number;
+};
+
+/** SDK updates plus list-closed / nested task deltas ahead of `@cursor/sdk`. */
+type InteractionUpdate = SdkInteractionUpdate | ToolCallDeltaUpdate | ToolRequestsListedUpdate;
 
 function asToolCallDelta(update: InteractionUpdate): ToolCallDeltaUpdate | undefined {
   if ((update as { type: string }).type !== "tool-call-delta") {
@@ -58,6 +64,12 @@ function asToolCallDelta(update: InteractionUpdate): ToolCallDeltaUpdate | undef
   return update as ToolCallDeltaUpdate;
 }
 
+function modelCallIdOf(update: { modelCallId?: unknown }): string | undefined {
+  return typeof update.modelCallId === "string" && update.modelCallId !== ""
+    ? update.modelCallId
+    : undefined;
+}
+
 export interface ToolCallDescription {
   toolName: string;
   args?: unknown;
@@ -74,6 +86,17 @@ interface NestedAccumulators {
   reasoning: string;
 }
 
+type ToolWave = {
+  key: string;
+  modelCallId?: string;
+  parentCallId?: string;
+  calls: ActionCall[];
+  results: ActionResult[];
+  expectedCalls?: number;
+  requestedEmitted: boolean;
+  completedEmitted: boolean;
+};
+
 export class TurnEventMapper {
   private textAccumulator = "";
   private reasoningAccumulator = "";
@@ -82,6 +105,17 @@ export class TurnEventMapper {
   private summaryTitle: string | undefined;
   /** Per-parent-call accumulators for nested subagent streams. */
   private readonly nested = new Map<string, NestedAccumulators>();
+  /** One wave per model step (or per call when the step id is missing). */
+  private readonly waves = new Map<string, ToolWave>();
+  /**
+   * Keys of waves that already emitted `actions.completed`, plus each
+   * finished call's singleton key. A late duplicate cannot reopen the
+   * batch or emit a second pair for the same callId. A new late callId
+   * still gets its own singleton.
+   */
+  private readonly sealedWaveKeys = new Set<string>();
+  /** Listed-call count from `tool-requests-listed`, keyed by parentCallId. */
+  private readonly listedCounts = new Map<string, number>();
 
   /**
    * @param isStubbed Reports whether a finished tool call was answered by the
@@ -173,17 +207,25 @@ export class TurnEventMapper {
       }
       case "tool-call-started": {
         this.flushAssistantText("tool_call");
-        this.emitToolStarted(update.callId, update.toolCall);
+        this.noteToolStarted(update.callId, update.toolCall, {
+          modelCallId: modelCallIdOf(update),
+        });
         return;
       }
       case "tool-call-completed": {
-        this.emitToolCompleted(update.callId, update.toolCall);
+        this.noteToolCompleted(update.callId, update.toolCall, {
+          modelCallId: modelCallIdOf(update),
+        });
         return;
       }
       case "step-started": {
         this.emit({ type: "step.started", data: { stepId: update.stepId } });
         return;
       }
+      case "tool-requests-listed": {
+        this.noteRequestsListed(undefined, update.callCount);
+        return;
+      }
       case "step-completed": {
         this.emit({
           type: "step.completed",
@@ -223,6 +265,8 @@ export class TurnEventMapper {
 
   /** Close out the turn: finalize any open assistant text block. */
   finish(): void {
+    this.sealOpenRequests();
+    this.flushOpenResults();
     this.flushAssistantText("stop");
     for (const parentCallId of this.nested.keys()) {
       this.flushNestedAssistantText(parentCallId, "stop");
@@ -273,15 +317,26 @@ export class TurnEventMapper {
       }
       case "tool-call-started": {
         this.flushNestedAssistantText(parentCallId, "tool_call");
-        this.emitToolStarted(update.callId, update.toolCall, parentCallId);
+        this.noteToolStarted(update.callId, update.toolCall, {
+          parentCallId,
+          modelCallId: modelCallIdOf(update),
+        });
         return;
       }
       case "tool-call-completed": {
-        this.emitToolCompleted(update.callId, update.toolCall, parentCallId);
+        this.noteToolCompleted(update.callId, update.toolCall, {
+          parentCallId,
+          modelCallId: modelCallIdOf(update),
+        });
         return;
       }
       case "partial-tool-call":
+        return;
       case "step-started":
+        return;
+      case "tool-requests-listed":
+        this.noteRequestsListed(parentCallId, update.callCount);
+        return;
       case "step-completed":
         return;
       default: {
@@ -290,22 +345,36 @@ export class TurnEventMapper {
     }
   }
 
-  private emitToolStarted(callId: string, toolCall: ToolCall, parentCallId?: string): void {
+  private noteToolStarted(
+    callId: string,
+    toolCall: ToolCall,
+    ids?: { parentCallId?: string; modelCallId?: string },
+  ): void {
+    const parentCallId = ids?.parentCallId;
+    const modelCallId = ids?.modelCallId;
     const description = describeToolCall(toolCall);
-    this.emit({
-      type: "actions.requested",
-      data: {
-        calls: [
-          {
-            callId,
-            toolName: description.toolName,
-            args: description.args,
-            parentCallId,
-          },
-        ],
+    const call: ActionCall = {
+      callId,
+      toolName: description.toolName,
+      args: description.args,
+      parentCallId,
+      modelCallId,
+    };
+    if (modelCallId !== undefined) {
+      this.sealOpenRequests({
         parentCallId,
-      },
-    });
+        exceptModelCallId: modelCallId,
+      });
+    }
+    const wave = this.waveForStart({ parentCallId, modelCallId, callId });
+    if (wave === undefined) {
+      return;
+    }
+    if (wave.calls.every(existing => existing.callId !== callId)) {
+      wave.calls.push(call);
+    }
+    this.adoptSingletonResults(wave, parentCallId, callId);
+    this.maybeSealListedWave(wave);
     // Subagent bookends only fire for the top-level task tool, not nested
     // tools inside a subagent (nested subagents aren't supported).
     if (description.subagent !== undefined && parentCallId === undefined) {
@@ -318,22 +387,44 @@ export class TurnEventMapper {
         },
       });
     }
+    if (wave.modelCallId === undefined) {
+      this.sealWaveRequests(wave);
+    }
   }
 
-  private emitToolCompleted(callId: string, toolCall: ToolCall, parentCallId?: string): void {
+  private noteToolCompleted(
+    callId: string,
+    toolCall: ToolCall,
+    ids?: { parentCallId?: string; modelCallId?: string },
+  ): void {
+    const parentCallId = ids?.parentCallId;
+    const modelCallId = ids?.modelCallId;
     const description = describeToolCall(toolCall);
     const result = describeToolResult(toolCall);
-    this.emit({
-      type: "action.result",
-      data: {
-        callId,
-        toolName: description.toolName,
-        output: result.output,
-        isError: result.isError,
-        ...(this.isStubbed(callId) ? { stubbed: true as const } : {}),
-        parentCallId,
-      },
-    });
+    const actionResult: ActionResult = {
+      callId,
+      toolName: description.toolName,
+      output: result.output,
+      isError: result.isError,
+      stubbed: this.isStubbed(callId) ? true : undefined,
+      parentCallId,
+      modelCallId,
+    };
+    const wave = this.waveForComplete({ parentCallId, modelCallId, callId });
+    if (wave === undefined) {
+      return;
+    }
+    const isNew = wave.results.every(existing => existing.callId !== callId);
+    if (isNew) {
+      wave.results.push(actionResult);
+    }
+    if (wave.requestedEmitted && isNew) {
+      this.emit({
+        type: "action.result",
+        data: actionResult,
+      });
+      this.maybeEmitActionsCompleted(wave);
+    }
     if (description.subagent !== undefined && parentCallId === undefined) {
       this.flushNestedAssistantText(callId, "stop");
       this.nested.delete(callId);
@@ -344,6 +435,242 @@ export class TurnEventMapper {
     }
   }
 
+  private callBelongsToWave(wave: ToolWave, callId: string): boolean {
+    return (
+      wave.calls.some(existing => existing.callId === callId) ||
+      wave.results.some(existing => existing.callId === callId)
+    );
+  }
+
+  private singletonWave(parentCallId: string | undefined, callId: string): ToolWave | undefined {
+    const key = waveKey({ parentCallId, callId });
+    if (this.sealedWaveKeys.has(key) && !this.waves.has(key)) {
+      return undefined;
+    }
+    return this.ensureWave(key, { parentCallId });
+  }
+
+  /**
+   * Starts join the open model-step wave until `actions.requested` seals.
+   * A later start for that same step is its own singleton pair so completed
+   * cannot list tools the matching requested envelope never had.
+   */
+  private waveForStart(ids: {
+    parentCallId?: string;
+    modelCallId?: string;
+    callId: string;
+  }): ToolWave | undefined {
+    const groupedKey = waveKey(ids);
+    const grouped = this.waves.get(groupedKey);
+    if (grouped !== undefined && !grouped.requestedEmitted) {
+      return grouped;
+    }
+    if (grouped !== undefined && this.callBelongsToWave(grouped, ids.callId)) {
+      return grouped;
+    }
+    if (grouped !== undefined && grouped.requestedEmitted) {
+      return this.singletonWave(ids.parentCallId, ids.callId);
+    }
+    if (this.sealedWaveKeys.has(groupedKey)) {
+      return this.singletonWave(ids.parentCallId, ids.callId);
+    }
+    return this.ensureWave(groupedKey, {
+      modelCallId: ids.modelCallId,
+      parentCallId: ids.parentCallId,
+    });
+  }
+
+  /**
+   * Completes join a model-step wave only when that call already started
+   * there. A start-less complete on an open sibling batch would flush with
+   * `actions.requested` and then block `actions.completed` forever.
+   */
+  private waveForComplete(ids: {
+    parentCallId?: string;
+    modelCallId?: string;
+    callId: string;
+  }): ToolWave | undefined {
+    const groupedKey = waveKey(ids);
+    const grouped = this.waves.get(groupedKey);
+    if (grouped !== undefined && this.callBelongsToWave(grouped, ids.callId)) {
+      return grouped;
+    }
+    if (grouped !== undefined) {
+      return this.singletonWave(ids.parentCallId, ids.callId);
+    }
+    if (this.sealedWaveKeys.has(groupedKey)) {
+      return this.waves.get(waveKey({ parentCallId: ids.parentCallId, callId: ids.callId }));
+    }
+    return this.ensureWave(groupedKey, {
+      modelCallId: ids.modelCallId,
+      parentCallId: ids.parentCallId,
+    });
+  }
+
+  private adoptSingletonResults(
+    wave: ToolWave,
+    parentCallId: string | undefined,
+    callId: string,
+  ): void {
+    const singletonKey = waveKey({ parentCallId, callId });
+    if (singletonKey === wave.key) {
+      return;
+    }
+    const singleton = this.waves.get(singletonKey);
+    if (singleton === undefined) {
+      return;
+    }
+    for (const result of singleton.results) {
+      if (wave.results.every(existing => existing.callId !== result.callId)) {
+        wave.results.push(result);
+      }
+    }
+    this.waves.delete(singletonKey);
+  }
+
+  private ensureWave(key: string, ids: { modelCallId?: string; parentCallId?: string }): ToolWave {
+    let wave = this.waves.get(key);
+    if (wave === undefined) {
+      const expectedCalls = this.listedCounts.get(ids.parentCallId ?? "");
+      wave = {
+        key,
+        modelCallId: ids.modelCallId,
+        parentCallId: ids.parentCallId,
+        expectedCalls,
+        calls: [],
+        results: [],
+        requestedEmitted: false,
+        completedEmitted: false,
+      };
+      this.waves.set(key, wave);
+    }
+    return wave;
+  }
+
+  private noteRequestsListed(parentCallId: string | undefined, callCount: number): void {
+    const listed = Math.max(0, callCount);
+    if (listed === 0) {
+      this.sealOpenRequests({ parentCallId });
+      this.listedCounts.delete(parentCallId ?? "");
+      return;
+    }
+    this.listedCounts.set(parentCallId ?? "", listed);
+    for (const wave of this.waves.values()) {
+      if (wave.parentCallId !== parentCallId || wave.requestedEmitted) {
+        continue;
+      }
+      wave.expectedCalls = listed;
+      this.maybeSealListedWave(wave);
+    }
+  }
+
+  private maybeSealListedWave(wave: ToolWave): void {
+    const expected = wave.expectedCalls ?? this.listedCounts.get(wave.parentCallId ?? "");
+    if (expected !== undefined && wave.calls.length >= expected) {
+      this.sealWaveRequests(wave);
+    }
+  }
+
+  private sealOpenRequests(ids?: { parentCallId?: string; exceptModelCallId?: string }): void {
+    const parentCallId = ids?.parentCallId;
+    const exceptModelCallId = ids?.exceptModelCallId;
+    for (const wave of this.waves.values()) {
+      if (wave.parentCallId !== parentCallId) {
+        continue;
+      }
+      if (exceptModelCallId !== undefined && wave.modelCallId === exceptModelCallId) {
+        continue;
+      }
+      this.sealWaveRequests(wave);
+    }
+  }
+
+  private sealWaveRequests(wave: ToolWave): void {
+    if (wave.requestedEmitted || wave.calls.length === 0) {
+      return;
+    }
+    wave.requestedEmitted = true;
+    this.listedCounts.delete(wave.parentCallId ?? "");
+    this.emit({
+      type: "actions.requested",
+      data: {
+        calls: wave.calls,
+        parentCallId: wave.parentCallId,
+        modelCallId: wave.modelCallId,
+      },
+    });
+    for (const result of wave.results) {
+      this.emit({
+        type: "action.result",
+        data: result,
+      });
+    }
+    this.maybeEmitActionsCompleted(wave);
+  }
+
+  private maybeEmitActionsCompleted(wave: ToolWave): void {
+    if (
+      wave.completedEmitted ||
+      !wave.requestedEmitted ||
+      wave.calls.length === 0 ||
+      wave.results.length < wave.calls.length
+    ) {
+      return;
+    }
+    const callIds = new Set(wave.calls.map(call => call.callId));
+    if (!wave.results.every(result => callIds.has(result.callId))) {
+      return;
+    }
+    if (!wave.calls.every(call => wave.results.some(result => result.callId === call.callId))) {
+      return;
+    }
+    this.emitActionsCompleted(wave);
+  }
+
+  private emitActionsCompleted(wave: ToolWave): void {
+    wave.completedEmitted = true;
+    this.emit({
+      type: "actions.completed",
+      data: {
+        results: wave.results,
+        parentCallId: wave.parentCallId,
+        modelCallId: wave.modelCallId,
+      },
+    });
+    this.forgetWave(wave);
+  }
+
+  private forgetWave(wave: ToolWave): void {
+    this.waves.delete(wave.key);
+    this.sealedWaveKeys.add(wave.key);
+    for (const callId of new Set([
+      ...wave.calls.map(call => call.callId),
+      ...wave.results.map(result => result.callId),
+    ])) {
+      this.sealedWaveKeys.add(waveKey({ parentCallId: wave.parentCallId, callId }));
+    }
+    wave.calls = [];
+    wave.results = [];
+  }
+
+  private flushOpenResults(): void {
+    for (const wave of [...this.waves.values()]) {
+      if (wave.calls.length === 0 && wave.results.length > 0) {
+        wave.calls = wave.results.map(result => ({
+          callId: result.callId,
+          toolName: result.toolName,
+          parentCallId: result.parentCallId,
+          modelCallId: result.modelCallId,
+        }));
+      }
+      this.sealWaveRequests(wave);
+      this.maybeEmitActionsCompleted(wave);
+      if (!wave.completedEmitted) {
+        this.forgetWave(wave);
+      }
+    }
+  }
+
   private ensureNested(parentCallId: string): NestedAccumulators {
     let acc = this.nested.get(parentCallId);
     if (acc === undefined) {
@@ -415,10 +742,10 @@ export function describeToolCall(toolCall: ToolCall): ToolCallDescription {
         toolName: "task",
         args: {
           description: toolCall.args.description,
-          ...(subagentName === undefined ? {} : { subagentType: subagentName }),
+          subagentType: subagentName,
         },
         subagent: {
-          ...(subagentName === undefined ? {} : { name: subagentName }),
+          name: subagentName,
           description: toolCall.args.description,
         },
       };
@@ -462,6 +789,10 @@ export function describeToolResult(toolCall: ToolCall): ToolResultDescription {
   return { output: result.value, isError: false };
 }
 
+function waveKey(ids: { parentCallId?: string; modelCallId?: string; callId: string }): string {
+  return `${ids.parentCallId ?? ""}:${ids.modelCallId ?? `call:${ids.callId}`}`;
+}
+
 function addUsage(total: TurnUsage | undefined, usage: TurnUsage): TurnUsage {
   if (total === undefined) {
     return { ...usage };

package/src/internal/hosted-delivery-protocol.ts

@@ -1,3 +1,9 @@
+/**
+ * Private control-plane/engine wire contract. Version 2 is unreleased and
+ * intentionally strict: unknown fields and modes fail closed. After release,
+ * any shape or semantic change must use a new version and a rolling
+ * compatibility window. See `docs/agent-serve/hosted-delivery-protocol.md`.
+ */
 export const HOSTED_DELIVERY_PROTOCOL_VERSION = 2;
 export const HOSTED_DELIVERY_HEADER = "x-agent-sdk-hosted-delivery";
 export const HOSTED_ADMISSION_PATH = "/v1/internal/hosted-admission";
@@ -251,7 +257,7 @@ export type HostedAdmissionPlatformHandoff = {
   };
 };
 
-export type HostedAdmission = {
+export type HostedAdmissionInput = {
   v: 2;
   channelId: string;
   /**
@@ -270,9 +276,20 @@ export type HostedAdmission = {
   platformHandoff?: HostedAdmissionPlatformHandoff;
 };
 
+export type HostedAdmissionStart = HostedAdmissionInput & { mode: "start" };
+
+export type HostedAdmissionStatus = {
+  v: 2;
+  mode: "status";
+  deliveryId: string;
+};
+
+export type HostedAdmission = HostedAdmissionStart | HostedAdmissionStatus;
+
 export type HostedAdmissionOutcome =
   | { ok: true; v: 2; outcome: "skip" | "task" }
-  | { ok: true; v: 2; outcome: "send"; admissionToken: string };
+  | { ok: true; v: 2; outcome: "send"; admissionToken: string }
+  | { ok: true; v: 2; outcome: "started" | "running" };
 
 /**
  * Cap on delivery IDs an owner execute may report as consumed (primary +
@@ -281,19 +298,19 @@ export type HostedAdmissionOutcome =
  */
 export const HOSTED_MAX_CONSUMED_DELIVERY_IDS = 16;
 
-/** Hosted-execution run mode. Omitted/`execute` is the legacy wait path. */
-export type HostedExecutionMode = "execute" | "enqueue";
+/** Hosted-execution is unary: start/status for owners, enqueue for guests. */
+export type HostedExecutionMode = "enqueue" | "start" | "status";
 
 export type HostedExecution = {
   v: 2;
   admissionToken: string;
   sessionPublicId: string;
   /**
-   * `execute` (default when omitted) runs the owner send and waits for the
-   * coalesce chain. `enqueue` injects into an accepting owner or returns
-   * `not_active`.
+   * `enqueue` injects into an accepting owner or returns `not_active`.
+   * `start` launches the owner turn and returns `started` immediately.
+   * `status` returns `running` or replays the terminal response.
    */
-  mode?: HostedExecutionMode;
+  mode: HostedExecutionMode;
 };
 
 export type HostedExecutionOutcome =
@@ -303,16 +320,17 @@ export type HostedExecutionOutcome =
       outcome: "send";
       /**
        * Primary delivery id then accepted enqueue ids; length 1..16.
-       * Optional for old-guest compatibility; callers must normalize absent
-       * lists to `[primaryDeliveryId]`.
        */
-      consumedDeliveryIds?: string[];
+      consumedDeliveryIds: string[];
     }
   | { ok: true; v: 2; outcome: "enqueued" }
-  | { ok: true; v: 2; outcome: "not_active" };
+  | { ok: true; v: 2; outcome: "not_active" }
+  | { ok: true; v: 2; outcome: "started" }
+  | { ok: true; v: 2; outcome: "running" };
 
 const DELIVERY_KEYS = new Set([
   "v",
+  "mode",
   "channelId",
   "channelKind",
   "eventType",
@@ -435,10 +453,18 @@ export function parseHostedAdmission(value: unknown): HostedAdmission | undefine
     return undefined;
   }
   const body = value as Record<string, unknown>;
+  if (body.mode === "status") {
+    return Object.keys(body).every(key => key === "v" || key === "mode" || key === "deliveryId") &&
+      body.v === HOSTED_DELIVERY_PROTOCOL_VERSION &&
+      boundedString(body.deliveryId, 256)
+      ? (body as HostedAdmissionStatus)
+      : undefined;
+  }
   if (
     Object.keys(body).some(key => !DELIVERY_KEYS.has(key)) ||
     !Object.hasOwn(body, "payload") ||
     body.v !== HOSTED_DELIVERY_PROTOCOL_VERSION ||
+    body.mode !== "start" ||
     !boundedString(body.channelId, 128) ||
     !boundedString(body.channelKind, 128) ||
     !boundedString(body.eventType, 128) ||
@@ -468,7 +494,7 @@ export function parseHostedExecution(value: unknown): HostedExecution | undefine
   ) {
     return undefined;
   }
-  if (body.mode !== undefined && body.mode !== "execute" && body.mode !== "enqueue") {
+  if (body.mode !== "enqueue" && body.mode !== "start" && body.mode !== "status") {
     return undefined;
   }
   return body as HostedExecution;
@@ -501,7 +527,12 @@ export function parseHostedExecutionOutcome(value: unknown): HostedExecutionOutc
   ) {
     return undefined;
   }
-  if (body.outcome === "enqueued" || body.outcome === "not_active") {
+  if (
+    body.outcome === "enqueued" ||
+    body.outcome === "not_active" ||
+    body.outcome === "started" ||
+    body.outcome === "running"
+  ) {
     if (body.consumedDeliveryIds !== undefined) {
       return undefined;
     }
@@ -510,10 +541,6 @@ export function parseHostedExecutionOutcome(value: unknown): HostedExecutionOutc
   if (body.outcome !== "send") {
     return undefined;
   }
-  // Old guests omit consumedDeliveryIds; accept and let callers normalize.
-  if (body.consumedDeliveryIds === undefined) {
-    return { ok: true, v: 2, outcome: "send" };
-  }
   const consumedDeliveryIds = parseConsumedDeliveryIds(body.consumedDeliveryIds);
   if (consumedDeliveryIds === undefined) {
     return undefined;
@@ -530,7 +557,7 @@ export function parseHostedExecutionOutcome(value: unknown): HostedExecutionOutc
  * True when the admission envelope is the reserved internal reminder fire
  * path (not an authored channel event).
  */
-export function isHostedReminderAdmission(delivery: HostedAdmission): boolean {
+export function isHostedReminderAdmission(delivery: HostedAdmissionInput): boolean {
   return (
     delivery.channelKind === HOSTED_REMINDER_CHANNEL_KIND &&
     delivery.eventType === HOSTED_REMINDER_EVENT_TYPE
@@ -768,20 +795,30 @@ export function parseHostedReminderFireDescriptorPayload(
   };
 }
 
+const HOSTED_ADMISSION_OUTCOME_KEYS = new Set(["ok", "v", "outcome", "admissionToken"]);
+
 export function parseHostedAdmissionOutcome(value: unknown): HostedAdmissionOutcome | undefined {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
     return undefined;
   }
   const body = value as Record<string, unknown>;
   if (
+    Object.keys(body).some(key => !HOSTED_ADMISSION_OUTCOME_KEYS.has(key)) ||
     body.ok !== true ||
     body.v !== HOSTED_DELIVERY_PROTOCOL_VERSION ||
-    (body.outcome !== "skip" && body.outcome !== "send" && body.outcome !== "task")
+    (body.outcome !== "skip" &&
+      body.outcome !== "send" &&
+      body.outcome !== "task" &&
+      body.outcome !== "started" &&
+      body.outcome !== "running")
   ) {
     return undefined;
   }
   if (body.outcome === "send" && !boundedString(body.admissionToken, 128)) {
     return undefined;
   }
+  if (body.outcome !== "send" && Object.hasOwn(body, "admissionToken")) {
+    return undefined;
+  }
   return body as HostedAdmissionOutcome;
 }