@agen-ai/agent-runtime 0.4.1 → 0.4.2

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
   });
 }
@@ -541,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
   });
@@ -637,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;
@@ -672,58 +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 = () => {
-    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 +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,
@@ -786,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({
@@ -855,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(
@@ -880,7 +920,7 @@ function validateAgentProviderSession(input) {
           );
         } catch (error) {
           suspendedRequests.withdraw();
-          unusable = true;
+          validationOwner.fence();
           throw error;
         }
         if (result.status === "failed") {
@@ -899,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",
@@ -915,7 +955,7 @@ function validateAgentProviderSession(input) {
         parts: content.parts,
         providerKey
       });
-      const targetedActiveTurn = activeTurn;
+      const targetedActiveTurn = validationOwner.activeTurn;
       const settleSteering = trackActiveTurnOperation(targetedActiveTurn);
       try {
         try {
@@ -927,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",
@@ -1394,14 +1434,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) {
@@ -1411,7 +1451,7 @@ function validateAgentProviderSession(input) {
       await input.sessionInteractionOwner?.join();
       await closingTurn?.owner.join();
       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 +1460,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 +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) {
@@ -1529,15 +1576,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 +1610,7 @@ async function openIdentityCreatingAgentProviderSession(input) {
 }
 export {
   closeRejectedAgentProviderSession,
+  createAgentSessionValidationOwner,
   openIdentityCreatingAgentProviderSession,
   validateAgentProviderSession
 };

package/dist/sessions.d.ts

@@ -1,9 +1,10 @@
 import type { AgentAuthenticationFlow, AgentCollaborationControlInput, AgentCollaborationNode, AgentCollaborationSpawnInput, AgentConfigurationCatalog, AgentConfigurationSelectionInput, AgentError, AgentGeneratedResourceDescriptor, AgentGeneratedResourceId, AgentManagedContentCatalog, AgentOperationCatalog, AgentOperationInvocation, AgentOperationResult, AgentRequestResolution, AgentSessionBinding, AgentSessionBranchSource, AgentSessionConfiguration, AgentSessionId, AgentTurnId, AgentTurnInputContent, AgentTurnInteractionMode, AgentTurnInputPart, AgentTurnInterruptionReason } from "@agen-ai/agent-protocol";
+import type { AgentNativeContinuationContext, AgentNativeContinuationSupport } from "./nativeContinuations/types.js";
 import type { MaybePromise } from "./foundation.js";
 import type { AgentSessionHostBinding, AgentSessionHostBindingSupport } from "./hostBindings/types.js";
 import type { AgentProviderOutput } from "./outputs.js";
 import type { AgentArtifactCandidate } from "./artifacts.js";
-import type { AgentSessionInteractionContext, AgentSessionInteractionSupport } from "./sessionInteractions/types.js";
+import type { AgentProviderSessionInteractionContext, AgentSessionInteractionContext, AgentSessionInteractionSupport } from "./sessionInteractions/types.js";
 import type { AgentEnvironmentObservationPort } from "./environment/types.js";
 export interface AgentProviderSessionContext {
     readonly sessionId: AgentSessionId;
@@ -11,7 +12,7 @@ export interface AgentProviderSessionContext {
     readonly configuration: AgentSessionConfiguration;
     readonly signal?: AbortSignal;
     readonly hostBinding?: AgentSessionHostBinding;
-    readonly interactions?: AgentSessionInteractionContext;
+    readonly interactions?: AgentProviderSessionInteractionContext;
 }
 export type AgentSessionBindingCreatedObserver = (binding: AgentSessionBinding) => void;
 export interface AgentProviderCreateSessionInput extends AgentProviderSessionContext {
@@ -216,9 +217,39 @@ export type AgentProviderAuthentication = Readonly<{
 export interface AgentProviderAdapter {
     readonly sessionInteractions?: AgentSessionInteractionSupport;
     readonly hostBinding?: AgentSessionHostBindingSupport;
+    readonly nativeContinuations?: AgentNativeContinuationSupport;
     readonly createSession: (input: AgentProviderCreateSessionInput) => MaybePromise<AgentProviderSession>;
     readonly resumption: AgentSessionResumption;
     readonly branching: AgentSessionBranching;
     readonly authentication: AgentProviderAuthentication;
 }
+export type AgentSessionOpenContext = Omit<AgentProviderSessionContext, "interactions"> & Readonly<{
+    interactions?: AgentSessionInteractionContext;
+    nativeContinuations?: AgentNativeContinuationContext;
+}>;
+export type AgentCreateSessionInput = AgentSessionOpenContext & Readonly<{
+    onBindingCreated: AgentSessionBindingCreatedObserver;
+}>;
+export type AgentResumeSessionInput = AgentSessionOpenContext & Readonly<{
+    binding: AgentSessionBinding;
+}>;
+export type AgentBranchSessionInput = AgentSessionOpenContext & Readonly<{
+    source: AgentSessionBranchSource;
+    onBindingCreated: AgentSessionBindingCreatedObserver;
+}>;
+export type AgentValidatedProviderAdapter = Omit<AgentProviderAdapter, "createSession" | "resumption" | "branching"> & Readonly<{
+    createSession: (input: AgentCreateSessionInput) => MaybePromise<AgentProviderSession>;
+    resumption: Readonly<{
+        kind: "unsupported";
+    }> | Readonly<{
+        kind: "supported";
+        resumeSession: (input: AgentResumeSessionInput) => MaybePromise<AgentProviderSession>;
+    }>;
+    branching: Readonly<{
+        kind: "unsupported";
+    }> | Readonly<{
+        kind: "through_turn";
+        branchSession: (input: AgentBranchSessionInput) => MaybePromise<AgentProviderSession>;
+    }>;
+}>;
 //# sourceMappingURL=sessions.d.ts.map

package/dist/testing/conformance.d.ts

@@ -18,7 +18,9 @@ export interface AgentProviderConformanceScenario {
     readonly interruptionSessionId: AgentSessionId;
     readonly turn: AgentProviderStartTurnInput;
     readonly interruptionTurn: AgentProviderStartTurnInput;
-    readonly resolutionFor: (request: AgentRequest) => AgentRequestResolution;
+    readonly resolutionFor: (request: AgentRequest, context: Readonly<{
+        signal: AbortSignal;
+    }>) => AgentRequestResolution | undefined | Promise<AgentRequestResolution | undefined>;
     readonly branchSource?: (binding: AgentSessionBinding, turnId: AgentTurnId) => AgentSessionBranchSource;
     readonly steeringInput?: AgentTurnInputContent;
 }