@omercnet/paseo-omp 5.1.1 → 5.2.0-next.362.1

package/server/provider/session.ts

@@ -6,10 +6,12 @@ import type {
   ProviderInput,
   ProviderSessionConfig,
 } from "@getpaseo/plugin/server/provider";
+import { isLiveOmpSubagentStatus } from "../../shared/subagents";
 import type {
   OmpOperationalFailure,
   OmpOperationalFailureReporter,
 } from "../operational-failure-diagnostics";
+import { type OmpSubagentControls, OmpSubagentNotRunningError } from "../subagents";
 import {
   mapOmpModels,
   nativeOmpModelId,
@@ -73,15 +75,18 @@ import {
   assistantTerminalOutcome,
   classifyTerminalCandidate,
   createActiveTurn,
+  createNativeRunTurn,
+  type HeldAgentEnd,
   historyTerminalOutcome,
   nativeEntryId,
   type PendingUser,
   type TerminalCandidate,
+  takeRunEvidence,
   terminalOutcome,
   unknownTerminalOutcomeError,
 } from "./session-terminal";
 import { OmpSessionUsage } from "./session-usage";
-import { OmpSubsessionProjector } from "./subsessions";
+import { OmpSubsessionProjector, ompSubagentHandle } from "./subsessions";
 import {
   defaultOmpTimelineScheduler,
   OmpTimelineProjector,
@@ -223,8 +228,9 @@ export async function authorizeNativeSession(
   sessionId: string,
   cwd: string,
   sessionDir?: string,
+  signal?: AbortSignal,
 ): Promise<OmpSessionDescriptor> {
-  const matches = await runtime.listSessions({ sessionId, cwd, limit: 2, sessionDir });
+  const matches = await runtime.listSessions({ sessionId, cwd, limit: 2, sessionDir, signal });
   const descriptor = matches[0];
   if (matches.length !== 1 || descriptor?.id !== sessionId) {
     throw new OmpPublicError("OMP session could not be resolved in this workspace");
@@ -295,7 +301,7 @@ async function settleSessionCleanup(promises: readonly Promise<void>[]): Promise
     throw new AggregateError(failures, "OMP session initialization cleanup failed");
   }
 }
-export class OmpProviderSession implements OmpOpenedSession {
+export class OmpProviderSession implements OmpOpenedSession, OmpSubagentControls {
   readonly id: string;
   readonly cwd: string;
 
@@ -330,6 +336,8 @@ export class OmpProviderSession implements OmpOpenedSession {
   private configRevision = 0;
   private recoveryUsesNativeConfig = false;
   private activeAbort: PendingAbort | null = null;
+  /** Frames of a run that started while the previous terminal was being confirmed or published. */
+  private runStartBacklog: OmpRpcEvent[] | null = null;
   private readonly usage: OmpSessionUsage;
   private readonly compaction: OmpSessionCompaction;
   private revertInFlight = false;
@@ -460,6 +468,36 @@ export class OmpProviderSession implements OmpOpenedSession {
     this.projector.setBrowserAuthorizationIssuer(issue);
   }
 
+  async cancelSubagent(handle: string): Promise<boolean> {
+    const target = await this.liveSubagent(handle);
+    return target ? await target.runtime.cancelSubagent(target.nativeId) : false;
+  }
+
+  async steerSubagent(handle: string, message: string): Promise<void> {
+    const target = await this.liveSubagent(handle);
+    if (!target) throw new OmpSubagentNotRunningError();
+    await target.runtime.steerSubagent(target.nativeId, message);
+  }
+
+  /**
+   * The native ID and runtime of a subagent this session's current runtime lists as running, or
+   * `null`. OMP repeats the check; this scopes the request to this session and answers exactly.
+   */
+  private async liveSubagent(
+    handle: string,
+  ): Promise<{ runtime: OmpRuntimeSession; nativeId: string } | null> {
+    if (this.closed || this.runtimeDead) return null;
+    const runtime = this.runtime;
+    const snapshots = await runtime.getSubagents();
+    if (runtime !== this.runtime || this.closed || this.runtimeDead) return null;
+    const live = snapshots.find(
+      (snapshot) =>
+        ompSubagentHandle(this.id, snapshot.id) === handle &&
+        isLiveOmpSubagentStatus(snapshot.status),
+    );
+    return live ? { runtime, nativeId: live.id } : null;
+  }
+
   private readonly imageMaterializer = new OmpImageMaterializer();
   static async open(
     input: SessionOpenInput,
@@ -505,6 +543,7 @@ export class OmpProviderSession implements OmpOpenedSession {
           resumeSessionId,
           input.config.cwd,
           normalizedConfig.sessionDir,
+          signal,
         )
       : undefined;
     validateOmpHostToolConfig(effectiveConfig);
@@ -1458,33 +1497,46 @@ export class OmpProviderSession implements OmpOpenedSession {
     } catch (error) {
       if (this.closed || this.runtimeDead || turn.generation !== this.generation) return;
       turn.manualCompactionPending = false;
+      // OMP 18.13.3+ reports the outcome in manual_compaction_end before rejecting `compact`.
+      const outcome = turn.manualCompactionOutcome;
+      if (outcome === "skipped") {
+        await this.finishTurn(turn, turn.interrupted ? "canceled" : "completed");
+        return;
+      }
       const raw = providerError(error, "OMP compaction failed");
       const failure = { message: this.dataFilter.text(raw.message, 4_096) };
-      const state = turn.interrupted ? "canceled" : "failed";
+      const state = turn.interrupted || outcome === "canceled" ? "canceled" : "failed";
       this.compaction.finish(state, { message: failure.message });
       await this.finishTurn(turn, state, state === "failed" ? failure : undefined, true, true);
     }
   }
 
   async canStopRuntime(): Promise<boolean> {
-    const hasLocalWork =
+    if (this.hasLocalRuntimeWork()) return false;
+    const state = await this.runtime.getState();
+    // OMP can start a run of its own while the state lookup is pending.
+    if (this.hasLocalRuntimeWork()) return false;
+    // OMP builds that predate these fields report neither, which keeps the runtime alive.
+    return (
+      state.isSettled === true &&
+      state.hasPendingAsyncWork === false &&
+      !state.isStreaming &&
+      !state.isCompacting
+    );
+  }
+
+  private hasLocalRuntimeWork(): boolean {
+    return (
       this.closed ||
       this.runtimeDead !== null ||
       this.recoveryPromise !== null ||
       this.activeTurn !== null ||
+      this.runStartBacklog !== null ||
       this.activeAbort !== null ||
       this.revertInFlight ||
       this.configMutationInFlight ||
       this.permissions.hasPending() ||
-      Boolean(this.subsessions?.hasActiveChildren());
-    if (hasLocalWork) return false;
-    const state = await this.runtime.getState();
-    // OMP builds that predate these fields report neither, which keeps the runtime alive.
-    return (
-      state.isSettled === true &&
-      state.hasPendingAsyncWork === false &&
-      !state.isStreaming &&
-      !state.isCompacting
+      Boolean(this.subsessions?.hasActiveChildren())
     );
   }
 
@@ -2259,6 +2311,17 @@ export class OmpProviderSession implements OmpOpenedSession {
 
   private handleRuntimeEvent(event: OmpRpcEvent): void {
     if (this.closed) return;
+    if (this.runStartBacklog) {
+      this.bufferEvent(this.runStartBacklog, event);
+      return;
+    }
+    // A run that starts while the previous terminal is being confirmed or published waits for it,
+    // so neither the old turn's outcome nor the new run's frames are lost.
+    const pendingTerminal = this.activeTurn?.terminalization ?? this.activeTurn?.agentEndCheck;
+    if (event.type === "agent_start" && pendingTerminal) {
+      this.deferRunStart(event, pendingTerminal);
+      return;
+    }
     if (
       event.type === "subagent_lifecycle" ||
       event.type === "subagent_progress" ||
@@ -2336,7 +2399,8 @@ export class OmpProviderSession implements OmpOpenedSession {
       event.type === "ttsr_triggered" ||
       event.type === "cache_warming_start" ||
       event.type === "cache_warming_end" ||
-      event.type === "queue_update"
+      event.type === "queue_update" ||
+      event.type === "session_info_update"
     ) {
       return;
     }
@@ -2353,7 +2417,8 @@ export class OmpProviderSession implements OmpOpenedSession {
       event.type === "auto_retry_end" ||
       event.type === "compaction_start" ||
       event.type === "compaction_end" ||
-      event.type === "advisor_yielded"
+      event.type === "advisor_yielded" ||
+      event.type === "extension_error"
     ) {
       this.projector.projectPassive(event);
       return;
@@ -2367,13 +2432,23 @@ export class OmpProviderSession implements OmpOpenedSession {
       this.scheduleCommittedConfigRefresh();
       return;
     }
-    if (event.type === "model_changed" || event.type === "thinking_level_changed") {
+    if (
+      event.type === "model_changed" ||
+      event.type === "thinking_level_changed" ||
+      event.type === "config_update"
+    ) {
       this.scheduleCommittedConfigRefresh();
       return;
     }
-    const turn = this.activeTurn;
+    const turn =
+      this.activeTurn ?? (event.type === "agent_start" ? this.openNativeRunTurn() : null);
     if (!turn) {
-      if (event.type === "auto_compaction_start" || event.type === "auto_compaction_end") {
+      if (
+        event.type === "auto_compaction_start" ||
+        event.type === "auto_compaction_end" ||
+        event.type === "manual_compaction_start" ||
+        event.type === "manual_compaction_end"
+      ) {
         this.projector.projectPassive(event);
       }
       return;
@@ -2386,27 +2461,69 @@ export class OmpProviderSession implements OmpOpenedSession {
       return;
     }
     if (turn.starting) {
-      if (
-        turn.bufferedEvents.length >= MAX_BUFFERED_TURN_EVENTS ||
-        retainedBytes(turn.bufferedEvents, MAX_BUFFERED_TURN_BYTES) +
-          boundedJsonBytes(
-            event,
-            MAX_BUFFERED_TURN_BYTES,
-            MAX_BUFFERED_VALUE_ITEMS,
-            MAX_BUFFERED_TURN_BYTES,
-            MAX_BUFFERED_VALUE_NODES,
-          ) >
-          MAX_BUFFERED_TURN_BYTES
-      ) {
-        this.handleRuntimeFailure();
-        return;
-      }
-      turn.bufferedEvents.push(event);
+      this.bufferEvent(turn.bufferedEvents, event);
       return;
     }
     this.handleTurnEvent(turn, event);
   }
 
+  private bufferEvent(buffer: OmpRpcEvent[], event: OmpRpcEvent): void {
+    if (
+      buffer.length >= MAX_BUFFERED_TURN_EVENTS ||
+      retainedBytes(buffer, MAX_BUFFERED_TURN_BYTES) +
+        boundedJsonBytes(
+          event,
+          MAX_BUFFERED_TURN_BYTES,
+          MAX_BUFFERED_VALUE_ITEMS,
+          MAX_BUFFERED_TURN_BYTES,
+          MAX_BUFFERED_VALUE_NODES,
+        ) >
+        MAX_BUFFERED_TURN_BYTES
+    ) {
+      this.handleRuntimeFailure();
+      return;
+    }
+    buffer.push(event);
+  }
+
+  private deferRunStart(event: OmpRpcEvent, pendingTerminal: Promise<void>): void {
+    const backlog = [event];
+    this.runStartBacklog = backlog;
+    const replay = () => {
+      if (this.runStartBacklog !== backlog) return;
+      this.runStartBacklog = null;
+      for (const buffered of backlog) this.handleRuntimeEvent(buffered);
+    };
+    void pendingTerminal.then(replay, replay);
+  }
+
+  private scheduleHeldTurnCheck(turn: ActiveTurn, held: HeldAgentEnd): void {
+    this.scheduler.set(() => this.checkHeldTurn(turn, held), USAGE_POLL_MS);
+  }
+
+  /** Released OMP does not always write `session_settled` once a held run's async work is gone. */
+  private async checkHeldTurn(turn: ActiveTurn, held: HeldAgentEnd): Promise<void> {
+    if (turn.heldAgentEnd !== held || this.activeTurn !== turn) return;
+    const state = await this.usage.boundedSnapshot(turn, FINAL_USAGE_WAIT_MS);
+    if (turn.heldAgentEnd !== held || this.activeTurn !== turn) return;
+    const settled =
+      state?.isSettled === true &&
+      state.hasPendingAsyncWork === false &&
+      !state.isStreaming &&
+      !state.isCompacting;
+    if (settled) this.handleTurnEvent(turn, { type: "session_settled" });
+    else this.scheduleHeldTurnCheck(turn, held);
+  }
+
+  private openNativeRunTurn(): ActiveTurn {
+    const turn = createNativeRunTurn(this.generation);
+    this.activeTurn = turn;
+    turn.acknowledged = true;
+    this.startTurn(turn);
+    this.projector.acceptLiveTurn(turn.turnId);
+    return turn;
+  }
+
   private handleTurnEvent(
     turn: ActiveTurn,
     event: OmpRpcEvent,
@@ -2476,10 +2593,27 @@ export class OmpProviderSession implements OmpOpenedSession {
       this.compaction.start(turn, "auto", event.action);
       return;
     }
-    if (event.type === "auto_compaction_end") {
-      if (this.compaction.handleAutoEnd(turn, event)) {
-        this.usage.schedulePoll(turn, USAGE_REFRESH_MS);
-      }
+    if (event.type === "manual_compaction_start") {
+      turn.nativeActivity = true;
+      this.cancelLocalOnlyCompletion(turn);
+      // A no-op when this turn's own `compact` call already opened the operation.
+      this.compaction.start(turn, "manual");
+      return;
+    }
+    if (event.type === "auto_compaction_end" || event.type === "manual_compaction_end") {
+      const outcome = this.compaction.handleEnd(turn, event);
+      if (outcome && turn.manualCompaction) turn.manualCompactionOutcome = outcome;
+      if (outcome) this.usage.schedulePoll(turn, USAGE_REFRESH_MS);
+      return;
+    }
+    if (event.type === "session_settled") {
+      // OMP is quiet, so the held end closes this stretch; a later run opens its own turn.
+      const held = turn.heldAgentEnd;
+      if (!held) return;
+      turn.heldAgentEnd = undefined;
+      Object.assign(turn, held.evidence);
+      // Ownership is judged as of the held end's arrival, never from evidence that came later.
+      this.acceptTerminal(turn, { ...held.event, isTerminal: true }, held.arrivalSequence);
       return;
     }
     if (event.type === "agent_end" && turn.manualCompactionPending) return;
@@ -2502,35 +2636,30 @@ export class OmpProviderSession implements OmpOpenedSession {
         return;
       }
     }
+    if (event.type === "agent_start") {
+      turn.heldAgentEnd = undefined;
+      // Evidence is per run; records OMP writes between runs belong to neither.
+      takeRunEvidence(turn);
+      if (turn.agentEndPending && !turn.interrupted) {
+        // A terminal waiting to retry its idle check is stale once another run starts.
+        this.resetAgentEndProbe(turn);
+        turn.deferredAgentEnd = undefined;
+        this.usage.poll(turn);
+      }
+    }
     if (event.type === "agent_end") {
       if (event.isTerminal === false) {
-        turn.completedMessageCount = 0;
-        turn.streamedMessageEntryIds.length = 0;
-        turn.streamedMessageIdentityComplete = true;
-        turn.lastCompletedAssistantOutcome = undefined;
-        turn.lastCompletedAssistantEntryId = undefined;
-        return;
-      }
-      const candidate: TerminalCandidate = turn.interrupted
-        ? { event, confidence: "interrupted", arrivalSequence: turn.activitySequence }
-        : classifyTerminalCandidate(turn, event);
-      if (candidate.confidence === "ambiguous") {
-        this.deferAmbiguousTerminal(turn, candidate);
-        return;
-      }
-      turn.nativeActivity = true;
-      this.cancelLocalOnlyCompletion(turn);
-      if (
-        (!turn.interrupted &&
-          candidate.confidence !== "keyed" &&
-          this.hasTerminalConflict(turn, false)) ||
-        turn.steersInFlight > 0 ||
-        turn.terminalizing
-      ) {
-        turn.deferredAgentEnd = candidate;
+        const held = {
+          event,
+          arrivalSequence: turn.activitySequence,
+          evidence: takeRunEvidence(turn),
+        };
+        turn.heldAgentEnd = held;
+        this.scheduleHeldTurnCheck(turn, held);
         return;
       }
-      this.beginTerminalization(turn, candidate);
+      turn.heldAgentEnd = undefined;
+      this.acceptTerminal(turn, event, turn.activitySequence);
       return;
     }
     if (isNativeTurnActivity(event)) {
@@ -2563,9 +2692,39 @@ export class OmpProviderSession implements OmpOpenedSession {
       });
       throw error;
     }
+    if (event.type === "tool_execution_start" && event.toolName === "task") {
+      this.subsessions?.anchorRootTask(event.toolCallId);
+    }
     if (event.type === "tool_execution_end") this.resumeDeferredAgentEnd();
   }
 
+  private acceptTerminal(
+    turn: ActiveTurn,
+    event: Extract<OmpRpcEvent, { type: "agent_end" }>,
+    arrivalSequence: number,
+  ): void {
+    const candidate: TerminalCandidate = turn.interrupted
+      ? { event, confidence: "interrupted", arrivalSequence }
+      : classifyTerminalCandidate(turn, event, arrivalSequence);
+    if (candidate.confidence === "ambiguous") {
+      this.deferAmbiguousTerminal(turn, candidate);
+      return;
+    }
+    turn.nativeActivity = true;
+    this.cancelLocalOnlyCompletion(turn);
+    if (
+      (!turn.interrupted &&
+        candidate.confidence !== "keyed" &&
+        this.hasTerminalConflict(turn, false)) ||
+      turn.steersInFlight > 0 ||
+      turn.terminalizing
+    ) {
+      turn.deferredAgentEnd = candidate;
+      return;
+    }
+    this.beginTerminalization(turn, candidate);
+  }
+
   private projectUserEcho(turn: ActiveTurn, message: OmpMessage): void {
     turn.userEchoObserved = true;
     const entryId = nativeEntryId(message);
@@ -3033,6 +3192,7 @@ export class OmpProviderSession implements OmpOpenedSession {
       if (!turn.agentEndPending || turn.terminal || this.activeTurn !== turn) return;
       if (
         candidate.confidence === "keyed" ||
+        candidate.confidence === "native-run" ||
         (candidate.confidence === "initial-turn" && !turn.userEchoObserved)
       ) {
         void this.completeAgentEnd(turn, candidate.event);
@@ -3146,14 +3306,16 @@ export class OmpProviderSession implements OmpOpenedSession {
       return;
     }
     if (state) {
-      if (state.isStreaming || state.isCompacting) {
+      // A run start buffered behind this check proves this end was the last one before it, so a
+      // streaming state belongs to that new run, not to this turn.
+      if ((state.isStreaming || state.isCompacting) && !this.runStartBacklog) {
         this.ignoreActiveTerminalCandidate(turn, candidate);
         return;
       }
       await this.completeAgentEnd(turn, candidate.event, true);
       return;
     }
-    if (turn.userEchoObserved) {
+    if (turn.userEchoObserved && candidate.confidence !== "native-run") {
       await this.cancelIndeterminateTerminal(
         turn,
         "OMP agent_end state could not be confirmed",
@@ -3389,6 +3551,7 @@ export class OmpProviderSession implements OmpOpenedSession {
         throw error;
       }
       this.unclaimedBranchEntries.length = 0;
+      turn.terminalEmitAttempted = true;
       this.emit({
         type: "session.turn",
         sessionId: this.id,
@@ -3398,17 +3561,42 @@ export class OmpProviderSession implements OmpOpenedSession {
       });
       this.runtimeTurnCompleted = true;
       if (this.activeTurn === turn) this.activeTurn = null;
-    })();
+    })().catch(() => this.failTerminalization(turn));
     turn.terminalization = terminalization;
     return terminalization;
   }
 
+  /** A turn whose terminal state could not be published must not keep owning the session. */
+  private failTerminalization(turn: ActiveTurn): void {
+    const message = "OMP turn could not be finalized";
+    turn.terminal = true;
+    if (this.activeTurn === turn) this.activeTurn = null;
+    this.recordOperationalFailure({ category: "terminal-outcome", stage: "failed" });
+    // Once the terminal emit was attempted, earlier listeners may already hold it; a second,
+    // conflicting terminal would be worse than failing the runtime alone.
+    if (!turn.terminalEmitAttempted) {
+      try {
+        this.emit({
+          type: "session.turn",
+          sessionId: this.id,
+          turnId: turn.turnId,
+          state: "failed",
+          error: { message },
+        });
+      } catch {
+        // The listener that failed may fail again; the runtime failure below still applies.
+      }
+    }
+    this.handleRuntimeFailure(message);
+  }
+
   private invalidateRuntime(
     message: string,
     compactionState: "failed" | "canceled" = "failed",
   ): void {
     this.imageMaterializer.clear();
     if (this.closed || this.runtimeDead) return;
+    this.runStartBacklog = null;
     this.compaction.resetDiscardedEnds();
     this.permissions.resolveAllPermissions();
     this.recoveryUsesNativeConfig ||=