Method compactSessionClaimed

packages/runtime/src/runtime-kernel.ts:959–1112

(
    sessionId: string,
    input: CompactSessionInput,
    execution: PendingExecutionClaim,
  )

  }

  private async *compactSessionClaimed(
    sessionId: string,
    input: CompactSessionInput,
    execution: PendingExecutionClaim,
  ): AsyncIterable<SessionEvent> {
    await this.enterExecutionClaim(execution);
    if (
      input.minRecentTurns !== undefined &&
      (!Number.isSafeInteger(input.minRecentTurns) || input.minRecentTurns < 0)
    ) {
      throw new Error('Runtime compaction minRecentTurns must be a non-negative safe integer');
    }
    if (!this.deps.runStore || !this.deps.runtimeEventStore) {
      throw new RuntimeContextCompactError(
        'operation_unavailable',
        'Runtime compaction requires execution stores',
      );
    }
    if (this.hasActiveRuns(sessionId)) {
      throw new RuntimeContextCompactError(
        'session_busy',
        'Cannot compact while a Turn is running',
      );
    }

    const header = await this.deps.store.readHeader(sessionId);
    const turnId = input.turnId ?? this.deps.newId();
    const run = new AgentRun({
      sessionId,
      header,
      userInput: { turnId, text: '' },
      rootExecutionKind: 'context_compact',
      ...(input.hostedRoot ? { runId: input.hostedRoot.runId } : {}),
      store: this.deps.store,
      runStore: this.deps.runStore,
      runtimeEventStore: this.deps.runtimeEventStore,
      ...(runtimeToolBoundaryProtocol(this.deps, header)
        ? { toolBoundaryProtocol: runtimeToolBoundaryProtocol(this.deps, header) }
        : {}),
      repairRunRuntimeLedger: this.deps.repairRunRuntimeLedger,
      newId: this.deps.newId,
      now: this.deps.now,
      effectiveOrchestration: resolveEffectiveOrchestration('default', undefined),
      hooks: {
        reserveRun: async (targetSessionId, nextHeader, activeRun) => {
          const active = await this.reserveParentRun(
            targetSessionId,
            nextHeader,
            activeRun,
            execution,
          );
          this.reserveExecutionClaim(execution, active, activeRun);
          return active;
        },
        unregisterRun: (active, activeRun) => this.unregisterParentRun(active, activeRun),
        updateHeader: (targetSessionId, patch) => this.updateHeader(targetSessionId, patch),
        updateStatus: (targetSessionId, status, blockedReason, ts) =>
          this.updateStatus(targetSessionId, status, blockedReason, ts),