@agen-ai/agent-runtime 0.3.1 → 0.4.1

package/dist/sessionValidation.js

@@ -9,8 +9,6 @@ import {
   parseAgentGeneratedResourceId,
   parseAgentOperationInvocation,
   parseAgentOperationInvocationFor,
-  parseAgentRequestResolution,
-  parseAgentRequestResolutionFor,
   parseAgentSessionBinding,
   parseAgentTurnId,
   parseAgentTurnInputContent,
@@ -32,8 +30,12 @@ import {
 } from "./interactionValidation.js";
 import {
   AgentProviderDelegatedOperationError,
+  AgentProviderSessionCleanupError,
   throwAgentProviderContractError
 } from "./contractErrors.js";
+import { createAgentHostBindingCleanupError } from "./hostBindings/lifetime.js";
+import { associateAgentSessionCleanupError } from "./sessionCleanup.js";
+import { hasExactOwnKeys } from "./internal/objectShape.js";
 import {
   throwIfAgentOperationAborted
 } from "./foundation.js";
@@ -42,18 +44,17 @@ import {
   validateAgentProviderOutputForContext
 } from "./outputValidation.js";
 import { validateAgentTurnSteeringResult } from "./steeringValidation.js";
-function hasExactOwnKeys(candidate, expectedKeys) {
-  const ownKeys = Reflect.ownKeys(candidate);
-  if (ownKeys.some((key) => typeof key !== "string")) return false;
-  const actualKeys = ownKeys.sort();
-  const canonicalExpectedKeys = [...expectedKeys].sort();
-  return actualKeys.length === canonicalExpectedKeys.length && actualKeys.every((key, index) => key === canonicalExpectedKeys[index]);
+import { createValidatedAgentTurnExecution } from "./turnExecution/execution.js";
+import { validateAgentProviderTurnInterruptionResult } from "./turnExecution/receipts.js";
+function validateCloseReason(reason) {
+  if (reason !== void 0 && !["idle", "shutdown", "replaced", "contract_rejected", "error", "other"].includes(reason)) {
+    throw new TypeError("Provider session close reason is unsupported.");
+  }
 }
 function validateSessionPorts(capabilities, session) {
   if (!hasExactOwnKeys(session, [
     "binding",
-    "runTurn",
-    "resolveRequest",
+    "startTurn",
     "interruption",
     "steering",
     "configuration",
@@ -63,7 +64,7 @@ function validateSessionPorts(capabilities, session) {
     "collaboration",
     "generatedResources",
     "close"
-  ]) || typeof session.runTurn !== "function" || typeof session.resolveRequest !== "function" || typeof session.close !== "function" || session.interruption === null || typeof session.interruption !== "object" || !["supported", "unsupported"].includes(session.interruption.kind) || session.steering === null || typeof session.steering !== "object" || !["supported", "unsupported"].includes(session.steering.kind) || session.configuration === null || typeof session.configuration !== "object" || !["managed", "selectable"].includes(session.configuration.kind) || session.operations === null || typeof session.operations !== "object" || !["supported", "unsupported"].includes(session.operations.kind) || session.managedContent === null || typeof session.managedContent !== "object" || !["supported", "unsupported"].includes(session.managedContent.kind) || session.environment === null || typeof session.environment !== "object" || !["read", "read_and_watch", "unsupported"].includes(session.environment.kind) || session.collaboration === null || typeof session.collaboration !== "object" || !["supported", "unsupported"].includes(session.collaboration.kind) || session.generatedResources === null || typeof session.generatedResources !== "object" || !["supported", "unsupported"].includes(session.generatedResources.kind)) {
+  ]) || typeof session.startTurn !== "function" || typeof session.close !== "function" || session.interruption === null || typeof session.interruption !== "object" || !["supported", "unsupported"].includes(session.interruption.kind) || session.steering === null || typeof session.steering !== "object" || !["supported", "unsupported"].includes(session.steering.kind) || session.configuration === null || typeof session.configuration !== "object" || !["managed", "selectable"].includes(session.configuration.kind) || session.operations === null || typeof session.operations !== "object" || !["supported", "unsupported"].includes(session.operations.kind) || session.managedContent === null || typeof session.managedContent !== "object" || !["supported", "unsupported"].includes(session.managedContent.kind) || session.environment === null || typeof session.environment !== "object" || !["read", "read_and_watch", "unsupported"].includes(session.environment.kind) || session.collaboration === null || typeof session.collaboration !== "object" || !["supported", "unsupported"].includes(session.collaboration.kind) || session.generatedResources === null || typeof session.generatedResources !== "object" || !["supported", "unsupported"].includes(session.generatedResources.kind)) {
     throwAgentProviderContractError(
       capabilities.providerKey,
       "invalid_session",
@@ -169,7 +170,6 @@ function completeTurnSequence(input) {
     );
   }
   input.state.terminal = true;
-  input.state.waiting = false;
 }
 const FINAL_DIFF_TRAILING_EVENT_TYPES = [
   "artifact.referenced",
@@ -305,6 +305,7 @@ function observeTurnEvent(input) {
     contextUsageState,
     event,
     openedRequestIds,
+    turnRequestIds,
     pendingRequests,
     providerKey,
     state
@@ -399,14 +400,15 @@ function observeTurnEvent(input) {
       state
     });
     openedRequestIds.add(requestId);
+    turnRequestIds.add(requestId);
     pendingRequests.set(requestId, {
       request: event.payload.request,
       turnId: event.turnId
     });
   }
   if (event.type === "turn.state_changed") {
-    state.waiting = event.payload.state === "waiting_for_request";
-    if (state.waiting && !pendingRequests.has(event.payload.requestId)) {
+    const waiting = event.payload.state === "waiting_for_request";
+    if (waiting && !turnRequestIds.has(event.payload.requestId)) {
       invalidTurnSequence(
         providerKey,
         "Provider entered a waiting state for a request it did not open."
@@ -414,6 +416,7 @@ function observeTurnEvent(input) {
     }
   }
   if (event.type === "turn.completed") {
+    if (event.payload.outcome !== "completed") pendingRequests.clear();
     completeTurnSequence({ providerKey, state, pendingRequests });
   }
 }
@@ -506,6 +509,7 @@ function observeTurnOutput(input) {
     state: input.state,
     pendingRequests: input.pendingRequests,
     openedRequestIds: input.openedRequestIds,
+    turnRequestIds: input.turnRequestIds,
     contextUsageState: input.contextUsageState
   });
 }
@@ -544,23 +548,11 @@ function observeSessionOperationOutput(input) {
     state: input.state,
     pendingRequests: /* @__PURE__ */ new Map(),
     openedRequestIds: /* @__PURE__ */ new Set(),
+    turnRequestIds: /* @__PURE__ */ new Set(),
     contextUsageState: input.contextUsageState,
     interactionState: input.interactionState
   });
 }
-function assertStableTurnBoundary(input) {
-  const terminal = input.state.terminal && !input.state.waiting;
-  const waiting = !input.state.terminal && input.state.waiting && input.pendingRequests.size === 1;
-  if (terminal && input.pendingRequests.size === 0 || waiting) return;
-  invalidTurnSequence(
-    input.providerKey,
-    "Provider turn must finish with completion or exactly one pending request."
-  );
-}
-function replacePendingRequests(target, source) {
-  target.clear();
-  for (const [requestId, pending] of source) target.set(requestId, pending);
-}
 function trackActiveTurnOperation(turn) {
   if (!turn) return null;
   let settle;
@@ -573,45 +565,6 @@ function trackActiveTurnOperation(turn) {
     settle();
   };
 }
-function interruptionTerminalizesTurn(input) {
-  if (["completed", "canceled"].includes(input.result.status)) {
-    return true;
-  }
-  return (input.result.outputs ?? []).some(
-    (output) => output.kind === "event" && output.event.turnId === input.turnId && output.event.type === "turn.completed"
-  );
-}
-function observeTurnOperationOutputs(input) {
-  for (const output of input.outputs ?? []) {
-    observeTurnOutput({
-      providerKey: input.providerKey,
-      output,
-      state: input.state,
-      pendingRequests: input.pendingRequests,
-      openedRequestIds: input.openedRequestIds,
-      contextUsageState: input.contextUsageState,
-      capabilities: input.capabilities,
-      interactionState: input.interactionState
-    });
-  }
-}
-function reconstructWaitingTurn(input) {
-  const targetedPendingRequests = new Map(
-    [...input.pendingRequests].filter(
-      ([, pending]) => pending.turnId === input.turnId
-    )
-  );
-  if (targetedPendingRequests.size === 0 || input.state === void 0 || input.state.terminal || !input.state.waiting) return null;
-  return {
-    state: input.state,
-    pendingRequests: targetedPendingRequests
-  };
-}
-function clearPendingRequestsForTurn(pendingRequests, turnId) {
-  for (const [requestId, pending] of pendingRequests) {
-    if (pending.turnId === turnId) pendingRequests.delete(requestId);
-  }
-}
 function assertAgentTurnInputCapability(input) {
   const imageParts = input.parts.filter((part) => part.type === "image");
   if (imageParts.length > 0) {
@@ -726,8 +679,6 @@ function validateAgentProviderSession(input) {
     port: input.candidate.environment,
     signal: sessionLifetime.signal
   });
-  const pendingRequests = /* @__PURE__ */ new Map();
-  const waitingTurnStates = /* @__PURE__ */ new Map();
   const openedRequestIds = /* @__PURE__ */ new Set();
   const contextUsageState = {
     latestByScope: /* @__PURE__ */ new Map(),
@@ -746,6 +697,7 @@ function validateAgentProviderSession(input) {
   let activeTurn = null;
   let closePromise = null;
   let closed = false;
+  let providerClosed = false;
   let unusable = false;
   const requireOpen = () => {
     if (closed)
@@ -756,6 +708,7 @@ function validateAgentProviderSession(input) {
       );
   };
   const requireUsable = () => {
+    input.sessionInteractionOwner?.requireUsable();
     requireOpen();
     if (unusable) {
       throwAgentProviderContractError(
@@ -771,17 +724,6 @@ function validateAgentProviderSession(input) {
     sessionId,
     ...turnId === void 0 ? {} : { turnId }
   });
-  const delegateOperation = async (operation, turnId) => {
-    try {
-      return validateAgentProviderOperationResult(
-        await operation(),
-        outputContext(turnId)
-      );
-    } catch (error) {
-      unusable = true;
-      throw error;
-    }
-  };
   const delegateProviderMutation = async (input2) => {
     let executionStarted = false;
     const onProviderExecutionStarted = () => {
@@ -806,6 +748,7 @@ function validateAgentProviderSession(input) {
       await input2.observeOutput?.(candidate);
     };
     try {
+      requireUsable();
       const candidate = await input2.invoke(onProviderExecutionStarted, onOutput);
       if (!executionStarted) {
         throwAgentProviderContractError(
@@ -825,7 +768,7 @@ function validateAgentProviderSession(input) {
       );
     }
   };
-  const runTurn = async function* (turnInput) {
+  const startTurn = (turnInput) => {
     requireUsable();
     throwIfAgentOperationAborted(turnInput.signal);
     const parsedInput = parseAgentTurnRunInput({
@@ -835,11 +778,7 @@ function validateAgentProviderSession(input) {
       ...turnInput.summary === void 0 ? {} : { summary: turnInput.summary },
       ...turnInput.deadlineAt === void 0 ? {} : { deadlineAt: turnInput.deadlineAt }
     });
-    assertAgentTurnInputCapability({
-      capability: capabilities.input,
-      parts: parsedInput.parts,
-      providerKey
-    });
+    assertAgentTurnInputCapability({ capability: capabilities.input, parts: parsedInput.parts, providerKey });
     if (!capabilities.turns.interactionModes.includes(parsedInput.interactionMode)) {
       throwAgentProviderContractError(
         providerKey,
@@ -847,179 +786,63 @@ function validateAgentProviderSession(input) {
         `Provider ${providerKey} does not support ${parsedInput.interactionMode} turn interaction mode.`
       );
     }
-    if (pendingRequests.size > 0) {
-      throwAgentProviderContractError(
-        providerKey,
-        "request_pending",
-        "Provider session cannot start another turn while a request is pending."
-      );
-    }
     if (activeTurn !== null) {
-      throwAgentProviderContractError(
-        providerKey,
-        "concurrent_turn",
-        "Provider session already has an active turn."
-      );
+      throwAgentProviderContractError(providerKey, "concurrent_turn", "Provider session already has an active turn.");
     }
-    let reachedStableBoundary = false;
-    const currentTurn = {
-      turnId: parsedInput.turnId,
-      pendingRequests: /* @__PURE__ */ new Map(),
-      state: {
-        fileChangeMode: capabilities.output.fileChanges,
-        observedItems: /* @__PURE__ */ new Map(),
-        proposedPlans: /* @__PURE__ */ new Map(),
-        generatedResourceIds: /* @__PURE__ */ new Set(),
-        started: false,
-        terminal: false,
-        waiting: false,
-        finalDiffObserved: false
-      },
-      inFlightOperations: /* @__PURE__ */ new Set()
+    const pendingRequests = /* @__PURE__ */ new Map();
+    const turnRequestIds = /* @__PURE__ */ new Set();
+    const state = {
+      fileChangeMode: capabilities.output.fileChanges,
+      observedItems: /* @__PURE__ */ new Map(),
+      proposedPlans: /* @__PURE__ */ new Map(),
+      generatedResourceIds: /* @__PURE__ */ new Set(),
+      started: false,
+      terminal: false,
+      finalDiffObserved: false
     };
-    activeTurn = currentTurn;
-    try {
-      turnInput.onProviderExecutionStarted?.();
-      for await (const candidate of input.candidate.runTurn({
+    const inFlightOperations = /* @__PURE__ */ new Set();
+    const owner = createValidatedAgentTurnExecution({
+      providerKey,
+      turnInput: {
         ...parsedInput,
-        ...turnInput.signal === void 0 ? {} : { signal: turnInput.signal }
-      })) {
-        const output = validateAgentProviderOutputForContext(
-          candidate,
-          outputContext(parsedInput.turnId)
-        );
-        observeTurnOutput({
-          capabilities,
-          providerKey,
-          output,
-          state: currentTurn.state,
-          pendingRequests: currentTurn.pendingRequests,
-          openedRequestIds,
-          contextUsageState,
-          interactionState
-        });
-        yield output;
-      }
-      while (currentTurn.inFlightOperations.size > 0) {
-        await Promise.all(currentTurn.inFlightOperations);
-      }
-      if (!currentTurn.state.started) {
-        invalidTurnSequence(
-          providerKey,
-          "Provider turn must emit turn.started before reaching a stable boundary."
-        );
-      }
-      assertStableTurnBoundary({
-        providerKey,
-        state: currentTurn.state,
-        pendingRequests: currentTurn.pendingRequests
-      });
-      if (currentTurn.state.waiting) {
-        replacePendingRequests(pendingRequests, currentTurn.pendingRequests);
-        waitingTurnStates.set(currentTurn.turnId, currentTurn.state);
-      } else {
-        waitingTurnStates.delete(currentTurn.turnId);
-      }
-      reachedStableBoundary = true;
-    } finally {
-      if (!reachedStableBoundary) unusable = true;
-      if (activeTurn === currentTurn) activeTurn = null;
-    }
-  };
-  const resolveRequest = async function* (requestInput) {
-    requireUsable();
-    throwIfAgentOperationAborted(requestInput.signal);
-    const resolution = parseAgentRequestResolution(requestInput.resolution);
-    const pending = pendingRequests.get(resolution.requestId);
-    if (!pending) {
-      throwAgentProviderContractError(
-        providerKey,
-        "request_resolution_mismatch",
-        "Provider request resolution does not identify a pending request."
-      );
-    }
-    try {
-      parseAgentRequestResolutionFor(pending.request, resolution);
-    } catch {
-      throwAgentProviderContractError(
-        providerKey,
-        "request_resolution_mismatch",
-        "Provider request resolution does not match the opened request."
-      );
-    }
-    if (pending.request.expiresAt !== void 0 && Date.parse(pending.request.expiresAt) <= Date.now() && resolution.disposition !== "canceled") {
-      throwAgentProviderContractError(
-        providerKey,
-        "request_resolution_mismatch",
-        "Provider request resolution identifies an expired request."
-      );
-    }
-    const nextPendingRequests = new Map(pendingRequests);
-    nextPendingRequests.delete(resolution.requestId);
-    if (activeTurn !== null) {
-      throwAgentProviderContractError(
-        providerKey,
-        "concurrent_turn",
-        "Provider session already has an active turn."
-      );
-    }
-    const waitingTurnState = waitingTurnStates.get(pending.turnId);
-    if (waitingTurnState === void 0 || waitingTurnState.terminal || !waitingTurnState.waiting) {
-      throwAgentProviderContractError(
-        providerKey,
-        "request_resolution_mismatch",
-        "Provider request resolution does not identify a waiting turn."
-      );
-    }
-    waitingTurnState.waiting = false;
-    const currentTurn = {
-      turnId: pending.turnId,
-      pendingRequests: nextPendingRequests,
-      state: waitingTurnState,
-      inFlightOperations: /* @__PURE__ */ new Set()
-    };
-    let reachedStableBoundary = false;
-    activeTurn = currentTurn;
-    try {
-      for await (const candidate of input.candidate.resolveRequest({
-        resolution,
-        ...requestInput.signal === void 0 ? {} : { signal: requestInput.signal }
-      })) {
-        const output = validateAgentProviderOutputForContext(
-          candidate,
-          outputContext(pending.turnId)
-        );
+        ...turnInput.signal === void 0 ? {} : { signal: turnInput.signal },
+        ...turnInput.onProviderExecutionStarted === void 0 ? {} : { onProviderExecutionStarted: turnInput.onProviderExecutionStarted }
+      },
+      pendingRequests,
+      inFlightOperations,
+      start: (inputTurn) => input.candidate.startTurn(inputTurn),
+      requireUsable,
+      isTerminal: () => state.terminal,
+      observe(candidate) {
+        const output = validateAgentProviderOutputForContext(candidate, outputContext(parsedInput.turnId));
         observeTurnOutput({
           capabilities,
           providerKey,
           output,
-          state: currentTurn.state,
-          pendingRequests: currentTurn.pendingRequests,
+          state,
+          pendingRequests,
           openedRequestIds,
+          turnRequestIds,
           contextUsageState,
           interactionState
         });
-        yield output;
-      }
-      while (currentTurn.inFlightOperations.size > 0) {
-        await Promise.all(currentTurn.inFlightOperations);
-      }
-      assertStableTurnBoundary({
-        providerKey,
-        state: currentTurn.state,
-        pendingRequests: currentTurn.pendingRequests
-      });
-      replacePendingRequests(pendingRequests, currentTurn.pendingRequests);
-      if (currentTurn.state.waiting) {
-        waitingTurnStates.set(currentTurn.turnId, currentTurn.state);
-      } else {
-        waitingTurnStates.delete(currentTurn.turnId);
-      }
-      reachedStableBoundary = true;
-    } finally {
-      if (!reachedStableBoundary) unusable = true;
-      if (activeTurn === currentTurn) activeTurn = null;
-    }
+        return output;
+      },
+      assertCompleted() {
+        if (!state.started || !state.terminal || pendingRequests.size > 0) {
+          invalidTurnSequence(providerKey, "Provider turn output must remain open until actual terminal completion.");
+        }
+      },
+      release() {
+        if (activeTurn?.owner === owner) activeTurn = null;
+      },
+      retire() {
+        unusable = true;
+      },
+      abandon: () => close({ reason: "other" })
+    });
+    activeTurn = { turnId: parsedInput.turnId, pendingRequests, state, inFlightOperations, owner };
+    return owner.execution;
   };
   const declaredInterruption = input.candidate.interruption;
   const interruption = declaredInterruption.kind === "unsupported" ? Object.freeze({ kind: "unsupported" }) : Object.freeze({
@@ -1033,68 +856,36 @@ function validateAgentProviderSession(input) {
         ...interruptionInput.requestedAt === void 0 ? {} : { requestedAt: interruptionInput.requestedAt }
       });
       const targetedActiveTurn = activeTurn?.turnId === parsed.turnId ? activeTurn : null;
-      const targetedWaitingTurn = targetedActiveTurn === null ? reconstructWaitingTurn({
-        pendingRequests,
-        turnId: parsed.turnId,
-        state: waitingTurnStates.get(parsed.turnId)
-      }) : null;
-      const targetedTurn = targetedActiveTurn ?? targetedWaitingTurn;
-      if (targetedTurn === null) {
+      const targetedTurn = targetedActiveTurn;
+      if (targetedTurn === null || targetedTurn.state.terminal || !targetedTurn.owner.hasEntered()) {
         throwAgentProviderContractError(
           providerKey,
           "active_turn_mismatch",
-          "Provider interruption does not identify an active or waiting turn."
+          "Provider interruption does not identify an active turn."
         );
       }
       const settleActiveInterruption = trackActiveTurnOperation(
         targetedActiveTurn
       );
       try {
-        const result = await delegateOperation(
-          () => declaredInterruption.interruptTurn({
-            ...parsed,
-            ...interruptionInput.signal === void 0 ? {} : { signal: interruptionInput.signal }
-          }),
-          parsed.turnId
-        );
-        const terminalized = interruptionTerminalizesTurn({
-          turnId: parsed.turnId,
-          result
-        });
-        if (terminalized || result.status === "accepted") {
-          clearPendingRequestsForTurn(pendingRequests, parsed.turnId);
-          clearPendingRequestsForTurn(
-            targetedTurn.pendingRequests,
-            parsed.turnId
-          );
-          targetedTurn.state.waiting = false;
-          waitingTurnStates.delete(parsed.turnId);
-        }
+        const suspendedRequests = targetedTurn.owner.suspendRequests();
+        let result;
         try {
-          observeTurnOperationOutputs({
-            capabilities,
-            providerKey,
-            outputs: result.outputs,
-            state: targetedTurn.state,
-            pendingRequests: targetedTurn.pendingRequests,
-            openedRequestIds,
-            contextUsageState,
-            interactionState
-          });
-          if (terminalized && !targetedTurn.state.terminal) {
-            completeTurnSequence({
-              providerKey,
-              state: targetedTurn.state,
-              pendingRequests: targetedTurn.pendingRequests
-            });
-          }
+          result = validateAgentProviderTurnInterruptionResult(
+            await declaredInterruption.interruptTurn({
+              ...parsed,
+              ...interruptionInput.signal === void 0 ? {} : { signal: interruptionInput.signal }
+            }),
+            outputContext(parsed.turnId)
+          );
         } catch (error) {
+          suspendedRequests.withdraw();
           unusable = true;
           throw error;
         }
-        if (result.status === "accepted" && targetedWaitingTurn !== null && !terminalized) {
-          unusable = true;
-        }
+        if (result.status === "failed") {
+          suspendedRequests.restore();
+        } else suspendedRequests.withdraw();
         return result;
       } finally {
         settleActiveInterruption?.();
@@ -1108,7 +899,7 @@ function validateAgentProviderSession(input) {
       requireUsable();
       throwIfAgentOperationAborted(steeringInput.signal);
       const turnId = parseAgentTurnId(steeringInput.turnId);
-      if (activeTurn?.turnId !== turnId || activeTurn.state.terminal || activeTurn.state.waiting) {
+      if (activeTurn?.turnId !== turnId || !activeTurn.owner.hasEntered() || activeTurn.state.terminal || activeTurn.pendingRequests.size > 0) {
         throwAgentProviderContractError(
           providerKey,
           "active_turn_mismatch",
@@ -1128,7 +919,7 @@ function validateAgentProviderSession(input) {
       const settleSteering = trackActiveTurnOperation(targetedActiveTurn);
       try {
         try {
-          return validateAgentTurnSteeringResult(
+          const result = validateAgentTurnSteeringResult(
             await declaredSteering.steerTurn({
               turnId,
               ...content,
@@ -1136,6 +927,8 @@ function validateAgentProviderSession(input) {
             }),
             providerKey
           );
+          if (result.status === "delivery_uncertain") unusable = true;
+          return result;
         } catch (error) {
           unusable = true;
           throw new AgentProviderDelegatedOperationError(
@@ -1287,7 +1080,6 @@ function validateAgentProviderSession(input) {
         generatedResourceIds: /* @__PURE__ */ new Set(),
         started: true,
         terminal: false,
-        waiting: false,
         finalDiffObserved: false
       };
       interactionState.operationInvocations.set(
@@ -1601,33 +1393,37 @@ function validateAgentProviderSession(input) {
       return inspection;
     }
   });
-  const close = (closeInput) => {
-    if (closed) return Promise.resolve();
-    if (closePromise) return closePromise;
+  const closeOwned = (closeInput, explicit) => {
+    if (closed && !input.sessionInteractionOwner) return Promise.resolve();
+    if (!input.sessionInteractionOwner && closePromise) return closePromise;
     throwIfAgentOperationAborted(closeInput.signal);
-    if (closeInput.reason !== void 0 && ![
-      "idle",
-      "shutdown",
-      "replaced",
-      "contract_rejected",
-      "error",
-      "other"
-    ].includes(closeInput.reason)) {
-      throw new TypeError("Provider session close reason is unsupported.");
-    }
+    validateCloseReason(closeInput.reason);
     unusable = true;
     sessionLifetime.abort(new DOMException("The provider session was closed.", "AbortError"));
-    closePromise = Promise.resolve().then(() => input.candidate.close(closeInput)).then(() => {
+    input.hostBindingLease?.stop();
+    const closingTurn = activeTurn;
+    closingTurn?.owner.stop(new DOMException("The provider session was closed.", "AbortError"));
+    const cleanup = async () => {
+      if (!providerClosed) {
+        await input.candidate.close(closeInput);
+        providerClosed = true;
+      }
+      await input.sessionInteractionOwner?.join();
+      await closingTurn?.owner.join();
+      await input.hostBindingLease?.release();
       closed = true;
-    }).finally(() => {
+    };
+    if (input.sessionInteractionOwner) return input.sessionInteractionOwner.close(cleanup, explicit);
+    closePromise = Promise.resolve().then(cleanup).finally(() => {
       closePromise = null;
     });
     return closePromise;
   };
+  const close = (closeInput) => closeOwned(closeInput, true);
+  input.sessionInteractionOwner?.installClose(() => closeOwned({ reason: "error" }, false));
   return Object.freeze({
     binding,
-    runTurn,
-    resolveRequest,
+    startTurn,
     interruption,
     steering,
     configuration,
@@ -1639,11 +1435,40 @@ function validateAgentProviderSession(input) {
     close
   });
 }
-async function closeRejectedAgentProviderSession(session, error) {
-  if (!session || typeof session.close !== "function") throw error;
+async function closeRejectedAgentProviderSession(session, error, hostBinding, opening, interactions) {
+  if (!session) throw error;
+  hostBinding?.lease.stop();
+  interactions?.stop();
+  let providerClosed = false;
+  const cleanup = async () => {
+    if (!providerClosed) {
+      if (typeof session.close !== "function") {
+        throw new TypeError("Rejected provider session has no callable close port.");
+      }
+      await session.close({ reason: "contract_rejected" });
+      providerClosed = true;
+    }
+    await interactions?.join();
+    await hostBinding?.lease.release();
+  };
   try {
-    await session.close({ reason: "contract_rejected" });
+    if (interactions) await interactions.close(cleanup, false);
+    else await cleanup();
   } catch (cleanupError) {
+    if (hostBinding) {
+      const retained = createAgentHostBindingCleanupError({
+        providerKey: hostBinding.providerKey,
+        lease: hostBinding.lease,
+        errors: [error, cleanupError],
+        retryCleanup: () => interactions ? interactions.close(cleanup, false) : cleanup()
+      });
+      throw opening ? associateAgentSessionCleanupError(retained, opening.input) : retained;
+    }
+    if (opening) throw associateAgentSessionCleanupError(new AgentProviderSessionCleanupError({
+      providerKey: opening.providerKey,
+      errors: [error, cleanupError],
+      retryCleanup: () => interactions ? interactions.close(cleanup, false) : cleanup()
+    }), opening.input);
     throw new AggregateError(
       [error, cleanupError],
       "Provider returned an invalid session and cleanup failed."
@@ -1713,12 +1538,24 @@ async function openIdentityCreatingAgentProviderSession(input) {
       capabilities: input.capabilities,
       sessionId: input.sessionId,
       candidate,
+      ...input.sessionInteractionOwner === void 0 ? {} : { sessionInteractionOwner: input.sessionInteractionOwner },
+      ...input.hostBindingLease === void 0 ? {} : { hostBindingLease: input.hostBindingLease },
       ...input.sourceBinding === void 0 ? {} : { sourceBinding: input.sourceBinding }
     });
     tracker.requireMatch(session.binding);
+    input.sessionInteractionOwner?.adopt();
     return session;
   } catch (error) {
-    return closeRejectedAgentProviderSession(candidate, error);
+    return closeRejectedAgentProviderSession(
+      candidate,
+      error,
+      input.hostBindingLease === void 0 ? void 0 : {
+        providerKey: input.capabilities.providerKey,
+        lease: input.hostBindingLease
+      },
+      input.openingInput === void 0 ? void 0 : { providerKey: input.capabilities.providerKey, input: input.openingInput },
+      input.sessionInteractionOwner
+    );
   }
 }
 export {