Class RuntimeKernel

packages/runtime/src/runtime-kernel.ts:395–3274

}

export class RuntimeKernel implements RuntimeKernelLike {
  private readonly active = new Map<string, BackendGeneration>();
  private readonly childActive = new Map<string, BackendGeneration>();
  private readonly backendGenerations = new Map<number, BackendGeneration>();
  private readonly backendActivationBuilds = new Map<string, Promise<BackendGeneration>>();
  private readonly stopOperations = new Map<string, StopOperation>();
  private readonly stopAttempts = new Map<string, Promise<void>>();
  private readonly executionClaims = new Map<string, Set<PendingExecutionClaim>>();
  private readonly sessionMutationTails = new Map<string, Promise<void>>();
  private readonly executionClaimStates = new WeakMap<
    RuntimeExecutionClaim,
    PendingExecutionClaim
  >();
  private readonly stopIntents = new Map<string, SessionStopIntent>();
  private readonly historyCompactCoordinator: HistoryCompactCheckpointCoordinator;
  private readonly pendingContinuationClaims = new Set<string>();
  private readonly pendingContinuationSessions = new Set<string>();
  private readonly steeringBySession = new Map<string, SessionSteeringState>();
  private readonly backendInvalidations = new Map<string, BackendInvalidationState>();
  private readonly interactionRequestOwners = new Map<string, InteractionRequestOwner>();
  private nextBackendGeneration = 0;
  private readonly interactionRuns = new Map<AgentRun, RuntimeInteractionRunBinding>();

  constructor(private readonly deps: RuntimeKernelDeps) {
    if (deps.runStore && !deps.runtimeEventStore) {
      throw new Error('RuntimeEventStore is required when AgentRunStore is configured');
    }
    this.historyCompactCoordinator = new HistoryCompactCheckpointCoordinator(deps);
  }

  private async runBackendActivation<T>(operation: () => Promise<T> | T): Promise<T> {
    return await (this.deps.runBackendActivation?.(operation) ?? operation());
  }

  claimExecution(sessionId: string): RuntimeExecutionClaim {
    if (this.stopIntents.has(sessionId)) {
      throw new Error(`Session ${sessionId} is stopping and cannot admit a new execution`);
    }
    let resolveSettled!: () => void;
    let rejectSettled!: (error: unknown) => void;
    const settled = new Promise<void>((resolve, reject) => {
      resolveSettled = resolve;
      rejectSettled = reject;
    });
    // A failed claim may have no concurrent stop subscriber; stop still observes this same promise.
    void settled.catch(() => undefined);
    const abortController = new AbortController();
    const cancellation = new RuntimeExecutionCancellation(sessionId);
    const handle: RuntimeExecutionClaim = {
      sessionId,
      stopSignal: abortController.signal,
      isStopRequested: () => state.stopIntent !== undefined,
      release: () => this.releaseExecutionClaim(state),
    };
    const state: PendingExecutionClaim = {
      handle,
      sessionId,
      abortController,