@agen-ai/agent-runtime 0.4.1 → 0.4.2

package/dist/sessionInteractions/validation.d.ts

@@ -1,21 +1,25 @@
 import { type AgentCapabilities, type AgentProviderKey, type AgentSessionId } from "@agen-ai/agent-protocol";
 import { AgentProviderContractError } from "../contractErrors.js";
 import type { AgentProviderAdapter } from "../sessions.js";
-import { type AgentSessionInteraction, type AgentSessionInteractionContext, type AgentSessionInteractionLimits, type AgentSessionInteractionSupport, type AgentSessionInteractionTerminal } from "./types.js";
+import type { AgentNativeContinuationSupport, AgentNativeContinuationContext } from "../nativeContinuations/types.js";
+import { type AgentSessionInteractionContext, type AgentSessionInteractionLimits, type AgentSessionInteractionSupport, type AgentSessionInteractionTerminal, type AgentSessionHumanWaitKind, type AgentProviderSessionInteraction, type AgentSessionInteractionDeadline } from "./types.js";
+export declare function interactionRecord(input: unknown): Record<string, unknown>;
 export declare function interactionContractError(providerKey: AgentProviderKey, message: string): AgentProviderContractError;
 export declare function validateSessionInteractionSupport(capabilities: AgentCapabilities, adapter: AgentProviderAdapter): AgentSessionInteractionSupport;
+export declare function validateNativeContinuationSupport(capabilities: AgentCapabilities, adapter: AgentProviderAdapter, interactions: AgentSessionInteractionSupport): AgentNativeContinuationSupport;
 export interface ValidatedSessionInteractionContext {
     readonly onRequest: AgentSessionInteractionContext["onRequest"];
+    readonly humanWait: AgentSessionHumanWaitKind;
     readonly limits: Readonly<AgentSessionInteractionLimits>;
 }
 export declare function validateSessionInteractionContext(input: AgentSessionInteractionContext): ValidatedSessionInteractionContext;
-export interface CapturedSessionInteractionCandidate {
-    readonly request: unknown;
-    readonly signal: AbortSignal;
-    readonly terminal: Promise<unknown>;
-    readonly respond: AgentSessionInteraction["respond"];
-}
-export declare function captureSessionInteractionCandidate(input: AgentSessionInteraction, observe: (terminal: Promise<unknown>) => void): CapturedSessionInteractionCandidate;
-export declare function validateSessionInteractionCandidate(input: CapturedSessionInteractionCandidate, sessionId: AgentSessionId, requestTimeoutMs: number): CapturedSessionInteractionCandidate & Pick<AgentSessionInteraction, "request">;
+export declare function validateNativeContinuationContext(input: AgentNativeContinuationContext | undefined): AgentNativeContinuationContext | undefined;
+export type CapturedSessionInteractionCandidate = AgentProviderSessionInteraction;
+export declare function captureSessionInteractionCandidate(input: AgentProviderSessionInteraction, observe: (terminal: Promise<unknown>) => void): CapturedSessionInteractionCandidate;
+export type ValidatedSessionInteractionCandidate = CapturedSessionInteractionCandidate & Readonly<{
+    deadline: AgentSessionInteractionDeadline;
+    deadlineAt?: number;
+}>;
+export declare function validateSessionInteractionCandidate(input: CapturedSessionInteractionCandidate, sessionId: AgentSessionId, context: ValidatedSessionInteractionContext): ValidatedSessionInteractionCandidate;
 export declare function validateSessionInteractionTerminal(input: unknown): AgentSessionInteractionTerminal;
 //# sourceMappingURL=validation.d.ts.map

package/dist/sessionInteractions/validation.js

@@ -1,50 +1,98 @@
 import path from "node:path";
 import {
   parseAgentError,
-  parseAgentSessionDecisionChoiceId,
-  parseAgentSessionDecisionRequest
+  parseAgentIsoDateTime,
+  parseAgentSessionRequest,
+  parseAgentSessionResponse,
+  parseAgentSessionFormChoiceId,
+  parseAgentSessionPlanReviewChoiceId,
+  parseAgentSessionPlanId,
+  parseAgentSessionPlanRevision
 } from "@agen-ai/agent-protocol";
 import { AgentProviderContractError } from "../contractErrors.js";
 import { hasExactOwnKeys } from "../internal/objectShape.js";
 import {
   DEFAULT_AGENT_SESSION_INTERACTION_LIMITS
 } from "./types.js";
-function record(input) {
+function interactionRecord(input) {
   if (input === null || typeof input !== "object" || Array.isArray(input)) throw new TypeError("Expected an interaction object.");
   return input;
 }
 function interactionContractError(providerKey, message) {
   return new AgentProviderContractError(providerKey, "invalid_session_interaction", message);
 }
+const operations = ["create", "resume", "branch"];
+const kinds = ["decision", "form", "plan_review"];
+const timings = ["after_open_return", "before_open_return", "before_binding"];
+const waits = ["bounded", "until_withdrawn_or_closed"];
+function ordered(input, values) {
+  if (!Array.isArray(input) || input.length === 0 || input.length > values.length) throw new TypeError("Expected a bounded nonempty support list.");
+  let last = -1;
+  const result = [];
+  for (const value of input) {
+    const index = values.indexOf(value);
+    if (index <= last) throw new TypeError("Support must be unique and canonical-sorted.");
+    last = index;
+    result.push(values[index]);
+  }
+  const [first, ...rest] = result;
+  if (first === void 0) throw new TypeError();
+  return Object.freeze([first, ...rest]);
+}
+function mapping(input, capabilities, adapter) {
+  const value = interactionRecord(input);
+  const operation = operations.find((entry) => entry === value.openingOperation);
+  const requestKind = kinds.find((entry) => entry === value.requestKind);
+  if (!operation || !requestKind || operation === "resume" && (!capabilities.sessions.resume || adapter.resumption.kind !== "supported") || operation === "branch" && (capabilities.sessions.branch.kind !== "through_turn" || adapter.branching.kind !== "through_turn")) throw new TypeError();
+  return Object.freeze({ openingOperation: operation, requestKind });
+}
 function validateSessionInteractionSupport(capabilities, adapter) {
-  const input = adapter.sessionInteractions;
-  if (input === void 0) return Object.freeze({ kind: "unsupported" });
+  if (adapter.sessionInteractions === void 0) return Object.freeze({ kind: "unsupported" });
   try {
-    const value = record(input);
+    const value = interactionRecord(adapter.sessionInteractions);
     if (value.kind === "unsupported" && hasExactOwnKeys(value, ["kind"])) return Object.freeze({ kind: "unsupported" });
-    if (!hasExactOwnKeys(value, ["kind", "openingOperations", "requestKinds", "producerOwnership"]) || value.kind !== "supported" || value.producerOwnership !== "exclusive" || !Array.isArray(value.openingOperations) || value.openingOperations.length === 0 || !Array.isArray(value.requestKinds) || value.requestKinds.length !== 1 || value.requestKinds[0] !== "decision") throw new TypeError();
-    const operations = [];
-    for (const operation of value.openingOperations) {
-      if (operation !== "create" && operation !== "resume" && operation !== "branch") throw new TypeError();
-      if (operations.includes(operation)) throw new TypeError();
-      if (operation === "resume" && (!capabilities.sessions.resume || adapter.resumption.kind !== "supported")) throw new TypeError();
-      if (operation === "branch" && (capabilities.sessions.branch.kind !== "through_turn" || adapter.branching.kind !== "through_turn")) throw new TypeError();
-      operations.push(operation);
-    }
-    const order = ["create", "resume", "branch"];
-    if (operations.some((operation, index) => index > 0 && order.indexOf(operation) < order.indexOf(operations[index - 1]))) throw new TypeError();
-    const [first, ...rest] = operations;
-    if (first === void 0) throw new TypeError();
-    return Object.freeze({
-      kind: "supported",
-      producerOwnership: "exclusive",
-      openingOperations: Object.freeze([first, ...rest]),
-      requestKinds: Object.freeze(["decision"])
+    if (!hasExactOwnKeys(value, ["kind", "mappings", "producerOwnership", "humanWait"]) || value.kind !== "supported" || value.producerOwnership !== "exclusive" || !Array.isArray(value.mappings) || value.mappings.length < 1 || value.mappings.length > 9) throw new TypeError();
+    let previous = -1;
+    const parsed = value.mappings.map((entry) => {
+      if (!hasExactOwnKeys(interactionRecord(entry), ["openingOperation", "requestKind"])) throw new TypeError();
+      const parsed2 = mapping(entry, capabilities, adapter);
+      const index = operations.indexOf(parsed2.openingOperation) * 3 + kinds.indexOf(parsed2.requestKind);
+      if (index <= previous) throw new TypeError();
+      previous = index;
+      return parsed2;
     });
+    const [first, ...rest] = parsed;
+    if (!first) throw new TypeError();
+    return Object.freeze({ kind: "supported", producerOwnership: "exclusive", mappings: Object.freeze([first, ...rest]), humanWait: ordered(value.humanWait, waits) });
   } catch {
     throw interactionContractError(capabilities.providerKey, "Provider declared invalid session interaction support.");
   }
 }
+function validateNativeContinuationSupport(capabilities, adapter, interactions) {
+  if (adapter.nativeContinuations === void 0) return Object.freeze({ kind: "unsupported" });
+  try {
+    const value = interactionRecord(adapter.nativeContinuations);
+    if (value.kind === "unsupported" && hasExactOwnKeys(value, ["kind"])) return Object.freeze({ kind: "unsupported" });
+    if (!hasExactOwnKeys(value, ["kind", "mappings", "producerOwnership"]) || value.kind !== "supported" || value.producerOwnership !== "exclusive" || !Array.isArray(value.mappings) || value.mappings.length < 1 || value.mappings.length > 18 || interactions.kind !== "supported") throw new TypeError();
+    let previous = -1;
+    const parsed = value.mappings.map((entry) => {
+      const record = interactionRecord(entry);
+      if (!hasExactOwnKeys(record, ["openingOperation", "requestKind", "timing"])) throw new TypeError();
+      const parsed2 = mapping(record, capabilities, adapter);
+      const timing = timings.find((entry2) => entry2 === record.timing);
+      if (parsed2.requestKind === "decision" || !timing || !interactions.mappings.some((entry2) => entry2.openingOperation === parsed2.openingOperation && entry2.requestKind === parsed2.requestKind)) throw new TypeError();
+      const index = operations.indexOf(parsed2.openingOperation) * 6 + (parsed2.requestKind === "form" ? 0 : 3) + timings.indexOf(timing);
+      if (index <= previous) throw new TypeError();
+      previous = index;
+      return Object.freeze({ openingOperation: parsed2.openingOperation, requestKind: parsed2.requestKind, timing });
+    });
+    const [first, ...rest] = parsed;
+    if (!first) throw new TypeError();
+    return Object.freeze({ kind: "supported", producerOwnership: "exclusive", mappings: Object.freeze([first, ...rest]) });
+  } catch {
+    throw new AgentProviderContractError(capabilities.providerKey, "capability_port_mismatch", "Provider declared invalid native continuation support.");
+  }
+}
 const limitRanges = {
   maxRetainedRequests: [1, 32],
   maxRetainedBytes: [65536, 2097152],
@@ -53,65 +101,78 @@ const limitRanges = {
   cleanupTimeoutMs: [1e3, 12e4]
 };
 function validateSessionInteractionContext(input) {
-  const value = record(input);
-  const onRequest = value.onRequest;
-  if (!hasExactOwnKeys(value, Object.hasOwn(value, "limits") ? ["onRequest", "limits"] : ["onRequest"]) || typeof onRequest !== "function") throw new TypeError("Session interactions require a callable handler and known fields.");
-  const supplied = value.limits === void 0 ? {} : record(value.limits);
-  if (Reflect.ownKeys(supplied).some((key) => typeof key !== "string" || !Object.hasOwn(limitRanges, key))) {
-    throw new TypeError("Session interaction limits contain an unknown field.");
-  }
+  const value = interactionRecord(input);
+  if (Reflect.ownKeys(value).some((key) => !["onRequest", "limits", "humanWait"].includes(String(key))) || typeof value.onRequest !== "function") throw new TypeError("Session interactions require a callable handler and known fields.");
+  const human = value.humanWait === void 0 ? { kind: "bounded" } : interactionRecord(value.humanWait);
+  if (!hasExactOwnKeys(human, ["kind"]) || human.kind !== "bounded" && human.kind !== "until_withdrawn_or_closed") throw new TypeError("Invalid human wait policy.");
+  const supplied = value.limits === void 0 ? {} : interactionRecord(value.limits);
+  if (Reflect.ownKeys(supplied).some((key) => typeof key !== "string" || !Object.hasOwn(limitRanges, key)) || human.kind === "until_withdrawn_or_closed" && Object.hasOwn(supplied, "requestTimeoutMs")) throw new TypeError("Conflicting or unknown session interaction limits.");
   const limits = { ...DEFAULT_AGENT_SESSION_INTERACTION_LIMITS };
   for (const key of Object.keys(limitRanges)) {
     const number = supplied[key];
     if (number === void 0) continue;
     const [minimum, maximum] = limitRanges[key];
-    if (typeof number !== "number" || !Number.isSafeInteger(number) || number < minimum || number > maximum) {
-      throw new RangeError(`Session interaction ${key} must be an integer between ${minimum} and ${maximum}.`);
-    }
+    if (typeof number !== "number" || !Number.isSafeInteger(number) || number < minimum || number > maximum) throw new RangeError(`Invalid session interaction ${key}.`);
     limits[key] = number;
   }
-  return Object.freeze({ onRequest: onRequest.bind(input), limits: Object.freeze(limits) });
+  return Object.freeze({ onRequest: input.onRequest.bind(input), humanWait: human.kind, limits: Object.freeze(limits) });
+}
+function validateNativeContinuationContext(input) {
+  if (input === void 0) return void 0;
+  const value = interactionRecord(input);
+  if (!hasExactOwnKeys(value, ["onExecution"]) || typeof value.onExecution !== "function") throw new TypeError("Native continuations require one callable handler.");
+  return Object.freeze({ onExecution: input.onExecution.bind(input) });
 }
 function captureSessionInteractionCandidate(input, observe) {
-  const value = record(input);
+  const value = interactionRecord(input);
   const terminal = value.terminal;
   const observation = Promise.resolve(terminal);
   void observation.catch(() => {
   });
   observe(observation);
-  const request = value.request;
-  const signal = value.signal;
-  const respond = value.respond;
-  if (!hasExactOwnKeys(value, ["request", "signal", "terminal", "respond"]) || !(signal instanceof AbortSignal) || typeof respond !== "function" || !terminal || typeof record(terminal).then !== "function") throw new TypeError("Provider offered an invalid session interaction handle.");
-  return Object.freeze({
-    request,
-    signal,
-    terminal: observation,
-    respond: respond.bind(input)
-  });
-}
-function validateSessionInteractionCandidate(input, sessionId, requestTimeoutMs) {
-  const parsed = parseAgentSessionDecisionRequest(input.request);
-  if (parsed.sessionId !== sessionId || !path.isAbsolute(parsed.target.path) || path.normalize(parsed.target.path) !== parsed.target.path) {
-    throw new TypeError("Session interaction does not match its session or canonical workspace target.");
+  if (!(value.signal instanceof AbortSignal) || !terminal || typeof interactionRecord(terminal).then !== "function") throw new TypeError("Invalid interaction lifecycle.");
+  if (value.kind === "direct" && hasExactOwnKeys(value, ["kind", "request", "signal", "terminal", "respond"]) && typeof value.respond === "function") {
+    return Object.freeze({ kind: "direct", request: input.request, signal: value.signal, terminal: observation, respond: value.respond.bind(input) });
   }
-  const expiry = Math.min(Date.parse(parsed.expiresAt), Date.now() + requestTimeoutMs);
-  if (expiry <= Date.now()) throw new TypeError("Provider offered an expired session interaction.");
-  const request = parseAgentSessionDecisionRequest({ ...parsed, expiresAt: new Date(expiry).toISOString() });
-  return Object.freeze({ ...input, request });
+  if (value.kind === "prepared" && hasExactOwnKeys(value, ["kind", "request", "signal", "terminal", "prepareResponse"]) && typeof value.prepareResponse === "function") {
+    const request = parseAgentSessionRequest(value.request);
+    if (request.kind === "decision") throw new TypeError("Decisions cannot prepare native execution.");
+    return Object.freeze({ kind: "prepared", request, signal: value.signal, terminal: observation, prepareResponse: value.prepareResponse.bind(input) });
+  }
+  throw new TypeError("Provider offered an invalid session interaction handle.");
+}
+function validateSessionInteractionCandidate(input, sessionId, context) {
+  const request = parseAgentSessionRequest(input.request);
+  if (request.sessionId !== sessionId || request.kind === "decision" && (!path.isAbsolute(request.target.path) || path.normalize(request.target.path) !== request.target.path)) throw new TypeError("Interaction does not match its exact session or canonical workspace target.");
+  const provider = request.expiresAt === void 0 ? void 0 : Date.parse(request.expiresAt);
+  const host = context.humanWait === "bounded" ? Date.now() + context.limits.requestTimeoutMs : void 0;
+  const source = provider !== void 0 && (host === void 0 || provider <= host) ? "provider" : "host_policy";
+  const deadlineAt = source === "provider" ? provider : host;
+  const deadline = deadlineAt === void 0 ? Object.freeze({ kind: "no_deadline" }) : Object.freeze({ kind: "deadline", expiresAt: source === "provider" ? request.expiresAt : parseAgentIsoDateTime(new Date(deadlineAt).toISOString()), source });
+  if (input.kind === "prepared" && request.kind === "decision") throw new TypeError();
+  return Object.freeze({ ...input, request, deadline, ...deadlineAt === void 0 ? {} : { deadlineAt } });
+}
+function acceptedResponse(input) {
+  const value = interactionRecord(input);
+  if (value.kind === "decision") return parseAgentSessionResponse(value);
+  if (value.kind === "form" && hasExactOwnKeys(value, ["kind", "action", "choiceId"]) && (value.action === "submit" || value.action === "cancel")) return Object.freeze({ kind: "form", action: value.action, choiceId: parseAgentSessionFormChoiceId(value.choiceId) });
+  if (value.kind === "plan_review" && hasExactOwnKeys(value, ["kind", "action", "choiceId", "planId", "revision"]) && (value.action === "approve" || value.action === "revise" || value.action === "abandon")) return Object.freeze({ kind: "plan_review", action: value.action, choiceId: parseAgentSessionPlanReviewChoiceId(value.choiceId), planId: parseAgentSessionPlanId(value.planId), revision: parseAgentSessionPlanRevision(value.revision) });
+  throw new TypeError("Invalid accepted response.");
 }
 function validateSessionInteractionTerminal(input) {
-  const value = record(input);
-  if (value.kind === "answered" && hasExactOwnKeys(value, ["kind", "choiceId"])) {
-    return Object.freeze({ kind: "answered", choiceId: parseAgentSessionDecisionChoiceId(value.choiceId) });
-  }
+  const value = interactionRecord(input);
+  if (value.kind === "answered" && hasExactOwnKeys(value, ["kind", "response"])) return Object.freeze({ kind: "answered", response: acceptedResponse(value.response) });
   if ((value.kind === "failed" || value.kind === "rejected" || value.kind === "delivery_uncertain") && hasExactOwnKeys(value, ["kind", "error"])) return Object.freeze({ kind: value.kind, error: parseAgentError(value.error) });
-  if ((value.kind === "withdrawn" || value.kind === "expired" || value.kind === "session_closed") && hasExactOwnKeys(value, ["kind"])) return Object.freeze({ kind: value.kind });
+  if (value.kind === "expired" && hasExactOwnKeys(value, ["kind", "source"]) && (value.source === "provider" || value.source === "host_policy")) return Object.freeze({ kind: "expired", source: value.source });
+  if ((value.kind === "withdrawn" || value.kind === "session_closed") && hasExactOwnKeys(value, ["kind"])) return Object.freeze({ kind: value.kind });
   throw new TypeError("Provider returned an invalid session interaction terminal.");
 }
 export {
   captureSessionInteractionCandidate,
   interactionContractError,
+  interactionRecord,
+  validateNativeContinuationContext,
+  validateNativeContinuationSupport,
   validateSessionInteractionCandidate,
   validateSessionInteractionContext,
   validateSessionInteractionSupport,

package/dist/sessionValidation.d.ts

@@ -1,8 +1,81 @@
-import { type AgentCapabilities, type AgentProviderKey, type AgentSessionBinding, type AgentSessionId } from "@agen-ai/agent-protocol";
+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 AgentHostBindingLease } from "./hostBindings/lifetime.js";
 import { type MaybePromise } from "./foundation.js";
-import type { AgentProviderSession, AgentSessionBindingCreatedObserver } from "./sessions.js";
+import { type AgentProviderOutputValidationContext } from "./outputValidation.js";
+import type { AgentProviderStartTurnInput, AgentProviderSession, AgentSessionBindingCreatedObserver, AgentProviderTurnExecution } from "./sessions.js";
+import { type ValidatedAgentTurnExecution, type AdoptedAgentTurnExecution } from "./turnExecution/execution.js";
+import { type PendingAgentRequest } from "./turnExecution/requests.js";
 import type { SessionInteractionOwner } from "./sessionInteractions/lifetime.js";
+interface ObservedAgentItem {
+    readonly itemKind: AgentItemKind;
+    readonly status: AgentItemStatus;
+    readonly inProgressObserved: boolean;
+    readonly terminal: boolean;
+}
+interface AgentTurnSequenceState {
+    readonly fileChangeMode: AgentCapabilities["output"]["fileChanges"];
+    readonly observedItems: Map<string, ObservedAgentItem>;
+    readonly proposedPlans: Map<string, string>;
+    readonly generatedResourceIds: Set<string>;
+    started: boolean;
+    terminal: boolean;
+    finalDiffObserved: boolean;
+}
+interface AgentContextUsageSequenceState {
+    readonly latestByScope: Map<AgentContextMeasurementScope, AgentContextUsage>;
+    readonly cumulativeByScope: Map<AgentContextMeasurementScope, AgentContextCumulativeUsage>;
+    readonly compactionReadyScopes: Set<AgentContextMeasurementScope>;
+}
+interface TrackedAgentOperationInvocation {
+    readonly invocation: AgentOperationInvocation;
+    result?: AgentOperationResult;
+}
+interface AgentInteractionSequenceState {
+    readonly operationResults: Map<string, AgentOperationResult>;
+    readonly operationInvocations: Map<string, TrackedAgentOperationInvocation>;
+    readonly collaborationNodes: Map<string, AgentCollaborationNode>;
+    readonly collaborationSpawnReservations: Map<string, AgentCollaborationSpawnReservation>;
+    readonly generatedResources: Map<string, AgentGeneratedResourceDescriptor>;
+}
+interface AgentCollaborationSpawnReservation {
+    readonly parentCollaborationId?: string;
+}
+interface ActiveAgentTurn {
+    readonly turnId: AgentTurnId;
+    readonly pendingRequests: Map<string, PendingAgentRequest>;
+    readonly state: AgentTurnSequenceState;
+    readonly inFlightOperations: Set<Promise<void>>;
+    readonly owner: ValidatedAgentTurnExecution;
+}
+export declare function createAgentSessionValidationOwner(capabilities: AgentCapabilities, sessionId: AgentSessionId): {
+    sessionAdmission: {
+        reserveExecution(): object;
+        installExecution(token: object, execution: ActiveAgentTurn): void;
+        releaseExecution(token: object): void;
+        readonly execution: ActiveAgentTurn | null;
+        ownsExecution(token: object): boolean;
+        stop(): void;
+        claimRequest(requestId: import("@agen-ai/agent-protocol").AgentRequestId, duplicateCode: "invalid_turn_sequence" | "invalid_session_interaction"): void;
+    };
+    sessionLifetime: AbortController;
+    contextUsageState: AgentContextUsageSequenceState;
+    interactionState: AgentInteractionSequenceState;
+    outputContext: (turnId?: AgentTurnId) => AgentProviderOutputValidationContext;
+    requireUsable: () => void;
+    readonly activeTurn: ActiveAgentTurn | null;
+    readonly closed: boolean;
+    readonly unusable: boolean;
+    fence(): void;
+    stop(): void;
+    completeClose(): void;
+    installClose(close: () => Promise<void>): void;
+    reserveExecution: () => object;
+    ownsExecution: (token: object) => boolean;
+    releaseExecution: (token: object) => void;
+    installNativeExecution(token: object, turnId: AgentTurnId, createCandidate: (signal: AbortSignal) => AgentProviderTurnExecution): AdoptedAgentTurnExecution;
+    installCallerExecution(token: object, turnInput: AgentProviderStartTurnInput, start: (input: AgentProviderStartTurnInput) => AgentProviderTurnExecution): ValidatedAgentTurnExecution;
+};
+export type AgentSessionValidationOwner = ReturnType<typeof createAgentSessionValidationOwner>;
 export declare function validateAgentProviderSession(input: {
     readonly capabilities: AgentCapabilities;
     readonly sessionId: AgentSessionId;
@@ -11,6 +84,7 @@ export declare function validateAgentProviderSession(input: {
     readonly sourceBinding?: AgentSessionBinding;
     readonly hostBindingLease?: AgentHostBindingLease;
     readonly sessionInteractionOwner?: SessionInteractionOwner;
+    readonly validationOwner?: AgentSessionValidationOwner;
 }): AgentProviderSession;
 export declare function closeRejectedAgentProviderSession(session: AgentProviderSession | null, error: unknown, hostBinding?: Readonly<{
     providerKey: AgentProviderKey;
@@ -27,6 +101,8 @@ export declare function openIdentityCreatingAgentProviderSession(input: {
     readonly hostBindingLease?: AgentHostBindingLease;
     readonly openingInput?: object;
     readonly sessionInteractionOwner?: SessionInteractionOwner;
+    readonly validationOwner?: AgentSessionValidationOwner;
     readonly open: (observer: AgentSessionBindingCreatedObserver) => MaybePromise<AgentProviderSession>;
 }): Promise<AgentProviderSession>;
+export {};
 //# sourceMappingURL=sessionValidation.d.ts.map