@agen-ai/agent-runtime 0.4.1 → 0.4.3

package/dist/sessionValidation.js

@@ -44,8 +44,10 @@ 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.");
@@ -163,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."
@@ -176,6 +178,7 @@ const FINAL_DIFF_TRAILING_EVENT_TYPES = [
   "collaboration.updated",
   "operation.updated",
   "provider.diagnostic",
+  "request.unavailable",
   "resource.updated",
   "runtime.error",
   "runtime.warning",
@@ -226,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,
@@ -304,9 +297,7 @@ function observeTurnEvent(input) {
   const {
     contextUsageState,
     event,
-    openedRequestIds,
-    turnRequestIds,
-    pendingRequests,
+    requests,
     providerKey,
     state
   } = input;
@@ -332,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."
@@ -356,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") {
@@ -369,7 +360,7 @@ function observeTurnEvent(input) {
     state.proposedPlans.set(event.payload.artifactId, event.payload.requestId);
     assertPendingApprovalSubjectCorrelations({
       providerKey,
-      pendingRequests,
+      requests,
       state
     });
   }
@@ -381,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."
@@ -416,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) {
@@ -508,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
   });
 }
@@ -523,6 +499,7 @@ const SESSION_OPERATION_OBSERVATION_EVENT_TYPES = /* @__PURE__ */ new Set([
   "resource.updated",
   "runtime.warning",
   "runtime.error",
+  "runtime.retrying",
   "provider.diagnostic"
 ]);
 function observeSessionOperationOutput(input) {
@@ -541,14 +518,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
   });
@@ -637,6 +620,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;
@@ -672,58 +795,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 = () => {
-    input.sessionInteractionOwner?.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 = () => {
@@ -760,7 +847,7 @@ function validateAgentProviderSession(input) {
       return input2.validate(candidate);
     } catch (error) {
       if (!executionStarted) throw error;
-      unusable = true;
+      validationOwner.fence();
       throw new AgentProviderDelegatedOperationError(
         providerKey,
         input2.operation,
@@ -786,63 +873,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({
@@ -855,7 +896,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(
@@ -880,7 +921,7 @@ function validateAgentProviderSession(input) {
           );
         } catch (error) {
           suspendedRequests.withdraw();
-          unusable = true;
+          validationOwner.fence();
           throw error;
         }
         if (result.status === "failed") {
@@ -899,7 +940,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",
@@ -915,7 +956,7 @@ function validateAgentProviderSession(input) {
         parts: content.parts,
         providerKey
       });
-      const targetedActiveTurn = activeTurn;
+      const targetedActiveTurn = validationOwner.activeTurn;
       const settleSteering = trackActiveTurnOperation(targetedActiveTurn);
       try {
         try {
@@ -927,10 +968,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",
@@ -1008,142 +1049,154 @@ function validateAgentProviderSession(input) {
     invokeOperation: async (operationInput) => {
       requireUsable();
       throwIfAgentOperationAborted(operationInput.signal);
-      let invocation;
-      let observationTurnId;
+      const settle = validationOwner.sessionAdmission.trackOperation();
+      const signal = operationInput.signal === void 0 ? sessionLifetime.signal : AbortSignal.any([operationInput.signal, sessionLifetime.signal]);
+      operationInput = { ...operationInput, signal };
       try {
-        invocation = parseAgentOperationInvocation(operationInput.invocation);
-        observationTurnId = parseAgentTurnId(
-          operationInput.observationTurnId
-        );
-      } catch {
-        return throwAgentProviderContractError(
-          providerKey,
-          "input_operation_mismatch",
-          "Operation invocation is invalid."
-        );
-      }
-      const catalog = validateAgentOperationCatalogForCapabilities(
-        capabilities,
-        await declaredOperations.listOperations(
-          operationInput.signal === void 0 ? {} : { signal: operationInput.signal }
-        )
-      );
-      const descriptor = catalog.operations.find(
-        (operation) => operation.operationId === invocation.operationId
-      );
-      if (descriptor === void 0) {
-        return throwAgentProviderContractError(
-          providerKey,
-          "input_operation_mismatch",
-          "Operation invocation does not identify an offered operation."
+        let invocation;
+        let observationTurnId;
+        try {
+          invocation = parseAgentOperationInvocation(operationInput.invocation);
+          observationTurnId = parseAgentTurnId(
+            operationInput.observationTurnId
+          );
+        } catch {
+          return throwAgentProviderContractError(
+            providerKey,
+            "input_operation_mismatch",
+            "Operation invocation is invalid."
+          );
+        }
+        const catalog = validateAgentOperationCatalogForCapabilities(
+          capabilities,
+          await declaredOperations.listOperations(
+            operationInput.signal === void 0 ? {} : { signal: operationInput.signal }
+          )
         );
-      }
-      try {
-        invocation = parseAgentOperationInvocationFor(
-          descriptor,
-          invocation
+        const descriptor = catalog.operations.find(
+          (operation) => operation.operationId === invocation.operationId
         );
-      } catch {
-        return throwAgentProviderContractError(
-          providerKey,
-          "input_operation_mismatch",
-          "Operation invocation is stale or outside the offered descriptor."
-        );
-      }
-      const existing = interactionState.operationInvocations.get(
-        invocation.invocationId
-      );
-      if (existing !== void 0) {
-        if (JSON.stringify(existing.invocation) !== JSON.stringify(invocation)) {
+        if (descriptor === void 0) {
           return throwAgentProviderContractError(
             providerKey,
             "input_operation_mismatch",
-            "Operation invocation ID was reused with conflicting input."
+            "Operation invocation does not identify an offered operation."
           );
         }
-        if (descriptor.idempotency === "required" && existing.result !== void 0) {
-          return existing.result;
+        try {
+          invocation = parseAgentOperationInvocationFor(
+            descriptor,
+            invocation
+          );
+        } catch {
+          return throwAgentProviderContractError(
+            providerKey,
+            "input_operation_mismatch",
+            "Operation invocation is stale or outside the offered descriptor."
+          );
         }
-        return throwAgentProviderContractError(
-          providerKey,
-          "input_operation_mismatch",
-          "Operation invocation ID is already active or is not replayable."
+        const existing = interactionState.operationInvocations.get(
+          invocation.invocationId
         );
-      }
-      const trackedInvocation = {
-        invocation
-      };
-      const observationState = {
-        fileChangeMode: capabilities.output.fileChanges,
-        observedItems: /* @__PURE__ */ new Map(),
-        proposedPlans: /* @__PURE__ */ new Map(),
-        generatedResourceIds: /* @__PURE__ */ new Set(),
-        started: true,
-        terminal: false,
-        finalDiffObserved: false
-      };
-      interactionState.operationInvocations.set(
-        invocation.invocationId,
-        trackedInvocation
-      );
-      try {
-        const result = await delegateProviderMutation({
-          operation: "invoke_operation",
-          observer: operationInput.onProviderExecutionStarted,
-          invoke: (onProviderExecutionStarted, onOutput) => declaredOperations.invokeOperation({
-            invocation,
-            observationTurnId,
-            onProviderExecutionStarted,
-            onOutput,
-            ...operationInput.signal === void 0 ? {} : { signal: operationInput.signal }
-          }),
-          observeOutput: async (candidate) => {
-            const output = validateAgentProviderOutputForContext(
-              candidate,
-              {
-                ...outputContext(observationTurnId),
-                operationInvocationId: invocation.invocationId
-              }
-            );
-            observeSessionOperationOutput({
-              capabilities,
-              providerKey,
-              output,
-              state: observationState,
-              contextUsageState,
-              interactionState
-            });
-            await operationInput.onOutput?.(output);
-          },
-          validate: (candidate) => {
-            const result2 = validateAgentOperationResultTransition({
+        if (existing !== void 0) {
+          if (JSON.stringify(existing.invocation) !== JSON.stringify(invocation)) {
+            return throwAgentProviderContractError(
               providerKey,
-              candidate: validateAgentOperationResultForInvocation(
-                providerKey,
-                descriptor,
-                invocation,
-                candidate
-              ),
-              previous: interactionState.operationResults.get(
-                invocation.invocationId
-              )
-            });
-            interactionState.operationResults.set(
-              result2.invocationId,
-              result2
+              "input_operation_mismatch",
+              "Operation invocation ID was reused with conflicting input."
             );
-            return result2;
           }
-        });
-        trackedInvocation.result = result;
-        return result;
-      } catch (error) {
-        if (!(error instanceof AgentProviderDelegatedOperationError)) {
-          interactionState.operationInvocations.delete(
-            invocation.invocationId
+          if (descriptor.idempotency === "required" && existing.result !== void 0) {
+            return existing.result;
+          }
+          return throwAgentProviderContractError(
+            providerKey,
+            "input_operation_mismatch",
+            "Operation invocation ID is already active or is not replayable."
           );
         }
-        throw error;
+        requireUsable();
+        signal.throwIfAborted();
+        const reservation = descriptor.timing === "idle_session" && descriptor.executionMode === "immediate" ? validationOwner.reserveExecution() : void 0;
+        const trackedInvocation = {
+          invocation
+        };
+        const observationState = {
+          fileChangeMode: capabilities.output.fileChanges,
+          observedItems: /* @__PURE__ */ new Map(),
+          proposedPlans: /* @__PURE__ */ new Map(),
+          generatedResourceIds: /* @__PURE__ */ new Set(),
+          started: true,
+          terminal: false,
+          finalDiffObserved: false
+        };
+        interactionState.operationInvocations.set(
+          invocation.invocationId,
+          trackedInvocation
+        );
+        try {
+          const result = await delegateProviderMutation({
+            operation: "invoke_operation",
+            observer: operationInput.onProviderExecutionStarted,
+            invoke: (onProviderExecutionStarted, onOutput) => declaredOperations.invokeOperation({
+              invocation,
+              observationTurnId,
+              onProviderExecutionStarted,
+              onOutput,
+              ...operationInput.signal === void 0 ? {} : { signal: operationInput.signal }
+            }),
+            observeOutput: async (candidate) => {
+              const output = validateAgentProviderOutputForContext(
+                candidate,
+                {
+                  ...outputContext(observationTurnId),
+                  operationInvocationId: invocation.invocationId
+                }
+              );
+              observeSessionOperationOutput({
+                capabilities,
+                providerKey,
+                output,
+                state: observationState,
+                contextUsageState,
+                interactionState
+              });
+              await operationInput.onOutput?.(output);
+            },
+            validate: (candidate) => {
+              const result2 = validateAgentOperationResultTransition({
+                providerKey,
+                candidate: validateAgentOperationResultForInvocation(
+                  providerKey,
+                  descriptor,
+                  invocation,
+                  candidate
+                ),
+                previous: interactionState.operationResults.get(
+                  invocation.invocationId
+                )
+              });
+              interactionState.operationResults.set(
+                result2.invocationId,
+                result2
+              );
+              return result2;
+            }
+          });
+          trackedInvocation.result = result;
+          return result;
+        } catch (error) {
+          if (!(error instanceof AgentProviderDelegatedOperationError)) {
+            interactionState.operationInvocations.delete(
+              invocation.invocationId
+            );
+          }
+          throw error;
+        } finally {
+          if (reservation !== void 0) validationOwner.releaseExecution(reservation);
+        }
+      } finally {
+        settle();
       }
     }
   });
@@ -1394,14 +1447,14 @@ function validateAgentProviderSession(input) {
     }
   });
   const closeOwned = (closeInput, explicit) => {
-    if (closed && !input.sessionInteractionOwner) return Promise.resolve();
+    if (validationOwner.closed && !input.sessionInteractionOwner) return Promise.resolve();
     if (!input.sessionInteractionOwner && closePromise) return closePromise;
     throwIfAgentOperationAborted(closeInput.signal);
     validateCloseReason(closeInput.reason);
-    unusable = true;
-    sessionLifetime.abort(new DOMException("The provider session was closed.", "AbortError"));
+    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"));
     const cleanup = async () => {
       if (!providerClosed) {
@@ -1410,8 +1463,9 @@ function validateAgentProviderSession(input) {
       }
       await input.sessionInteractionOwner?.join();
       await closingTurn?.owner.join();
+      await validationOwner.sessionAdmission.joinOperations();
       await input.hostBindingLease?.release();
-      closed = true;
+      validationOwner.completeClose();
     };
     if (input.sessionInteractionOwner) return input.sessionInteractionOwner.close(cleanup, explicit);
     closePromise = Promise.resolve().then(cleanup).finally(() => {
@@ -1420,6 +1474,7 @@ function validateAgentProviderSession(input) {
     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,
@@ -1504,8 +1559,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) {
@@ -1529,15 +1590,18 @@ 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 }
@@ -1560,6 +1624,7 @@ async function openIdentityCreatingAgentProviderSession(input) {
 }
 export {
   closeRejectedAgentProviderSession,
+  createAgentSessionValidationOwner,
   openIdentityCreatingAgentProviderSession,
   validateAgentProviderSession
 };