@agen-ai/agent-runtime 0.4.1 → 0.4.2

package/dist/sessionInteractions/lifetime.js

@@ -4,7 +4,8 @@ import {
   captureSessionInteractionCandidate,
   interactionContractError,
   validateSessionInteractionCandidate,
-  validateSessionInteractionContext
+  validateSessionInteractionContext,
+  validateNativeContinuationContext
 } from "./validation.js";
 function sessionInteractionError(code, message, uncertain = false) {
   return Object.freeze({
@@ -27,9 +28,15 @@ function waitForInteractionWork(work, timeoutMs) {
   });
 }
 class SessionInteractionOwner {
-  constructor(providerKey, sessionId, context, signal) {
+  constructor(providerKey, sessionId, context, validationOwner, operation, support, nativeSupport, continuations, signal) {
     this.providerKey = providerKey;
     this.sessionId = sessionId;
+    this.validationOwner = validationOwner;
+    this.operation = operation;
+    this.support = support;
+    this.nativeSupport = nativeSupport;
+    this.admission = validationOwner.sessionAdmission;
+    this.continuations = validateNativeContinuationContext(continuations);
     try {
       this.context = validateSessionInteractionContext(context);
     } catch (cause) {
@@ -45,7 +52,9 @@ class SessionInteractionOwner {
     this.failure = new Promise((resolve) => {
       this.resolveFailure = resolve;
     });
-    this.facade = Object.freeze({ limits: this.limits, onRequest: (candidate) => this.offer(candidate) });
+    const { requestTimeoutMs: _timeout, ...nonHumanLimits } = this.limits;
+    const onRequest = (candidate) => this.offer(candidate);
+    this.facade = this.context.humanWait === "bounded" ? Object.freeze({ humanWait: Object.freeze({ kind: "bounded" }), limits: this.limits, onRequest }) : Object.freeze({ humanWait: Object.freeze({ kind: "until_withdrawn_or_closed" }), limits: Object.freeze(nonHumanLimits), onRequest });
     if (signal) {
       const aborted = () => this.fail(signal.reason ?? new DOMException("Session opening was aborted.", "AbortError"));
       signal.addEventListener("abort", aborted, { once: true });
@@ -53,6 +62,7 @@ class SessionInteractionOwner {
       if (signal.aborted) aborted();
     }
   }
+  admission;
   facade;
   openingSignal;
   limits;
@@ -71,8 +81,18 @@ class SessionInteractionOwner {
   cleanupAttempt = null;
   cleanupDeadline = 0;
   cleanupComplete = false;
+  retainedCleanup;
   cleanupFailure;
   adopted = false;
+  bound = false;
+  returned = false;
+  waiting = /* @__PURE__ */ new Map();
+  associationTimer;
+  prebindingCount = 0;
+  prebindingBytes = 0;
+  preparations = /* @__PURE__ */ new Set();
+  stoppedExecution = null;
+  continuations;
   context;
   track(promise) {
     this.work.add(promise);
@@ -84,6 +104,7 @@ class SessionInteractionOwner {
   }
   requireUsable() {
     if (this.fatal) throw this.fatal.cause;
+    this.validationOwner.requireUsable();
     if (!this.accepting) throw this.fenceCause ?? new AgentProviderContractError(
       this.providerKey,
       this.state === "closed" ? "session_closed" : "session_unusable",
@@ -96,13 +117,18 @@ class SessionInteractionOwner {
       captured = captureSessionInteractionCandidate(candidate, (terminal) => {
         this.track(terminal);
       });
-      const validated = validateSessionInteractionCandidate(captured, this.sessionId, this.limits.requestTimeoutMs);
+      const validated = validateSessionInteractionCandidate(captured, this.sessionId, this.context);
       this.requireUsable();
+      if (this.support.kind !== "supported" || !this.support.mappings.some((entry) => entry.openingOperation === this.operation && entry.requestKind === validated.request.kind)) {
+        throw interactionContractError(this.providerKey, "Provider offered an undeclared session request kind.");
+      }
+      if (validated.kind === "prepared") this.requireContinuation(validated.request.kind);
       if (validated.signal.aborted) throw interactionContractError(this.providerKey, "Provider offered an unavailable session interaction.");
       const bytes = Buffer.byteLength(JSON.stringify(validated.request), "utf8");
       if (this.requests.has(validated.request.requestId) || this.requests.size >= this.limits.maxRetainedRequests || this.retainedBytes + bytes > this.limits.maxRetainedBytes) {
         throw interactionContractError(this.providerKey, "Session interaction identity or retained capacity is unavailable.");
       }
+      this.admission.claimRequest(validated.request.requestId, "invalid_session_interaction");
       const request = new SessionInteractionRequest(this, validated, () => {
         this.requests.delete(validated.request.requestId);
         this.retainedBytes -= bytes;
@@ -110,15 +136,45 @@ class SessionInteractionOwner {
       this.requests.set(validated.request.requestId, request);
       this.retainedBytes += bytes;
       request.observe();
-      let callback;
-      try {
-        callback = Promise.resolve(this.context.onRequest(request.handle));
-      } catch (cause) {
-        callback = Promise.reject(cause);
-      }
+      let resolveCallback;
+      let rejectCallback;
+      const callback = new Promise((resolve, reject) => {
+        resolveCallback = resolve;
+        rejectCallback = reject;
+      });
+      const present = () => {
+        this.waiting.delete(present);
+        if (!this.accepting || request.handle.signal.aborted) {
+          resolveCallback();
+          return;
+        }
+        try {
+          Promise.resolve(this.context.onRequest(request.handle)).then(resolveCallback, rejectCallback);
+        } catch (cause) {
+          rejectCallback(cause);
+        }
+      };
       request.setCallback(callback);
       this.track(callback);
       void callback.catch((cause) => this.fail(cause));
+      if (validated.kind === "direct" || this.canPresent(validated.request.kind)) present();
+      else {
+        this.waiting.set(present, validated.request.kind);
+        if (!this.bound) {
+          this.prebindingCount += 1;
+          this.prebindingBytes += bytes;
+          if (this.prebindingCount > 16 || this.prebindingBytes > 1048576) throw new AgentProviderContractError(
+            this.providerKey,
+            "native_continuation_limit_exceeded",
+            "Prebinding association exceeded its retained material budget."
+          );
+          this.associationTimer ??= setTimeout(() => this.fail(new AgentProviderContractError(
+            this.providerKey,
+            "invalid_native_continuation",
+            "Prebinding association did not finish before its deadline."
+          )), 3e4);
+        }
+      }
       return callback;
     } catch (cause) {
       const failure = cause instanceof AgentProviderContractError ? cause : new AgentProviderContractError(
@@ -134,8 +190,48 @@ class SessionInteractionOwner {
       return rejected;
     }
   }
+  requireContinuation(kind) {
+    if (!this.continuations || this.nativeSupport.kind !== "supported" || !this.nativeSupport.mappings.some((entry) => entry.openingOperation === this.operation && entry.requestKind === kind)) {
+      throw new AgentProviderContractError(this.providerKey, "native_continuations_unsupported", "Provider native continuation requires its exact supported tuple and a host output handler.");
+    }
+  }
+  canPresent(kind) {
+    return this.bound && this.nativeSupport.kind === "supported" && this.nativeSupport.mappings.some((entry) => entry.openingOperation === this.operation && entry.requestKind === kind && (entry.timing !== "after_open_return" || this.returned));
+  }
+  bind() {
+    this.requireUsable();
+    this.bound = true;
+    if (this.associationTimer) clearTimeout(this.associationTimer);
+    this.prebindingCount = 0;
+    this.prebindingBytes = 0;
+    this.presentWaiting();
+  }
+  markReturned() {
+    this.returned = true;
+    this.presentWaiting();
+  }
+  presentWaiting() {
+    for (const [present, kind] of this.waiting) if (!this.accepting || this.canPresent(kind)) present();
+  }
+  async cleanupFailedPreparation() {
+    if (this.cleanupComplete) return;
+    if (this.retainedCleanup) return this.close(this.retainedCleanup, false);
+    if (this.automaticClose) return this.automaticClose();
+    throw new Error("Opening cleanup has not acquired its native session owner.");
+  }
+  quiesce() {
+    if (this.adopted && this.automaticClose) void this.automaticClose().catch(() => {
+    });
+  }
+  retainPreparation(cleanup) {
+    this.preparations.add(cleanup);
+    return () => {
+      this.preparations.delete(cleanup);
+    };
+  }
   installClose(close) {
     this.automaticClose = close;
+    this.validationOwner.installClose(close);
   }
   adopt() {
     this.requireUsable();
@@ -145,6 +241,7 @@ class SessionInteractionOwner {
   }
   fence(cause, source) {
     if (!this.accepting) return;
+    this.validationOwner.fence();
     this.fenceCause = new AgentProviderContractError(
       this.providerKey,
       "session_unusable",
@@ -179,15 +276,23 @@ class SessionInteractionOwner {
   }
   stop(terminal = Object.freeze({ kind: "session_closed" })) {
     if (this.state !== "closed" && this.state !== "cleanup-pending") this.state = "stopping";
+    this.stoppedExecution ??= this.validationOwner.activeTurn;
+    this.validationOwner.stop();
+    this.stoppedExecution?.owner.stop(new DOMException("The session interaction owner was stopped.", "AbortError"));
     this.removeOpeningAbort();
+    if (this.associationTimer) clearTimeout(this.associationTimer);
+    this.presentWaiting();
     this.controller.abort(new DOMException("The session interaction owner was stopped.", "AbortError"));
     for (const request of this.requests.values()) request.stop(terminal);
   }
   async join() {
+    await Promise.all([...this.preparations].map((cleanup) => cleanup()));
     while (this.work.size > 0) await Promise.allSettled([...this.work]);
     await Promise.all([...this.requests.values()].map((request) => request.join()));
+    await this.stoppedExecution?.owner.join();
   }
   close(cleanup, explicit) {
+    this.retainedCleanup ??= cleanup;
     this.stop();
     if (!this.cleanupComplete && !this.cleanupAttempt) {
       this.state = "cleanup-pending";
@@ -233,15 +338,42 @@ class SessionInteractionOwner {
   }
 }
 function createSessionInteractionOwner(input) {
-  if (input.context === void 0) return void 0;
-  if (input.support.kind === "unsupported" || !input.support.openingOperations.includes(input.operation)) {
+  if (input.context === void 0) {
+    if (input.continuations !== void 0) throw new AgentProviderContractError(input.providerKey, "native_continuations_unsupported", "Native continuations require session interaction handlers.");
+    return void 0;
+  }
+  if (input.support.kind === "unsupported" || !input.support.mappings.some((entry) => entry.openingOperation === input.operation)) {
     throw new AgentProviderContractError(
       input.providerKey,
       "session_interactions_unsupported",
       "Provider does not support session interactions for this opening operation."
     );
   }
-  return new SessionInteractionOwner(input.providerKey, input.sessionId, input.context, input.signal);
+  let parsed;
+  try {
+    parsed = validateSessionInteractionContext(input.context);
+  } catch (cause) {
+    throw new AgentProviderContractError(input.providerKey, "invalid_session_interaction", "Session interaction context is invalid.", { cause });
+  }
+  if (!input.support.humanWait.includes(parsed.humanWait)) throw new AgentProviderContractError(
+    input.providerKey,
+    "session_interactions_unsupported",
+    "Provider does not support the selected human wait policy."
+  );
+  if (input.continuations !== void 0 && (input.nativeSupport.kind !== "supported" || !input.nativeSupport.mappings.some((entry) => entry.openingOperation === input.operation))) {
+    throw new AgentProviderContractError(input.providerKey, "native_continuations_unsupported", "Provider does not support continuations for this opening operation.");
+  }
+  return new SessionInteractionOwner(
+    input.providerKey,
+    input.sessionId,
+    input.context,
+    input.validationOwner,
+    input.operation,
+    input.support,
+    input.nativeSupport,
+    input.continuations,
+    input.signal
+  );
 }
 export {
   SessionInteractionOwner,

package/dist/sessionInteractions/request.d.ts

@@ -1,7 +1,7 @@
 import { type SessionInteractionOwner } from "./lifetime.js";
 import type { AgentSessionInteraction, AgentSessionInteractionTerminal } from "./types.js";
-import { type CapturedSessionInteractionCandidate } from "./validation.js";
-type Candidate = CapturedSessionInteractionCandidate & Pick<AgentSessionInteraction, "request">;
+import { type ValidatedSessionInteractionCandidate } from "./validation.js";
+type Candidate = ValidatedSessionInteractionCandidate;
 export declare class SessionInteractionRequest {
     private readonly owner;
     private readonly candidate;
@@ -25,6 +25,7 @@ export declare class SessionInteractionRequest {
     constructor(owner: SessionInteractionOwner, candidate: Candidate, retire: () => void);
     observe(): void;
     setCallback(callback: Promise<void>): void;
+    private scheduleExpiry;
     private expire;
     private protocolFailure;
     private observeTerminal;

package/dist/sessionInteractions/request.js

@@ -1,10 +1,11 @@
-import { parseAgentSessionDecisionResponseFor } from "@agen-ai/agent-protocol";
+import { parseAgentSessionResponseFor } from "@agen-ai/agent-protocol";
 import { throwIfAgentOperationAborted } from "../foundation.js";
 import { AgentProviderContractError } from "../contractErrors.js";
-import { hasExactOwnKeys } from "../internal/objectShape.js";
 import { validateAgentRequestResolutionResult } from "../turnExecution/receipts.js";
 import { sessionInteractionError } from "./lifetime.js";
+import { dispatchPreparedSessionResponse, mintSessionResponseAttemptId } from "../nativeContinuations/admission.js";
 import { interactionContractError, validateSessionInteractionTerminal } from "./validation.js";
+const MAX_EXPIRY_TIMER_DELAY_MS = 2147483647;
 class SessionInteractionRequest {
   constructor(owner, candidate, retire) {
     this.owner = owner;
@@ -15,6 +16,7 @@ class SessionInteractionRequest {
     });
     this.handle = Object.freeze({
       request: candidate.request,
+      deadline: candidate.deadline,
       signal: this.presentation.signal,
       terminal,
       respond: (input) => this.respond(input)
@@ -42,7 +44,6 @@ class SessionInteractionRequest {
   };
   observe() {
     this.candidate.signal.addEventListener("abort", this.nativeAborted, { once: true });
-    this.expiryTimer = setTimeout(() => this.expire(), Math.max(0, Date.parse(this.handle.request.expiresAt) - Date.now()));
     void this.candidate.terminal.then((candidate) => {
       this.rawTerminalSettled = true;
       if (this.terminalTimer) clearTimeout(this.terminalTimer);
@@ -60,6 +61,7 @@ class SessionInteractionRequest {
       this.maybeRetire();
     });
     if (this.candidate.signal.aborted) this.nativeAborted();
+    this.scheduleExpiry();
   }
   setCallback(callback) {
     this.callback = callback;
@@ -74,9 +76,21 @@ class SessionInteractionRequest {
       }
     );
   }
+  scheduleExpiry() {
+    if (this.candidate.deadlineAt === void 0 || this.state.kind === "terminal") return;
+    const remainingMs = this.candidate.deadlineAt - Date.now();
+    if (remainingMs <= 0) {
+      this.expire();
+      return;
+    }
+    this.expiryTimer = setTimeout(() => {
+      this.expiryTimer = void 0;
+      this.scheduleExpiry();
+    }, Math.min(remainingMs, MAX_EXPIRY_TIMER_DELAY_MS));
+  }
   expire() {
     if (this.state.kind === "terminal") return;
-    this.stop(Object.freeze({ kind: "expired" }));
+    this.stop(Object.freeze({ kind: "expired", source: this.candidate.deadline.kind === "deadline" ? this.candidate.deadline.source : "provider" }));
     this.owner.fail(interactionContractError(this.owner.providerKey, "Session interaction expired before final delivery."));
   }
   protocolFailure(cause) {
@@ -108,6 +122,7 @@ class SessionInteractionRequest {
       this.stopped ??= terminal;
       this.unavailable = true;
       this.presentation.abort(new DOMException("The provider interaction is no longer answerable.", "AbortError"));
+      this.finalize(this.stopped, attempt);
     }
     if (attempt && !attempt.actualReceipt) return;
     if (attempt?.actualReceipt && this.receiptContradiction(attempt, attempt.actualReceipt)) {
@@ -117,7 +132,7 @@ class SessionInteractionRequest {
       );
     }
     if (terminal.kind === "answered") {
-      if (!attempt || terminal.choiceId !== attempt.choiceId || attempt.actualReceipt?.status !== "delivered") {
+      if (!attempt || JSON.stringify(terminal.response) !== JSON.stringify(attempt.response) || attempt.actualReceipt?.status !== "delivered") {
         throw interactionContractError(this.owner.providerKey, "Provider interaction acceptance disagrees with its delivery receipt.");
       }
       this.finalize(terminal, attempt);
@@ -151,7 +166,7 @@ class SessionInteractionRequest {
     this.stopped ??= terminal;
     this.unavailable = true;
     this.presentation.abort(new DOMException("The session interaction was stopped.", "AbortError"));
-    if (this.state.kind === "pending") this.finalize(this.stopped, void 0, nativeRetirementExpected);
+    if (this.state.kind !== "terminal") this.finalize(this.stopped, void 0, nativeRetirementExpected);
     if (nativeRetirementExpected) this.expectTerminal();
   }
   refusal(active = false) {
@@ -179,45 +194,86 @@ class SessionInteractionRequest {
       "Session interaction response delivery failed after provider entry.",
       { cause }
     ), this);
+    if (this.candidate.kind === "prepared") this.owner.quiesce();
     return receipt;
   }
   receiptContradiction(attempt, result) {
     const terminal = this.nativeTerminal;
     if (!terminal) return false;
     if (result.status === "delivery_uncertain") return terminal.kind === "rejected";
-    if (terminal.kind === "answered") return terminal.choiceId !== attempt.choiceId || result.status !== "delivered";
-    if (result.status === "delivered") return true;
+    if (terminal.kind === "answered") return JSON.stringify(terminal.response) !== JSON.stringify(attempt.response) || result.status !== "delivered";
+    if (result.status === "delivered") return terminal.kind === "rejected" || terminal.kind === "delivery_uncertain";
     if (terminal.kind === "delivery_uncertain") return true;
     return result.requestState === "pending" && terminal.kind === "rejected";
   }
   async respond(input) {
-    if (input === null || typeof input !== "object" || !hasExactOwnKeys(input, Object.hasOwn(input, "signal") ? ["choiceId", "signal"] : ["choiceId"])) {
-      throw new TypeError("Session interaction response must contain a choice and an optional AbortSignal.");
-    }
-    const responseSignal = input.signal;
-    if (responseSignal !== void 0 && !(responseSignal instanceof AbortSignal)) {
-      throw new TypeError("Session interaction response signal must be an AbortSignal.");
-    }
-    const response = parseAgentSessionDecisionResponseFor(this.handle.request, { choiceId: input.choiceId });
+    if (input === null || typeof input !== "object" || Array.isArray(input)) throw new TypeError("Session response must be an object.");
+    const { signal: responseSignal, ...rawResponse } = input;
+    if (responseSignal !== void 0 && !(responseSignal instanceof AbortSignal)) throw new TypeError("Session interaction response signal must be an AbortSignal.");
+    const response = parseAgentSessionResponseFor(this.handle.request, rawResponse);
     throwIfAgentOperationAborted(responseSignal);
     const deadline = new AbortController();
     const signal = AbortSignal.any([this.presentation.signal, deadline.signal, ...responseSignal ? [responseSignal] : []]);
-    if (Date.parse(this.handle.request.expiresAt) <= Date.now()) this.expire();
+    if (this.candidate.deadlineAt !== void 0 && this.candidate.deadlineAt <= Date.now()) this.expire();
     if (this.unavailable || !this.owner.accepting || this.state.kind === "terminal") return this.refusal();
     if (this.state.kind === "answering") return this.refusal(true);
-    const attempt = { choiceId: response.choiceId, deadline: Date.now() + this.owner.limits.responseTimeoutMs };
+    const attempt = { response: projectResponse(response), deadline: Date.now() + this.owner.limits.responseTimeoutMs, entered: false };
     this.lastAttempt = attempt;
     this.state = { kind: "answering", attempt };
     this.responseWork += 1;
     let entered;
-    try {
-      entered = Promise.resolve(this.candidate.respond({ ...response, signal }));
-    } catch (cause) {
-      entered = Promise.reject(cause);
+    const requireCurrent = () => {
+      if (this.state.kind !== "answering" || this.state.attempt !== attempt || this.unavailable) throw new DOMException("Session response is no longer eligible.", "AbortError");
+      if (this.candidate.deadlineAt !== void 0 && this.candidate.deadlineAt <= Date.now()) {
+        this.expire();
+        throw new DOMException("Session response expired before entry.", "AbortError");
+      }
+    };
+    if (this.candidate.kind === "prepared") {
+      entered = dispatchPreparedSessionResponse({
+        owner: this.owner,
+        candidate: this.candidate,
+        response,
+        attemptId: mintSessionResponseAttemptId(),
+        signal,
+        requireCurrent,
+        onDispatch: (deadlineAt) => {
+          attempt.entered = true;
+          attempt.deadline = deadlineAt;
+        },
+        observeActualReceipt: (work) => {
+          this.responseWork += 1;
+          const actual2 = this.owner.track(work.then((result2) => {
+            attempt.actualReceipt = result2;
+            try {
+              this.observeTerminal();
+            } catch (cause) {
+              this.protocolFailure(cause);
+            }
+          }));
+          void actual2.then(
+            () => {
+              this.responseWork -= 1;
+              this.maybeRetire();
+            },
+            () => {
+              this.responseWork -= 1;
+              this.maybeRetire();
+            }
+          );
+        }
+      });
+    } else {
+      attempt.entered = true;
+      try {
+        entered = Promise.resolve(this.candidate.respond({ ...response, signal }));
+      } catch (cause) {
+        entered = Promise.reject(cause);
+      }
     }
     const actual = this.owner.track(entered.then((candidate) => {
       const result2 = validateAgentRequestResolutionResult(candidate, this.owner.providerKey);
-      attempt.actualReceipt = result2;
+      if (this.candidate.kind === "direct") attempt.actualReceipt = result2;
       if (this.state.kind === "terminal") {
         try {
           this.observeTerminal();
@@ -240,6 +296,7 @@ class SessionInteractionRequest {
     );
     let timer;
     const timeout = new Promise((resolve) => {
+      if (this.candidate.kind === "prepared") return;
       timer = setTimeout(
         () => {
           deadline.abort(new DOMException("Session interaction response timed out.", "TimeoutError"));
@@ -253,6 +310,11 @@ class SessionInteractionRequest {
     try {
       result = await Promise.race([actual, timeout]);
     } catch (cause) {
+      if (!attempt.entered) {
+        if (this.state.kind === "answering" && this.state.attempt === attempt) this.state = { kind: "pending" };
+        this.lastAttempt = void 0;
+        throw cause;
+      }
       responseFailure = cause;
       result = null;
     }
@@ -270,12 +332,12 @@ class SessionInteractionRequest {
     if (result.status === "delivery_uncertain") {
       this.finalize(Object.freeze({ kind: "delivery_uncertain", error: result.error }), attempt);
       this.owner.fence(result.error, this);
+      if (this.candidate.kind === "prepared") this.owner.quiesce();
     } else if (result.status === "delivered") {
-      this.finalize(Object.freeze({ kind: "answered", choiceId: attempt.choiceId }), attempt);
+      this.finalize(this.stopped ?? Object.freeze({ kind: "answered", response: attempt.response }), attempt);
     } else if (result.requestState === "unavailable") {
       this.finalize(this.stopped ?? Object.freeze({ kind: "rejected", error: result.error }), attempt);
     } else if (this.stopped || this.unavailable || !this.owner.accepting) {
-      result = this.refusal();
       if (this.stopped || !this.owner.accepting) this.finalize(this.stopped ?? Object.freeze({ kind: "session_closed" }), attempt);
       else {
         this.state = { kind: "pending" };
@@ -303,6 +365,17 @@ class SessionInteractionRequest {
     await Promise.allSettled([this.candidate.terminal, ...this.callback ? [this.callback] : []]);
   }
 }
+function projectResponse(response) {
+  if (response.kind === "form") return Object.freeze({ kind: "form", action: response.action, choiceId: response.choiceId });
+  if (response.kind === "plan_review") return Object.freeze({
+    kind: "plan_review",
+    action: response.action,
+    choiceId: response.choiceId,
+    planId: response.planId,
+    revision: response.revision
+  });
+  return response;
+}
 export {
   SessionInteractionRequest
 };

package/dist/sessionInteractions/types.d.ts

@@ -1,14 +1,25 @@
-import type { AgentError, AgentSessionDecisionChoiceId, AgentSessionDecisionRequest, AgentSessionDecisionResponse } from "@agen-ai/agent-protocol";
+import type { AgentError, AgentSessionAcceptedResponse, AgentSessionDecisionResponse, AgentSessionRequest, AgentSessionRequestKind, AgentSessionResponse, AgentSessionFormRequest, AgentSessionPlanReviewRequest } from "@agen-ai/agent-protocol";
 import type { MaybePromise } from "../foundation.js";
 import type { AgentRequestResolutionResult } from "../sessions.js";
+import type { AgentPreparedSessionResponse, AgentSessionResponseAttemptId } from "../nativeContinuations/types.js";
 export type AgentSessionInteractionOpeningOperation = "create" | "resume" | "branch";
+export type AgentSessionHumanWaitKind = "bounded" | "until_withdrawn_or_closed";
+export type AgentSessionHumanWaitPolicy = Readonly<{
+    kind: "bounded";
+}> | Readonly<{
+    kind: "until_withdrawn_or_closed";
+}>;
+export interface AgentSessionInteractionMapping {
+    readonly openingOperation: AgentSessionInteractionOpeningOperation;
+    readonly requestKind: AgentSessionRequestKind;
+}
 export type AgentSessionInteractionSupport = Readonly<{
     kind: "unsupported";
 }> | Readonly<{
     kind: "supported";
-    openingOperations: readonly [AgentSessionInteractionOpeningOperation, ...AgentSessionInteractionOpeningOperation[]];
-    requestKinds: readonly ["decision"];
+    mappings: readonly [AgentSessionInteractionMapping, ...AgentSessionInteractionMapping[]];
     producerOwnership: "exclusive";
+    humanWait: readonly [AgentSessionHumanWaitKind, ...AgentSessionHumanWaitKind[]];
 }>;
 export interface AgentSessionInteractionLimits {
     readonly maxRetainedRequests: number;
@@ -17,12 +28,33 @@ export interface AgentSessionInteractionLimits {
     readonly responseTimeoutMs: number;
     readonly cleanupTimeoutMs: number;
 }
-export interface AgentSessionDecisionResponseInput extends AgentSessionDecisionResponse {
-    readonly signal?: AbortSignal;
-}
+export type AgentSessionInteractionOptions = Readonly<{
+    humanWait?: Readonly<{
+        kind: "bounded";
+    }>;
+    limits?: Partial<AgentSessionInteractionLimits>;
+}> | Readonly<{
+    humanWait: Readonly<{
+        kind: "until_withdrawn_or_closed";
+    }>;
+    limits?: Partial<Omit<AgentSessionInteractionLimits, "requestTimeoutMs">>;
+}>;
+export type AgentSessionInteractionDeadline = Readonly<{
+    kind: "no_deadline";
+}> | Readonly<{
+    kind: "deadline";
+    expiresAt: import("@agen-ai/agent-protocol").AgentIsoDateTime;
+    source: "provider" | "host_policy";
+}>;
+export type AgentSessionResponseInput = AgentSessionResponse & Readonly<{
+    signal?: AbortSignal;
+}>;
+export type AgentSessionDecisionResponseInput = AgentSessionDecisionResponse & Readonly<{
+    signal?: AbortSignal;
+}>;
 export type AgentSessionInteractionTerminal = Readonly<{
     kind: "answered";
-    choiceId: AgentSessionDecisionChoiceId;
+    response: AgentSessionAcceptedResponse;
 }> | Readonly<{
     kind: "rejected";
     error: AgentError;
@@ -33,6 +65,7 @@ export type AgentSessionInteractionTerminal = Readonly<{
     kind: "withdrawn";
 }> | Readonly<{
     kind: "expired";
+    source: "provider" | "host_policy";
 }> | Readonly<{
     kind: "session_closed";
 }> | Readonly<{
@@ -40,15 +73,38 @@ export type AgentSessionInteractionTerminal = Readonly<{
     error: AgentError;
 }>;
 export interface AgentSessionInteraction {
-    readonly request: AgentSessionDecisionRequest;
+    readonly request: AgentSessionRequest;
+    readonly deadline: AgentSessionInteractionDeadline;
     readonly signal: AbortSignal;
     readonly terminal: Promise<AgentSessionInteractionTerminal>;
-    readonly respond: (input: AgentSessionDecisionResponseInput) => Promise<AgentRequestResolutionResult>;
+    readonly respond: (input: AgentSessionResponseInput) => Promise<AgentRequestResolutionResult>;
 }
 export type AgentSessionInteractionHandler = (interaction: AgentSessionInteraction) => MaybePromise<void>;
-export interface AgentSessionInteractionContext {
-    readonly onRequest: AgentSessionInteractionHandler;
-    readonly limits?: Partial<AgentSessionInteractionLimits>;
+export type AgentSessionInteractionContext = AgentSessionInteractionOptions & Readonly<{
+    onRequest: AgentSessionInteractionHandler;
+}>;
+export interface AgentProviderDirectSessionInteraction {
+    readonly kind: "direct";
+    readonly request: AgentSessionRequest;
+    readonly signal: AbortSignal;
+    readonly terminal: Promise<AgentSessionInteractionTerminal>;
+    readonly respond: (input: AgentSessionResponseInput) => Promise<AgentRequestResolutionResult>;
+}
+export interface AgentProviderPrepareSessionResponseInput {
+    readonly response: AgentSessionResponse;
+    readonly responseAttemptId: AgentSessionResponseAttemptId;
+    readonly signal: AbortSignal;
 }
+export interface AgentProviderPreparedSessionInteraction {
+    readonly kind: "prepared";
+    readonly request: AgentSessionFormRequest | AgentSessionPlanReviewRequest;
+    readonly signal: AbortSignal;
+    readonly terminal: Promise<AgentSessionInteractionTerminal>;
+    readonly prepareResponse: (input: AgentProviderPrepareSessionResponseInput) => MaybePromise<AgentPreparedSessionResponse>;
+}
+export type AgentProviderSessionInteraction = AgentProviderDirectSessionInteraction | AgentProviderPreparedSessionInteraction;
+export type AgentProviderSessionInteractionContext = AgentSessionInteractionOptions & Readonly<{
+    onRequest: (interaction: AgentProviderSessionInteraction) => MaybePromise<void>;
+}>;
 export declare const DEFAULT_AGENT_SESSION_INTERACTION_LIMITS: Readonly<AgentSessionInteractionLimits>;
 //# sourceMappingURL=types.d.ts.map