@agen-ai/agent-runtime 0.4.2 → 0.4.4

package/dist/outputValidation.d.ts

@@ -1,6 +1,7 @@
 import { type AgentCapabilities, type AgentCollaborationId, type AgentGeneratedResourceId, type AgentOperationInvocationId, type AgentProviderKey, type AgentSessionId, type AgentTurnId } from "@agen-ai/agent-protocol";
 import { type AgentProviderOutput } from "./outputs.js";
 import type { AgentProviderOperationResult } from "./sessions.js";
+import type { AgentStructuredOutputBinding } from "./structuredOutput/admission.js";
 export interface AgentProviderOutputValidationContext {
     readonly capabilities: AgentCapabilities;
     readonly providerKey: AgentProviderKey;
@@ -10,6 +11,7 @@ export interface AgentProviderOutputValidationContext {
     readonly operationInvocationId?: AgentOperationInvocationId;
     readonly collaborationId?: AgentCollaborationId;
     readonly generatedResourceId?: AgentGeneratedResourceId;
+    readonly structuredOutputBinding?: AgentStructuredOutputBinding;
 }
 export declare function validateAgentProviderOutputForContext(candidate: AgentProviderOutput, context: AgentProviderOutputValidationContext): AgentProviderOutput;
 export declare function validateAgentProviderOperationResult(candidate: AgentProviderOperationResult, context: AgentProviderOutputValidationContext): AgentProviderOperationResult;

package/dist/outputValidation.js

@@ -1,10 +1,14 @@
 import {
-  parseAgentError
+  AGENT_PROTOCOL_EVENT_BYTES_LIMIT,
+  agentProtocolSerializedJsonBytes,
+  parseAgentError,
+  parseAgentEvent
 } from "@agen-ai/agent-protocol";
 import { throwAgentProviderContractError } from "./contractErrors.js";
 import {
   validateAgentProviderOutput
 } from "./outputs.js";
+import { validateAgentStructuredOutputResult } from "./structuredOutput/validation.js";
 function unsupportedCapabilitySemantic(value) {
   throw new TypeError(
     `Unsupported Agent Protocol capability semantic: ${String(value)}.`
@@ -206,6 +210,30 @@ function validateAgentProviderOutputForContext(candidate, context) {
     );
   }
   assertOutputCapability(context, output);
+  if (output.kind === "event" && output.event.type === "turn.completed") {
+    let structuredOutput = validateAgentStructuredOutputResult({
+      providerKey: context.providerKey,
+      ...context.structuredOutputBinding === void 0 ? {} : { binding: context.structuredOutputBinding },
+      result: output.event.payload.structuredOutput
+    });
+    if (output.event.payload.outcome !== "completed") return output;
+    let event = {
+      ...output.event,
+      payload: { ...output.event.payload, structuredOutput }
+    };
+    if (structuredOutput.kind === "unavailable" && structuredOutput.reason === "schema_mismatch" && structuredOutput.issues !== void 0 && agentProtocolSerializedJsonBytes(event) > AGENT_PROTOCOL_EVENT_BYTES_LIMIT) {
+      structuredOutput = Object.freeze({ kind: "unavailable", reason: "schema_mismatch" });
+      event = { ...event, payload: { ...event.payload, structuredOutput } };
+    }
+    parseAgentEvent(event);
+    return Object.freeze({
+      ...output,
+      event: Object.freeze({
+        ...event,
+        payload: Object.freeze(event.payload)
+      })
+    });
+  }
   return output;
 }
 function validateAgentProviderOperationResult(candidate, context) {

package/dist/sessionAdmission.d.ts

@@ -1,5 +1,7 @@
 import type { AgentProviderKey, AgentRequestId } from "@agen-ai/agent-protocol";
 export declare function createAgentSessionAdmission<Execution = unknown>(providerKey: AgentProviderKey): {
+    trackOperation(): () => void;
+    joinOperations(): Promise<void>;
     reserveExecution(): object;
     installExecution(token: object, execution: Execution): void;
     releaseExecution(token: object): void;

package/dist/sessionAdmission.js

@@ -6,7 +6,20 @@ function createAgentSessionAdmission(providerKey) {
   let requestIdBytes = 0;
   let slot;
   let stopped = false;
+  const operations = /* @__PURE__ */ new Set();
   return {
+    trackOperation() {
+      if (stopped) throwAgentProviderContractError(providerKey, "session_unusable", "Session admission is stopped.");
+      const completion = Promise.withResolvers();
+      operations.add(completion.promise);
+      return () => {
+        operations.delete(completion.promise);
+        completion.resolve();
+      };
+    },
+    async joinOperations() {
+      await Promise.all(operations);
+    },
     reserveExecution() {
       if (stopped) throwAgentProviderContractError(providerKey, "session_unusable", "Session admission is stopped.");
       if (slot) throwAgentProviderContractError(providerKey, "concurrent_turn", "Provider session already owns an execution.");

package/dist/sessionInteractions/lifetime.d.ts

@@ -49,6 +49,7 @@ export declare class SessionInteractionOwner {
     constructor(providerKey: AgentProviderKey, sessionId: AgentSessionId, context: AgentSessionInteractionContext, validationOwner: AgentSessionValidationOwner, operation: AgentSessionInteractionOpeningOperation, support: AgentSessionInteractionSupport, nativeSupport: AgentNativeContinuationSupport, continuations?: AgentNativeContinuationContext, signal?: AbortSignal);
     track<Result>(promise: Promise<Result>): Promise<Result>;
     get accepting(): boolean;
+    get hasLiveRequests(): boolean;
     requireUsable(): void;
     private offer;
     requireContinuation(kind: "form" | "plan_review"): void;

package/dist/sessionInteractions/lifetime.js

@@ -102,6 +102,10 @@ class SessionInteractionOwner {
   get accepting() {
     return this.state === "opening" || this.state === "open";
   }
+  get hasLiveRequests() {
+    for (const request of this.requests.values()) if (request.blocksExecutionInput) return true;
+    return false;
+  }
   requireUsable() {
     if (this.fatal) throw this.fatal.cause;
     this.validationOwner.requireUsable();

package/dist/sessionInteractions/request.d.ts

@@ -25,6 +25,7 @@ export declare class SessionInteractionRequest {
     constructor(owner: SessionInteractionOwner, candidate: Candidate, retire: () => void);
     observe(): void;
     setCallback(callback: Promise<void>): void;
+    get blocksExecutionInput(): boolean;
     private scheduleExpiry;
     private expire;
     private protocolFailure;

package/dist/sessionInteractions/request.js

@@ -76,6 +76,9 @@ class SessionInteractionRequest {
       }
     );
   }
+  get blocksExecutionInput() {
+    return this.state.kind !== "terminal" || this.responseWork > 0 || !this.rawTerminalSettled;
+  }
   scheduleExpiry() {
     if (this.candidate.deadlineAt === void 0 || this.state.kind === "terminal") return;
     const remainingMs = this.candidate.deadlineAt - Date.now();

package/dist/sessionValidation.d.ts

@@ -1,4 +1,4 @@
-import { type AgentCapabilities, type AgentCollaborationNode, type AgentContextCumulativeUsage, type AgentContextMeasurementScope, type AgentContextUsage, type AgentGeneratedResourceDescriptor, type AgentItemKind, type AgentItemStatus, type AgentOperationInvocation, type AgentOperationResult, type AgentProviderKey, type AgentSessionBinding, type AgentSessionId, type AgentTurnId } from "@agen-ai/agent-protocol";
+import { type AgentCapabilities, type AgentCollaborationNode, type AgentContextCumulativeUsage, type AgentContextMeasurementScope, type AgentContextUsage, type AgentGeneratedResourceDescriptor, type AgentItemKind, type AgentItemStatus, type AgentOperationInputCapability, type AgentOperationInvocation, type AgentOperationResult, type AgentProviderKey, type AgentSessionBinding, type AgentSessionId, type AgentTurnId } from "@agen-ai/agent-protocol";
 import { type AgentHostBindingLease } from "./hostBindings/lifetime.js";
 import { type MaybePromise } from "./foundation.js";
 import { type AgentProviderOutputValidationContext } from "./outputValidation.js";
@@ -6,6 +6,8 @@ import type { AgentProviderStartTurnInput, AgentProviderSession, AgentSessionBin
 import { type ValidatedAgentTurnExecution, type AdoptedAgentTurnExecution } from "./turnExecution/execution.js";
 import { type PendingAgentRequest } from "./turnExecution/requests.js";
 import type { SessionInteractionOwner } from "./sessionInteractions/lifetime.js";
+import type { AgentExecutionInputSupport } from "./executionInput/types.js";
+import { type AgentStructuredOutputBinding } from "./structuredOutput/admission.js";
 interface ObservedAgentItem {
     readonly itemKind: AgentItemKind;
     readonly status: AgentItemStatus;
@@ -47,8 +49,15 @@ interface ActiveAgentTurn {
     readonly inFlightOperations: Set<Promise<void>>;
     readonly owner: ValidatedAgentTurnExecution;
 }
-export declare function createAgentSessionValidationOwner(capabilities: AgentCapabilities, sessionId: AgentSessionId): {
+export declare function assertAgentTurnInputCapability(input: {
+    readonly capability: AgentOperationInputCapability;
+    readonly parts: AgentProviderStartTurnInput["parts"];
+    readonly providerKey: AgentProviderKey;
+}): void;
+export declare function createAgentSessionValidationOwner(capabilities: AgentCapabilities, sessionId: AgentSessionId, structuredOutputBinding?: AgentStructuredOutputBinding, executionInputSupport?: AgentExecutionInputSupport): {
     sessionAdmission: {
+        trackOperation(): () => void;
+        joinOperations(): Promise<void>;
         reserveExecution(): object;
         installExecution(token: object, execution: ActiveAgentTurn): void;
         releaseExecution(token: object): void;
@@ -69,11 +78,14 @@ export declare function createAgentSessionValidationOwner(capabilities: AgentCap
     stop(): void;
     completeClose(): void;
     installClose(close: () => Promise<void>): void;
+    installInputContextGuard(guard: () => void): void;
     reserveExecution: () => object;
     ownsExecution: (token: object) => boolean;
     releaseExecution: (token: object) => void;
+    admitTurnOutput(output: unknown, hasOutput: boolean): AgentStructuredOutputBinding | undefined;
+    requireNativeContinuationSupport: () => void;
     installNativeExecution(token: object, turnId: AgentTurnId, createCandidate: (signal: AbortSignal) => AgentProviderTurnExecution): AdoptedAgentTurnExecution;
-    installCallerExecution(token: object, turnInput: AgentProviderStartTurnInput, start: (input: AgentProviderStartTurnInput) => AgentProviderTurnExecution): ValidatedAgentTurnExecution;
+    installCallerExecution(token: object, turnInput: AgentProviderStartTurnInput, start: (input: AgentProviderStartTurnInput) => AgentProviderTurnExecution, binding?: AgentStructuredOutputBinding): ValidatedAgentTurnExecution;
 };
 export type AgentSessionValidationOwner = ReturnType<typeof createAgentSessionValidationOwner>;
 export declare function validateAgentProviderSession(input: {

package/dist/sessionValidation.js

@@ -48,6 +48,10 @@ import { createValidatedAgentTurnExecution, adoptValidatedAgentTurnExecution } f
 import { validateAgentProviderTurnInterruptionResult } from "./turnExecution/receipts.js";
 import { createAgentTurnRequestAdmission } from "./turnExecution/requests.js";
 import { createAgentSessionAdmission } from "./sessionAdmission.js";
+import { createExecutionInputCensus } from "./executionInput/lifetime.js";
+import {
+  admitAgentStructuredOutputTurn
+} from "./structuredOutput/admission.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.");
@@ -499,6 +503,7 @@ const SESSION_OPERATION_OBSERVATION_EVENT_TYPES = /* @__PURE__ */ new Set([
   "resource.updated",
   "runtime.warning",
   "runtime.error",
+  "runtime.retrying",
   "provider.diagnostic"
 ]);
 function observeSessionOperationOutput(input) {
@@ -619,7 +624,7 @@ function assertAgentTurnInputCapability(input) {
   });
   if (textIssue) rejectReference(`${textIssue.target} must use ${textIssue.format} text`);
 }
-function createAgentSessionValidationOwner(capabilities, sessionId) {
+function createAgentSessionValidationOwner(capabilities, sessionId, structuredOutputBinding, executionInputSupport) {
   const providerKey = capabilities.providerKey;
   const sessionLifetime = new AbortController();
   const sessionAdmission = createAgentSessionAdmission(providerKey);
@@ -638,6 +643,15 @@ function createAgentSessionValidationOwner(capabilities, sessionId) {
   let closed = false;
   let unusable = false;
   let closing;
+  let requireInputContext = () => {
+  };
+  const executionInputCensus = createExecutionInputCensus(providerKey, () => {
+    unusable = true;
+    queueMicrotask(() => {
+      void closing?.().catch(() => {
+      });
+    });
+  });
   const requireOpen = () => {
     if (closed)
       throwAgentProviderContractError(
@@ -676,6 +690,11 @@ function createAgentSessionValidationOwner(capabilities, sessionId) {
     const inFlightOperations = /* @__PURE__ */ new Set();
     const common = {
       providerKey,
+      ...executionInputSupport === void 0 ? {} : { executionInputSupport },
+      executionInputCensus,
+      ownsExecution: () => sessionAdmission.ownsExecution(token),
+      requireInputContext: () => requireInputContext(),
+      structuredOutputBound: source.kind === "caller" && source.binding !== void 0,
       pendingRequests,
       sessionAdmission,
       inFlightOperations,
@@ -683,7 +702,10 @@ function createAgentSessionValidationOwner(capabilities, sessionId) {
       isTerminal: () => state.terminal,
       canRestoreRequest: (pending) => hasLiveApprovalSubject(pending.request, state),
       observe(candidate, requests) {
-        const output = validateAgentProviderOutputForContext(candidate, outputContext(turnId));
+        const output = validateAgentProviderOutputForContext(candidate, {
+          ...outputContext(turnId),
+          ...source.kind !== "caller" || source.binding === void 0 ? {} : { structuredOutputBinding: source.binding }
+        });
         observeTurnOutput({
           capabilities,
           providerKey,
@@ -718,6 +740,15 @@ function createAgentSessionValidationOwner(capabilities, sessionId) {
     }
     return owner;
   }
+  const requireNativeContinuationSupport = () => {
+    if (structuredOutputBinding !== void 0) {
+      throwAgentProviderContractError(
+        providerKey,
+        "structured_output_unsupported",
+        "Schema-bound sessions cannot dispatch native continuations without structured-output admission."
+      );
+    }
+  };
   return {
     sessionAdmission,
     sessionLifetime,
@@ -748,14 +779,38 @@ function createAgentSessionValidationOwner(capabilities, sessionId) {
     installClose(close) {
       closing = close;
     },
+    installInputContextGuard(guard) {
+      requireInputContext = guard;
+    },
     reserveExecution: sessionAdmission.reserveExecution,
     ownsExecution: sessionAdmission.ownsExecution,
     releaseExecution: sessionAdmission.releaseExecution,
+    admitTurnOutput(output, hasOutput) {
+      if (structuredOutputBinding !== void 0 && hasOutput) {
+        throwAgentProviderContractError(
+          providerKey,
+          "structured_output_scope_mismatch",
+          "A schema-bound session cannot override or remove its opening structured-output request."
+        );
+      }
+      return admitAgentStructuredOutputTurn({
+        capabilities,
+        ...structuredOutputBinding === void 0 ? {} : { binding: structuredOutputBinding },
+        output
+      });
+    },
+    requireNativeContinuationSupport,
     installNativeExecution(token, turnId, createCandidate) {
+      requireNativeContinuationSupport();
       return installExecution(token, turnId, { kind: "native", createCandidate });
     },
-    installCallerExecution(token, turnInput, start) {
-      return installExecution(token, turnInput.turnId, { kind: "caller", input: turnInput, start });
+    installCallerExecution(token, turnInput, start, binding) {
+      return installExecution(token, turnInput.turnId, {
+        kind: "caller",
+        input: turnInput,
+        start,
+        ...binding === void 0 ? {} : { binding }
+      });
     }
   };
 }
@@ -795,6 +850,14 @@ function validateAgentProviderSession(input) {
   }
   validateSessionPorts(capabilities, input.candidate);
   const validationOwner = input.validationOwner ?? createAgentSessionValidationOwner(capabilities, sessionId);
+  validationOwner.installInputContextGuard(() => {
+    input.sessionInteractionOwner?.requireUsable();
+    if (input.sessionInteractionOwner?.hasLiveRequests) throwAgentProviderContractError(
+      providerKey,
+      "request_pending",
+      "Execution input cannot enter while a session interaction remains unsettled."
+    );
+  });
   const { sessionLifetime, contextUsageState, interactionState, outputContext } = validationOwner;
   const collaborationNodes = interactionState.collaborationNodes;
   const collaborationSpawnReservations = interactionState.collaborationSpawnReservations;
@@ -861,6 +924,7 @@ function validateAgentProviderSession(input) {
       turnId: turnInput.turnId,
       interactionMode: turnInput.interactionMode,
       parts: turnInput.parts,
+      ...turnInput.output === void 0 ? {} : { output: turnInput.output },
       ...turnInput.summary === void 0 ? {} : { summary: turnInput.summary },
       ...turnInput.deadlineAt === void 0 ? {} : { deadlineAt: turnInput.deadlineAt }
     });
@@ -872,13 +936,15 @@ function validateAgentProviderSession(input) {
         `Provider ${providerKey} does not support ${parsedInput.interactionMode} turn interaction mode.`
       );
     }
+    const binding2 = validationOwner.admitTurnOutput(parsedInput.output, Reflect.has(turnInput, "output"));
     const token = validationOwner.reserveExecution();
     try {
       return validationOwner.installCallerExecution(token, {
         ...parsedInput,
+        ...parsedInput.output === void 0 || binding2 === void 0 ? {} : { output: binding2.request },
         ...turnInput.signal === void 0 ? {} : { signal: turnInput.signal },
         ...turnInput.onProviderExecutionStarted === void 0 ? {} : { onProviderExecutionStarted: turnInput.onProviderExecutionStarted }
-      }, (inputTurn) => input.candidate.startTurn(inputTurn)).execution;
+      }, (inputTurn) => input.candidate.startTurn(inputTurn), binding2).execution;
     } catch (error) {
       validationOwner.releaseExecution(token);
       throw error;
@@ -907,6 +973,7 @@ function validateAgentProviderSession(input) {
       const settleActiveInterruption = trackActiveTurnOperation(
         targetedActiveTurn
       );
+      targetedTurn.owner.closeInputAdmission();
       try {
         const suspendedRequests = targetedTurn.owner.suspendRequests();
         let result;
@@ -938,6 +1005,13 @@ function validateAgentProviderSession(input) {
     steerTurn: async (steeringInput) => {
       requireUsable();
       throwIfAgentOperationAborted(steeringInput.signal);
+      if (Reflect.has(steeringInput, "output")) {
+        throwAgentProviderContractError(
+          providerKey,
+          "structured_output_scope_mismatch",
+          "Steering cannot change a turn's structured-output request."
+        );
+      }
       const turnId = parseAgentTurnId(steeringInput.turnId);
       if (validationOwner.activeTurn?.turnId !== turnId || !validationOwner.activeTurn.owner.hasEntered() || validationOwner.activeTurn.state.terminal || validationOwner.activeTurn.pendingRequests.size > 0) {
         throwAgentProviderContractError(
@@ -1048,142 +1122,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();
       }
     }
   });
@@ -1442,7 +1528,7 @@ function validateAgentProviderSession(input) {
     validationOwner.stop();
     input.hostBindingLease?.stop();
     const closingTurn = validationOwner.activeTurn;
-    closingTurn?.owner.stop(new DOMException("The provider session was closed.", "AbortError"));
+    closingTurn?.owner.stop(new DOMException("The provider session was closed.", "AbortError"), "closed");
     const cleanup = async () => {
       if (!providerClosed) {
         await input.candidate.close(closeInput);
@@ -1450,6 +1536,7 @@ function validateAgentProviderSession(input) {
       }
       await input.sessionInteractionOwner?.join();
       await closingTurn?.owner.join();
+      await validationOwner.sessionAdmission.joinOperations();
       await input.hostBindingLease?.release();
       validationOwner.completeClose();
     };
@@ -1609,6 +1696,7 @@ async function openIdentityCreatingAgentProviderSession(input) {
   }
 }
 export {
+  assertAgentTurnInputCapability,
   closeRejectedAgentProviderSession,
   createAgentSessionValidationOwner,
   openIdentityCreatingAgentProviderSession,