@agen-ai/agent-runtime 0.4.0 → 0.4.2

package/dist/sessionValidation.js

@@ -44,8 +44,15 @@ import {
   validateAgentProviderOutputForContext
 } from "./outputValidation.js";
 import { validateAgentTurnSteeringResult } from "./steeringValidation.js";
-import { createValidatedAgentTurnExecution } from "./turnExecution/execution.js";
+import { createValidatedAgentTurnExecution, adoptValidatedAgentTurnExecution } from "./turnExecution/execution.js";
 import { validateAgentProviderTurnInterruptionResult } from "./turnExecution/receipts.js";
+import { createAgentTurnRequestAdmission } from "./turnExecution/requests.js";
+import { createAgentSessionAdmission } from "./sessionAdmission.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",
@@ -158,7 +165,7 @@ function invalidTurnSequence(providerKey, message) {
   );
 }
 function completeTurnSequence(input) {
-  if (input.pendingRequests.size > 0) {
+  if (input.requests.hasUnclaimedRequest()) {
     invalidTurnSequence(
       input.providerKey,
       "Provider completed a turn while an interaction request remained pending."
@@ -171,6 +178,7 @@ const FINAL_DIFF_TRAILING_EVENT_TYPES = [
   "collaboration.updated",
   "operation.updated",
   "provider.diagnostic",
+  "request.unavailable",
   "resource.updated",
   "runtime.error",
   "runtime.warning",
@@ -221,29 +229,19 @@ function observeItemLifecycle(input) {
     terminal: event.type === "item.completed" || TERMINAL_ITEM_STATUSES.has(event.payload.status)
   });
 }
+function hasLiveApprovalSubject(request, state) {
+  if (request.requestKind !== "approval") return true;
+  if (request.subject.kind === "plan") return state.proposedPlans.get(request.subject.artifactId) === request.requestId;
+  const item = state.observedItems.get(request.subject.itemId);
+  return item !== void 0 && !item.terminal && (item.status === "pending" || item.status === "in_progress" || item.status === "unknown" && item.inProgressObserved);
+}
 function assertApprovalSubjectCorrelation(input) {
-  const { request } = input;
-  if (request.requestKind !== "approval") return;
-  if (request.subject.kind === "plan") {
-    if (input.state.proposedPlans.get(request.subject.artifactId) !== request.requestId) {
-      invalidTurnSequence(
-        input.providerKey,
-        "Provider approval request does not identify a proposed plan from this turn."
-      );
-    }
-    return;
-  }
-  const item = input.state.observedItems.get(request.subject.itemId);
-  const itemIsLive = item !== void 0 && !item.terminal && (item.status === "pending" || item.status === "in_progress" || item.status === "unknown" && item.inProgressObserved);
-  if (!itemIsLive) {
-    invalidTurnSequence(
-      input.providerKey,
-      "Provider approval request does not identify a live item from this turn."
-    );
+  if (!hasLiveApprovalSubject(input.request, input.state)) {
+    invalidTurnSequence(input.providerKey, input.request.requestKind === "approval" && input.request.subject.kind === "plan" ? "Provider approval request does not identify a proposed plan from this turn." : "Provider approval request does not identify a live item from this turn.");
   }
 }
 function assertPendingApprovalSubjectCorrelations(input) {
-  for (const pending of input.pendingRequests.values()) {
+  for (const pending of input.requests.unclaimedRequests()) {
     assertApprovalSubjectCorrelation({
       providerKey: input.providerKey,
       request: pending.request,
@@ -299,9 +297,7 @@ function observeTurnEvent(input) {
   const {
     contextUsageState,
     event,
-    openedRequestIds,
-    turnRequestIds,
-    pendingRequests,
+    requests,
     providerKey,
     state
   } = input;
@@ -327,7 +323,7 @@ function observeTurnEvent(input) {
   }
   if (state.fileChangeMode === "final_diff") {
     if (event.type === "turn.diff.updated") {
-      if (pendingRequests.size > 0) {
+      if (requests.hasUnclaimedRequest()) {
         invalidTurnSequence(
           providerKey,
           "Provider emitted a terminal diff while an interaction request remained pending."
@@ -351,7 +347,7 @@ function observeTurnEvent(input) {
     observeItemLifecycle({ providerKey, event, state });
     assertPendingApprovalSubjectCorrelations({
       providerKey,
-      pendingRequests,
+      requests,
       state
     });
     if (event.payload.itemKind === "context_compaction" && event.type === "item.completed" && event.payload.status === "completed") {
@@ -364,7 +360,7 @@ function observeTurnEvent(input) {
     state.proposedPlans.set(event.payload.artifactId, event.payload.requestId);
     assertPendingApprovalSubjectCorrelations({
       providerKey,
-      pendingRequests,
+      requests,
       state
     });
   }
@@ -376,34 +372,20 @@ function observeTurnEvent(input) {
     });
   }
   if (event.type === "request.opened") {
-    if (pendingRequests.size > 0) {
-      invalidTurnSequence(
-        providerKey,
-        "Provider opened more than one pending request for a session."
-      );
-    }
-    const requestId = event.payload.request.requestId;
-    if (openedRequestIds.has(requestId)) {
-      invalidTurnSequence(
-        providerKey,
-        "Provider reused a request ID within a session."
-      );
-    }
     assertApprovalSubjectCorrelation({
       providerKey,
       request: event.payload.request,
       state
     });
-    openedRequestIds.add(requestId);
-    turnRequestIds.add(requestId);
-    pendingRequests.set(requestId, {
+    requests.open({
       request: event.payload.request,
       turnId: event.turnId
     });
   }
+  if (event.type === "request.unavailable") requests.unavailable(event.payload.requestId);
   if (event.type === "turn.state_changed") {
     const waiting = event.payload.state === "waiting_for_request";
-    if (waiting && !turnRequestIds.has(event.payload.requestId)) {
+    if (waiting && !requests.hasOpened(event.payload.requestId)) {
       invalidTurnSequence(
         providerKey,
         "Provider entered a waiting state for a request it did not open."
@@ -411,8 +393,8 @@ function observeTurnEvent(input) {
     }
   }
   if (event.type === "turn.completed") {
-    if (event.payload.outcome !== "completed") pendingRequests.clear();
-    completeTurnSequence({ providerKey, state, pendingRequests });
+    if (event.payload.outcome !== "completed") requests.withdraw();
+    completeTurnSequence({ providerKey, state, requests });
   }
 }
 function observeTurnOutput(input) {
@@ -503,8 +485,7 @@ function observeTurnOutput(input) {
     event: input.output.event,
     state: input.state,
     pendingRequests: input.pendingRequests,
-    openedRequestIds: input.openedRequestIds,
-    turnRequestIds: input.turnRequestIds,
+    requests: input.requests,
     contextUsageState: input.contextUsageState
   });
 }
@@ -536,14 +517,20 @@ function observeSessionOperationOutput(input) {
       );
     }
   }
+  const pendingRequests = /* @__PURE__ */ new Map();
   observeTurnOutput({
     capabilities: input.capabilities,
     providerKey: input.providerKey,
     output: input.output,
     state: input.state,
-    pendingRequests: /* @__PURE__ */ new Map(),
-    openedRequestIds: /* @__PURE__ */ new Set(),
-    turnRequestIds: /* @__PURE__ */ new Set(),
+    pendingRequests,
+    requests: createAgentTurnRequestAdmission({
+      providerKey: input.providerKey,
+      sessionAdmission: createAgentSessionAdmission(input.providerKey),
+      pendingRequests,
+      canRestore: () => false,
+      canRestoreRequest: () => false
+    }),
     contextUsageState: input.contextUsageState,
     interactionState: input.interactionState
   });
@@ -632,6 +619,146 @@ function assertAgentTurnInputCapability(input) {
   });
   if (textIssue) rejectReference(`${textIssue.target} must use ${textIssue.format} text`);
 }
+function createAgentSessionValidationOwner(capabilities, sessionId) {
+  const providerKey = capabilities.providerKey;
+  const sessionLifetime = new AbortController();
+  const sessionAdmission = createAgentSessionAdmission(providerKey);
+  const contextUsageState = {
+    latestByScope: /* @__PURE__ */ new Map(),
+    cumulativeByScope: /* @__PURE__ */ new Map(),
+    compactionReadyScopes: /* @__PURE__ */ new Set()
+  };
+  const interactionState = {
+    operationResults: /* @__PURE__ */ new Map(),
+    operationInvocations: /* @__PURE__ */ new Map(),
+    collaborationNodes: /* @__PURE__ */ new Map(),
+    collaborationSpawnReservations: /* @__PURE__ */ new Map(),
+    generatedResources: /* @__PURE__ */ new Map()
+  };
+  let closed = false;
+  let unusable = false;
+  let closing;
+  const requireOpen = () => {
+    if (closed)
+      throwAgentProviderContractError(
+        providerKey,
+        "session_closed",
+        "Provider session is closed."
+      );
+  };
+  const requireUsable = () => {
+    requireOpen();
+    if (unusable) {
+      throwAgentProviderContractError(
+        providerKey,
+        "session_unusable",
+        "Provider session cannot be reused after an incomplete operation."
+      );
+    }
+  };
+  const outputContext = (turnId) => ({
+    capabilities,
+    providerKey,
+    sessionId,
+    ...turnId === void 0 ? {} : { turnId }
+  });
+  function installExecution(token, turnId, source) {
+    const pendingRequests = /* @__PURE__ */ new Map();
+    const state = {
+      fileChangeMode: capabilities.output.fileChanges,
+      observedItems: /* @__PURE__ */ new Map(),
+      proposedPlans: /* @__PURE__ */ new Map(),
+      generatedResourceIds: /* @__PURE__ */ new Set(),
+      started: false,
+      terminal: false,
+      finalDiffObserved: false
+    };
+    const inFlightOperations = /* @__PURE__ */ new Set();
+    const common = {
+      providerKey,
+      pendingRequests,
+      sessionAdmission,
+      inFlightOperations,
+      requireUsable,
+      isTerminal: () => state.terminal,
+      canRestoreRequest: (pending) => hasLiveApprovalSubject(pending.request, state),
+      observe(candidate, requests) {
+        const output = validateAgentProviderOutputForContext(candidate, outputContext(turnId));
+        observeTurnOutput({
+          capabilities,
+          providerKey,
+          output,
+          state,
+          pendingRequests,
+          requests,
+          contextUsageState,
+          interactionState
+        });
+        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 (source.kind === "caller") sessionAdmission.releaseExecution(token);
+      },
+      retire() {
+        unusable = true;
+      },
+      abandon: () => closing ? closing() : Promise.reject(new Error("Session cleanup is waiting for its opening owner."))
+    };
+    const owner = source.kind === "caller" ? createValidatedAgentTurnExecution({ ...common, turnInput: source.input, start: source.start }) : adoptValidatedAgentTurnExecution({ ...common, turnId, createCandidate: source.createCandidate });
+    try {
+      sessionAdmission.installExecution(token, { turnId, pendingRequests, state, inFlightOperations, owner });
+    } catch (cause) {
+      owner.stop(cause instanceof Error ? cause : new Error("Execution installation failed.", { cause }));
+      throw cause;
+    }
+    return owner;
+  }
+  return {
+    sessionAdmission,
+    sessionLifetime,
+    contextUsageState,
+    interactionState,
+    outputContext,
+    requireUsable,
+    get activeTurn() {
+      return sessionAdmission.execution;
+    },
+    get closed() {
+      return closed;
+    },
+    get unusable() {
+      return unusable;
+    },
+    fence() {
+      unusable = true;
+    },
+    stop() {
+      unusable = true;
+      sessionAdmission.stop();
+      sessionLifetime.abort(new DOMException("The provider session was closed.", "AbortError"));
+    },
+    completeClose() {
+      closed = true;
+    },
+    installClose(close) {
+      closing = close;
+    },
+    reserveExecution: sessionAdmission.reserveExecution,
+    ownsExecution: sessionAdmission.ownsExecution,
+    releaseExecution: sessionAdmission.releaseExecution,
+    installNativeExecution(token, turnId, createCandidate) {
+      return installExecution(token, turnId, { kind: "native", createCandidate });
+    },
+    installCallerExecution(token, turnInput, start) {
+      return installExecution(token, turnInput.turnId, { kind: "caller", input: turnInput, start });
+    }
+  };
+}
 function validateAgentProviderSession(input) {
   const { capabilities, sessionId } = input;
   const providerKey = capabilities.providerKey;
@@ -667,57 +794,22 @@ function validateAgentProviderSession(input) {
     );
   }
   validateSessionPorts(capabilities, input.candidate);
-  const sessionLifetime = new AbortController();
+  const validationOwner = input.validationOwner ?? createAgentSessionValidationOwner(capabilities, sessionId);
+  const { sessionLifetime, contextUsageState, interactionState, outputContext } = validationOwner;
+  const collaborationNodes = interactionState.collaborationNodes;
+  const collaborationSpawnReservations = interactionState.collaborationSpawnReservations;
+  const requireUsable = () => {
+    input.sessionInteractionOwner?.requireUsable();
+    validationOwner.requireUsable();
+  };
   const environment = validateAgentEnvironmentObservationPort({
     providerKey,
     capability: capabilities.environment.session,
     port: input.candidate.environment,
     signal: sessionLifetime.signal
   });
-  const openedRequestIds = /* @__PURE__ */ new Set();
-  const contextUsageState = {
-    latestByScope: /* @__PURE__ */ new Map(),
-    cumulativeByScope: /* @__PURE__ */ new Map(),
-    compactionReadyScopes: /* @__PURE__ */ new Set()
-  };
-  const interactionState = {
-    operationResults: /* @__PURE__ */ new Map(),
-    operationInvocations: /* @__PURE__ */ new Map(),
-    collaborationNodes: /* @__PURE__ */ new Map(),
-    collaborationSpawnReservations: /* @__PURE__ */ new Map(),
-    generatedResources: /* @__PURE__ */ new Map()
-  };
-  const collaborationNodes = interactionState.collaborationNodes;
-  const collaborationSpawnReservations = interactionState.collaborationSpawnReservations;
-  let activeTurn = null;
   let closePromise = null;
-  let closed = false;
   let providerClosed = false;
-  let unusable = false;
-  const requireOpen = () => {
-    if (closed)
-      throwAgentProviderContractError(
-        providerKey,
-        "session_closed",
-        "Provider session is closed."
-      );
-  };
-  const requireUsable = () => {
-    requireOpen();
-    if (unusable) {
-      throwAgentProviderContractError(
-        providerKey,
-        "session_unusable",
-        "Provider session cannot be reused after an incomplete operation."
-      );
-    }
-  };
-  const outputContext = (turnId) => ({
-    capabilities,
-    providerKey,
-    sessionId,
-    ...turnId === void 0 ? {} : { turnId }
-  });
   const delegateProviderMutation = async (input2) => {
     let executionStarted = false;
     const onProviderExecutionStarted = () => {
@@ -742,6 +834,7 @@ function validateAgentProviderSession(input) {
       await input2.observeOutput?.(candidate);
     };
     try {
+      requireUsable();
       const candidate = await input2.invoke(onProviderExecutionStarted, onOutput);
       if (!executionStarted) {
         throwAgentProviderContractError(
@@ -753,7 +846,7 @@ function validateAgentProviderSession(input) {
       return input2.validate(candidate);
     } catch (error) {
       if (!executionStarted) throw error;
-      unusable = true;
+      validationOwner.fence();
       throw new AgentProviderDelegatedOperationError(
         providerKey,
         input2.operation,
@@ -779,63 +872,17 @@ function validateAgentProviderSession(input) {
         `Provider ${providerKey} does not support ${parsedInput.interactionMode} turn interaction mode.`
       );
     }
-    if (activeTurn !== null) {
-      throwAgentProviderContractError(providerKey, "concurrent_turn", "Provider session already has an active turn.");
-    }
-    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
-    };
-    const inFlightOperations = /* @__PURE__ */ new Set();
-    const owner = createValidatedAgentTurnExecution({
-      providerKey,
-      turnInput: {
+    const token = validationOwner.reserveExecution();
+    try {
+      return validationOwner.installCallerExecution(token, {
         ...parsedInput,
         ...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,
-          pendingRequests,
-          openedRequestIds,
-          turnRequestIds,
-          contextUsageState,
-          interactionState
-        });
-        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;
+      }, (inputTurn) => input.candidate.startTurn(inputTurn)).execution;
+    } catch (error) {
+      validationOwner.releaseExecution(token);
+      throw error;
+    }
   };
   const declaredInterruption = input.candidate.interruption;
   const interruption = declaredInterruption.kind === "unsupported" ? Object.freeze({ kind: "unsupported" }) : Object.freeze({
@@ -848,7 +895,7 @@ function validateAgentProviderSession(input) {
         reason: interruptionInput.reason,
         ...interruptionInput.requestedAt === void 0 ? {} : { requestedAt: interruptionInput.requestedAt }
       });
-      const targetedActiveTurn = activeTurn?.turnId === parsed.turnId ? activeTurn : null;
+      const targetedActiveTurn = validationOwner.activeTurn?.turnId === parsed.turnId ? validationOwner.activeTurn : null;
       const targetedTurn = targetedActiveTurn;
       if (targetedTurn === null || targetedTurn.state.terminal || !targetedTurn.owner.hasEntered()) {
         throwAgentProviderContractError(
@@ -873,7 +920,7 @@ function validateAgentProviderSession(input) {
           );
         } catch (error) {
           suspendedRequests.withdraw();
-          unusable = true;
+          validationOwner.fence();
           throw error;
         }
         if (result.status === "failed") {
@@ -892,7 +939,7 @@ function validateAgentProviderSession(input) {
       requireUsable();
       throwIfAgentOperationAborted(steeringInput.signal);
       const turnId = parseAgentTurnId(steeringInput.turnId);
-      if (activeTurn?.turnId !== turnId || !activeTurn.owner.hasEntered() || activeTurn.state.terminal || activeTurn.pendingRequests.size > 0) {
+      if (validationOwner.activeTurn?.turnId !== turnId || !validationOwner.activeTurn.owner.hasEntered() || validationOwner.activeTurn.state.terminal || validationOwner.activeTurn.pendingRequests.size > 0) {
         throwAgentProviderContractError(
           providerKey,
           "active_turn_mismatch",
@@ -908,7 +955,7 @@ function validateAgentProviderSession(input) {
         parts: content.parts,
         providerKey
       });
-      const targetedActiveTurn = activeTurn;
+      const targetedActiveTurn = validationOwner.activeTurn;
       const settleSteering = trackActiveTurnOperation(targetedActiveTurn);
       try {
         try {
@@ -920,10 +967,10 @@ function validateAgentProviderSession(input) {
             }),
             providerKey
           );
-          if (result.status === "delivery_uncertain") unusable = true;
+          if (result.status === "delivery_uncertain") validationOwner.fence();
           return result;
         } catch (error) {
-          unusable = true;
+          validationOwner.fence();
           throw new AgentProviderDelegatedOperationError(
             providerKey,
             "steer_turn",
@@ -1386,39 +1433,35 @@ function validateAgentProviderSession(input) {
       return inspection;
     }
   });
-  const close = (closeInput) => {
-    if (closed) return Promise.resolve();
-    if (closePromise) return closePromise;
+  const closeOwned = (closeInput, explicit) => {
+    if (validationOwner.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.");
-    }
-    unusable = true;
-    sessionLifetime.abort(new DOMException("The provider session was closed.", "AbortError"));
+    validateCloseReason(closeInput.reason);
+    validationOwner.fence();
+    validationOwner.stop();
     input.hostBindingLease?.stop();
-    const closingTurn = activeTurn;
+    const closingTurn = validationOwner.activeTurn;
     closingTurn?.owner.stop(new DOMException("The provider session was closed.", "AbortError"));
-    closePromise = Promise.resolve().then(async () => {
+    const cleanup = async () => {
       if (!providerClosed) {
         await input.candidate.close(closeInput);
         providerClosed = true;
       }
+      await input.sessionInteractionOwner?.join();
       await closingTurn?.owner.join();
       await input.hostBindingLease?.release();
-    }).then(() => {
-      closed = true;
-    }).finally(() => {
+      validationOwner.completeClose();
+    };
+    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);
+  validationOwner.installClose(() => closeOwned({ reason: "error" }, false));
+  input.sessionInteractionOwner?.installClose(() => closeOwned({ reason: "error" }, false));
   return Object.freeze({
     binding,
     startTurn,
@@ -1433,9 +1476,10 @@ function validateAgentProviderSession(input) {
     close
   });
 }
-async function closeRejectedAgentProviderSession(session, error, hostBinding, opening) {
+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) {
@@ -1445,24 +1489,26 @@ async function closeRejectedAgentProviderSession(session, error, hostBinding, op
       await session.close({ reason: "contract_rejected" });
       providerClosed = true;
     }
+    await interactions?.join();
     await hostBinding?.lease.release();
   };
   try {
-    await cleanup();
+    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: cleanup
+        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: cleanup
+      retryCleanup: () => interactions ? interactions.close(cleanup, false) : cleanup()
     }), opening.input);
     throw new AggregateError(
       [error, cleanupError],
@@ -1499,8 +1545,14 @@ function bindingTracker(input) {
           "Provider branch reused its source binding."
         );
       }
-      input.observer(binding);
       observed = binding;
+      try {
+        input.interactions?.bind();
+        input.observer(binding);
+      } catch (cause) {
+        input.interactions?.fail(cause);
+        throw cause;
+      }
     },
     requireMatch(binding) {
       if (!observed) {
@@ -1524,19 +1576,24 @@ async function openIdentityCreatingAgentProviderSession(input) {
   const tracker = bindingTracker({
     providerKey: input.capabilities.providerKey,
     observer: input.observer,
+    ...input.sessionInteractionOwner === void 0 ? {} : { interactions: input.sessionInteractionOwner },
     ...input.sourceBinding === void 0 ? {} : { sourceBinding: input.sourceBinding }
   });
   let candidate = null;
   try {
     candidate = await input.open(tracker.observe);
+    tracker.requireMatch(parseAgentSessionBinding(candidate.binding));
     const session = validateAgentProviderSession({
       capabilities: input.capabilities,
       sessionId: input.sessionId,
       candidate,
+      ...input.validationOwner === void 0 ? {} : { validationOwner: input.validationOwner },
+      ...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(
@@ -1546,12 +1603,14 @@ async function openIdentityCreatingAgentProviderSession(input) {
         providerKey: input.capabilities.providerKey,
         lease: input.hostBindingLease
       },
-      input.openingInput === void 0 ? void 0 : { providerKey: input.capabilities.providerKey, input: input.openingInput }
+      input.openingInput === void 0 ? void 0 : { providerKey: input.capabilities.providerKey, input: input.openingInput },
+      input.sessionInteractionOwner
     );
   }
 }
 export {
   closeRejectedAgentProviderSession,
+  createAgentSessionValidationOwner,
   openIdentityCreatingAgentProviderSession,
   validateAgentProviderSession
 };