@omercnet/paseo-omp 0.3.0 → 0.4.0-next.119.1

package/server/provider/session.ts

@@ -11,7 +11,19 @@ import type {
   ProviderUsage,
 } from "@getpaseo/plugin/server/provider";
 import { getForgeDefinitionOrNeutral } from "@getpaseo/protocol/forge-manifest";
-import { mapOmpModels, nativeOmpModelId, OMP_MODES, ompModelId, thinkingForModel } from "./catalog";
+import type {
+  OmpOperationalFailure,
+  OmpOperationalFailureReporter,
+} from "../operational-failure-diagnostics";
+import {
+  mapOmpModels,
+  nativeOmpModelId,
+  OMP_MODES,
+  ompModelId,
+  selectOmpModels,
+  thinkingForModel,
+  validateOmpModelIdentities,
+} from "./catalog";
 import {
   normalizeOmpSessionConfig,
   type OmpRecoveryOptions,
@@ -21,6 +33,7 @@ import { OmpHostToolsBridge, type OmpMcpConnector, validateOmpHostToolConfig } f
 import { isOmpImageMimeType, isValidImagePayload, OmpImageMaterializer } from "./image";
 import type {
   OmpAvailableCommand,
+  OmpBranchResult,
   OmpCompactionResult,
   OmpExtensionUiResponse,
   OmpImage,
@@ -35,7 +48,7 @@ import type {
   OmpToolApprovalCancel,
   OmpToolApprovalRequest,
 } from "./omp-rpc";
-import { buildOmpSpawnRequest } from "./omp-rpc";
+import { buildOmpSpawnRequest, OmpRpcRequestRejectedError } from "./omp-rpc";
 import {
   BoundedStringSet,
   boundedJsonBytes,
@@ -283,6 +296,7 @@ type ActiveTurn = {
   terminalizing: boolean;
   terminalization?: Promise<void>;
   terminalOutcome?: TurnOutcome;
+  operationalTerminalStage?: "failed" | "unresolved";
   terminalWake?: VoidDeferred;
   steerReady: VoidDeferred;
   steersInFlight: number;
@@ -938,6 +952,8 @@ export class OmpProviderSession {
   private readonly pendingToolPermissions = new Map<string, PendingToolPermission>();
   private readonly inFlightToolPermissions = new Map<string, PendingToolPermission>();
   private readonly resolvedToolApprovalIds = new BoundedStringSet(MAX_TRACKED_ENTRY_IDS);
+  private unsupportedThinkingNoticePending = false;
+  private unsupportedThinkingNoticePublished = false;
 
   private constructor(
     id: string,
@@ -962,6 +978,7 @@ export class OmpProviderSession {
     private readonly transitionNativeSession: NativeSessionTransition,
     private readonly quarantineRewindCleanup: RewindCleanupQuarantine,
     private readonly retireRewindSession: RewindSessionRetirement,
+    private readonly reportOperationalFailure: OmpOperationalFailureReporter,
     scheduler: OmpTimelineScheduler = defaultOmpTimelineScheduler,
   ) {
     this.id = id;
@@ -995,6 +1012,13 @@ export class OmpProviderSession {
       : null;
     this.bindRuntime(runtime);
   }
+  private recordOperationalFailure(failure: OmpOperationalFailure): void {
+    try {
+      this.reportOperationalFailure(failure);
+    } catch {
+      // Diagnostics must never affect provider or session flow.
+    }
+  }
   get persistenceSessionId(): string | undefined {
     return this.persistSession ? this.nativeSessionId : undefined;
   }
@@ -1021,6 +1045,7 @@ export class OmpProviderSession {
     environment?: NodeJS.ProcessEnv,
     mcpConnector?: OmpMcpConnector,
     mcpInitializationTimeoutMs?: number,
+    reportOperationalFailure: OmpOperationalFailureReporter = () => {},
   ): Promise<OmpProviderSession> {
     const resumeSessionId = ompPersistenceSessionId(input);
     if (resumeSessionId && !input.config.persist) {
@@ -1056,10 +1081,9 @@ export class OmpProviderSession {
     }
     const startOptions: OmpStartOptions = {
       ...normalizedConfig,
-      // Model selection is authorized only after this runtime reports its exact catalog.
-      ...(resumeSessionId
-        ? { thinkingOption: undefined, systemPrompt: undefined, resumeSessionId }
-        : {}),
+      // Thinking is authorized only after this runtime reports its exact model catalog.
+      thinkingOption: undefined,
+      ...(resumeSessionId ? { systemPrompt: undefined, resumeSessionId } : {}),
       signal,
       environment,
     };
@@ -1068,6 +1092,7 @@ export class OmpProviderSession {
       connectMcp: mcpConnector,
       signal,
       initializationTimeoutMs: mcpInitializationTimeoutMs,
+      reportOperationalFailure,
     });
     let native: OmpRuntimeSession | undefined;
     let cleanupNativeSessionId: string | undefined;
@@ -1095,6 +1120,7 @@ export class OmpProviderSession {
           () => ({ available: false, commands: [] }),
         ),
       ]);
+      validateOmpModelIdentities(nativeModels);
       if (effectiveConfig.persist && !native.canReplayHistory) {
         throw new OmpPublicError("OMP session persistence requires negotiated RPC protocol v2");
       }
@@ -1108,12 +1134,10 @@ export class OmpProviderSession {
       if (resumeSessionId && initialState.sessionId !== resumeSessionId) {
         throw new OmpPublicError("OMP resumed a different native session");
       }
-      const models = mapOmpModels(nativeModels, new OmpPublicDataSerializer(outputRedactionValues));
-      const nativeModelsByPublicId = new Map(
-        nativeModels.map((model) => [ompModelId(model), model] as const),
-      );
       if (!resumeSessionId && input.config.model) {
-        const selected = nativeModelsByPublicId.get(input.config.model);
+        const selected = selectOmpModels(nativeModels, state.model).find(
+          (model) => ompModelId(model) === input.config.model,
+        );
         if (!selected) {
           throw new OmpPublicError("OMP model is not advertised by the configured session runtime");
         }
@@ -1122,9 +1146,29 @@ export class OmpProviderSession {
           state = await native.getState();
         }
       }
+      let currentModel = state.model
+        ? nativeModels.find(
+            (model) => model.provider === state.model?.provider && model.id === state.model.id,
+          )
+        : undefined;
+      if (state.model && !currentModel) {
+        throw new OmpPublicError("OMP runtime selected an unadvertised model");
+      }
+      if (!resumeSessionId && input.config.thinkingOption !== undefined) {
+        if (
+          !thinkingForModel(currentModel).some(
+            (option) => option.id === input.config.thinkingOption,
+          )
+        ) {
+          throw new OmpPublicError("OMP thinking level is unavailable for the selected model");
+        }
+        if (state.thinkingLevel !== input.config.thinkingOption) {
+          await native.setThinkingLevel(input.config.thinkingOption);
+        }
+      }
       const reconciledConfigRevision = bootstrapConfigRevision;
       state = await native.getState();
-      const currentModel = state.model
+      currentModel = state.model
         ? nativeModels.find(
             (model) => model.provider === state.model?.provider && model.id === state.model.id,
           )
@@ -1132,21 +1176,21 @@ export class OmpProviderSession {
       if (state.model && !currentModel) {
         throw new OmpPublicError("OMP runtime selected an unadvertised model");
       }
+      const selectedNativeModels = selectOmpModels(nativeModels, state.model);
+      const models = mapOmpModels(
+        selectedNativeModels,
+        new OmpPublicDataSerializer(outputRedactionValues),
+      );
+      const nativeModelsByPublicId = new Map(
+        nativeModels.map((model) => [ompModelId(model), model] as const),
+      );
       const thinkingOptions = thinkingForModel(currentModel);
-      const committedThinkingLevel = applicableThinkingLevel(currentModel, state.thinkingLevel);
-      if (
-        !resumeSessionId &&
-        input.config.thinkingOption !== undefined &&
-        !thinkingOptions.some((option) => option.id === input.config.thinkingOption)
-      ) {
-        throw new OmpPublicError("OMP thinking level is unavailable for the selected model");
-      }
-      if (
-        committedThinkingLevel &&
-        !thinkingOptions.some((option) => option.id === committedThinkingLevel)
-      ) {
-        throw new OmpPublicError("OMP runtime selected an unsupported thinking level");
-      }
+      const applicableLevel = applicableThinkingLevel(currentModel, state.thinkingLevel);
+      const committedThinkingLevel = thinkingOptions.some((option) => option.id === applicableLevel)
+        ? applicableLevel
+        : undefined;
+      const unsupportedThinkingLevel =
+        applicableLevel !== undefined && committedThinkingLevel === undefined;
       const configState: ProviderConfigState = {
         ...(state.model ? { model: ompModelId(state.model) } : {}),
         mode: normalizedConfig.mode ?? "full",
@@ -1207,8 +1251,10 @@ export class OmpProviderSession {
         transitionNativeSession,
         quarantineRewindCleanup,
         retireRewindSession,
+        reportOperationalFailure,
         scheduler,
       );
+      session.unsupportedThinkingNoticePending = unsupportedThinkingLevel;
 
       if (bootstrapConfigRevision !== reconciledConfigRevision) {
         session.configRefreshDirty = true;
@@ -1267,6 +1313,7 @@ export class OmpProviderSession {
         : {}),
       ...(this.config.title ? { title: this.dataFilter.text(this.config.title, 256) } : {}),
     });
+    this.publishUnsupportedThinkingNotice();
     this.emit({ type: "session.config", sessionId: this.id, config: this.configState });
     if (this.replayHistoryOnOpen) await this.replayHistory(true);
     this.publishCommands(this.commandCatalog);
@@ -1274,6 +1321,22 @@ export class OmpProviderSession {
     this.readyPublished = true;
     if (this.configRefreshDirty) this.scheduleCommittedConfigRefresh();
   }
+  private publishUnsupportedThinkingNotice(): void {
+    if (!this.unsupportedThinkingNoticePending || this.unsupportedThinkingNoticePublished) return;
+    this.unsupportedThinkingNoticePending = false;
+    this.unsupportedThinkingNoticePublished = true;
+    this.emit({
+      type: "session.notice",
+      sessionId: this.id,
+      notice: {
+        id: "omp:unsupported-thinking-level",
+        severity: "warning",
+        title: "OMP thinking level unavailable",
+        description:
+          "OMP reported a thinking level that the active model does not advertise. Paseo omitted it from the session configuration.",
+      },
+    });
+  }
 
   private usageFrom(
     state: OmpSessionState | undefined,
@@ -1592,8 +1655,24 @@ export class OmpProviderSession {
             replay.signal,
           );
           messages = transcript.messages;
+          if (transcript.imageReplayWarning) {
+            this.emit({
+              type: "timeline.item",
+              sessionId: this.id,
+              item: {
+                id: "omp:replay-image-unavailable",
+                type: "notification",
+                level: "warning",
+                message: "OMP skipped one or more unavailable images while replaying this session.",
+              },
+            });
+          }
         } catch (error) {
           if (replay.signal.aborted) throw error;
+          this.recordOperationalFailure({
+            category: "replay-recovery",
+            stage: "persisted-replay",
+          });
           this.emit({
             type: "timeline.item",
             sessionId: this.id,
@@ -1606,7 +1685,7 @@ export class OmpProviderSession {
           });
         }
       }
-      messages ??= await waitForReplay(this.runtime.getMessages(), replay.signal);
+      messages ??= await waitForReplay(this.runtime.getMessages(replay.signal), replay.signal);
       this.quarantineBranchEntries();
       for (const message of messages) {
         replay.signal.throwIfAborted();
@@ -1667,19 +1746,33 @@ export class OmpProviderSession {
         throw new OmpPublicError("OMP conversation rewind requires negotiated RPC protocol v2");
       }
       const entryId = this.projector.resolveRevertToken(input.token);
-      const [branchMessages, beforeState] = await Promise.all([
-        runtime.getBranchMessages(),
-        runtime.getState(),
-      ]);
+      const beforeState = await runtime.getState();
       this.requireCurrentRuntime(runtime, generation);
       if (this.activeTurn || beforeState.isStreaming || beforeState.isCompacting) {
         throw new OmpPublicError("Cannot rewind the OMP conversation while a turn is active");
       }
-      if (!branchMessages.some((message) => message.entryId === entryId)) {
-        throw new OmpPublicError("OMP conversation rewind token is stale");
+      const beforeAdvertisedModel = beforeState.model
+        ? this.nativeModelsByPublicId.get(ompModelId(beforeState.model))
+        : undefined;
+      if (beforeState.model && !beforeAdvertisedModel) {
+        throw new OmpPublicError("OMP runtime selected an unadvertised model");
       }
+      const restorableThinkingLevel = thinkingForModel(beforeAdvertisedModel).some(
+        (option) => option.id === beforeState.thinkingLevel,
+      )
+        ? beforeState.thinkingLevel
+        : undefined;
       branchMutationPossible = true;
-      const result = await runtime.branch(entryId);
+      let result: OmpBranchResult;
+      try {
+        result = await runtime.branch(entryId);
+      } catch (error) {
+        if (error instanceof OmpRpcRequestRejectedError) {
+          branchMutationPossible = false;
+          throw new OmpPublicError("OMP conversation rewind token is stale");
+        }
+        throw error;
+      }
       this.requireCurrentRuntime(runtime, generation);
       if (result.cancelled) {
         branchMutationPossible = false;
@@ -1711,13 +1804,10 @@ export class OmpProviderSession {
         }
         await runtime.setModel(beforeState.model.provider, beforeState.model.id);
       }
-      if (thinkingChanged) {
-        if (!beforeState.thinkingLevel) {
-          throw new OmpPublicError("OMP changed thinking level while rewinding the conversation");
-        }
-        await runtime.setThinkingLevel(beforeState.thinkingLevel);
+      if (thinkingChanged && restorableThinkingLevel) {
+        await runtime.setThinkingLevel(restorableThinkingLevel);
       }
-      if (modelChanged || thinkingChanged) {
+      if (modelChanged || (thinkingChanged && restorableThinkingLevel)) {
         state = await runtime.getState();
         this.requireCurrentRuntime(runtime, generation);
       }
@@ -1725,7 +1815,7 @@ export class OmpProviderSession {
         state.sessionId !== this.nativeSessionId ||
         state.model?.provider !== beforeState.model?.provider ||
         state.model?.id !== beforeState.model?.id ||
-        state.thinkingLevel !== beforeState.thinkingLevel
+        (restorableThinkingLevel !== undefined && state.thinkingLevel !== restorableThinkingLevel)
       ) {
         throw new OmpPublicError("OMP did not preserve session configuration while rewinding");
       }
@@ -1737,6 +1827,7 @@ export class OmpProviderSession {
       this.publishCommittedConfig(state, runtime, generation);
       this.emit({ type: "request.completed", requestId: input.requestId });
     } catch (error) {
+      this.recordOperationalFailure({ category: "replay-recovery", stage: "rewind" });
       const failure = branchMutationPossible
         ? { message: "OMP conversation rewind left native state indeterminate" }
         : providerError(error, "OMP conversation rewind failed");
@@ -2325,7 +2416,10 @@ export class OmpProviderSession {
       const targetModel = targetModelId
         ? this.nativeModelsByPublicId.get(targetModelId)
         : undefined;
-      if (input.changes.model !== undefined && !targetModel) {
+      const targetModelPublished = this.configState.models.some(
+        (model) => model.id === targetModelId,
+      );
+      if (input.changes.model !== undefined && (!targetModel || !targetModelPublished)) {
         throw new OmpPublicError("OMP model selection is unavailable");
       }
       if (
@@ -2572,13 +2666,18 @@ export class OmpProviderSession {
       throw new OmpCatalogEscape("OMP runtime selected an unadvertised model");
     }
     const thinkingOptions = thinkingForModel(advertisedModel);
-    const committedThinkingLevel = applicableThinkingLevel(advertisedModel, state.thinkingLevel);
-    if (
-      committedThinkingLevel &&
-      !thinkingOptions.some((option) => option.id === committedThinkingLevel)
-    ) {
-      throw new OmpCatalogEscape("OMP runtime selected an unsupported thinking level");
+    const applicableLevel = applicableThinkingLevel(advertisedModel, state.thinkingLevel);
+    const committedThinkingLevel = thinkingOptions.some((option) => option.id === applicableLevel)
+      ? applicableLevel
+      : undefined;
+    if (applicableLevel !== undefined && committedThinkingLevel === undefined) {
+      this.unsupportedThinkingNoticePending = true;
+      this.publishUnsupportedThinkingNotice();
     }
+    const models = mapOmpModels(
+      selectOmpModels([...this.nativeModelsByPublicId.values()], state.model),
+      this.dataFilter,
+    );
     this.configRefreshAttempts = 0;
     this.cancelConfigRefreshRetry();
     const nextConfig: ProviderConfigState = {
@@ -2587,12 +2686,15 @@ export class OmpProviderSession {
       ...(committedThinkingLevel
         ? { thinkingOption: committedThinkingLevel }
         : { thinkingOption: undefined }),
+      models,
       thinkingOptions,
     };
     const changed =
       force ||
       nextConfig.model !== this.configState.model ||
       nextConfig.thinkingOption !== this.configState.thinkingOption ||
+      nextConfig.models.some((model, index) => model.id !== this.configState.models[index]?.id) ||
+      this.configState.models.length !== nextConfig.models.length ||
       nextConfig.thinkingOptions.length !== this.configState.thinkingOptions.length ||
       nextConfig.thinkingOptions.some(
         (option, index) =>
@@ -2843,7 +2945,13 @@ export class OmpProviderSession {
 
   private async recoverRuntime(): Promise<void> {
     if (!this.runtimeDead) return;
-    this.recoveryPromise ??= this.startRecovery();
+    this.recoveryPromise ??= this.startRecovery().catch((error) => {
+      this.recordOperationalFailure({
+        category: "replay-recovery",
+        stage: "runtime-recovery",
+      });
+      throw error;
+    });
     try {
       await this.recoveryPromise;
     } finally {
@@ -2913,13 +3021,6 @@ export class OmpProviderSession {
       if (state.model && !advertisedModel) {
         throw new Error("OMP recovered with an unadvertised model");
       }
-      const recoveredThinkingLevel = applicableThinkingLevel(advertisedModel, state.thinkingLevel);
-      if (
-        recoveredThinkingLevel &&
-        !thinkingForModel(advertisedModel).some((option) => option.id === recoveredThinkingLevel)
-      ) {
-        throw new Error("OMP recovered with an unsupported thinking level");
-      }
       if (this.closed) throw new Error("OMP session closed while runtime recovery was pending");
       if (!this.hostTools.isBoundTo(recovered)) {
         throw new Error("OMP host tool bridge detached during recovery");
@@ -3073,6 +3174,10 @@ export class OmpProviderSession {
       try {
         this.subsessions?.handle(event);
       } catch {
+        this.recordOperationalFailure({
+          category: "tool-projector",
+          stage: "subsession-projector",
+        });
         this.handleRuntimeFailure("OMP subagent event processing failed");
       }
       return;
@@ -3129,6 +3234,17 @@ export class OmpProviderSession {
       this.handleRuntimeFailure();
       return;
     }
+    if (
+      event.type === "config_warnings_changed" ||
+      event.type === "advisor_cost_changed" ||
+      event.type === "ttsr_triggered"
+    ) {
+      return;
+    }
+    if (event.type === "irc_message") {
+      this.projector.projectPassive(event);
+      return;
+    }
     if (
       event.type === "notice" ||
       event.type === "todo_reminder" ||
@@ -3307,6 +3423,10 @@ export class OmpProviderSession {
       try {
         this.subsessions?.observeSessionEvent(this.id, event);
       } catch {
+        this.recordOperationalFailure({
+          category: "tool-projector",
+          stage: "subsession-projector",
+        });
         this.handleRuntimeFailure("OMP subagent dispatch tracking failed");
         return;
       }
@@ -3363,7 +3483,15 @@ export class OmpProviderSession {
       }
     }
     if (isNativeTurnActivity(event)) this.markAgentEvidence(turn);
-    this.projector.project(event, turn.turnId);
+    try {
+      this.projector.project(event, turn.turnId);
+    } catch (error) {
+      this.recordOperationalFailure({
+        category: "tool-projector",
+        stage: "timeline-projector",
+      });
+      throw error;
+    }
     if (event.type === "tool_execution_end") this.resumeDeferredAgentEnd();
   }
 
@@ -4432,11 +4560,13 @@ export class OmpProviderSession {
     const state = await this.boundedTerminalState(turn, FINAL_USAGE_WAIT_MS);
     if (turn.terminal || this.activeTurn !== turn || turn.deferredAgentEnd !== candidate) return;
     if (!state) {
+      turn.operationalTerminalStage = "unresolved";
       this.handleRuntimeFailure("OMP agent_end state could not be confirmed");
       return;
     }
     turn.deferredAgentEnd = undefined;
     if (state.isStreaming || state.isCompacting) return;
+    turn.operationalTerminalStage = "unresolved";
     await this.finishTurn(turn, "failed", {
       message: "OMP unkeyed agent_end could not be correlated to the current prompt",
     });
@@ -4517,6 +4647,7 @@ export class OmpProviderSession {
       ) {
         void this.completeAgentEnd(turn, candidate.event);
       } else {
+        turn.operationalTerminalStage = "unresolved";
         this.handleRuntimeFailure("OMP agent_end state could not be confirmed");
       }
     }, AGENT_END_SETTLE_MS);
@@ -4541,8 +4672,13 @@ export class OmpProviderSession {
     turn.terminalizing = false;
     turn.deferredAgentEnd = candidate;
     void this.subsessions.reconcile(this.runtime).catch(() => {
+      this.recordOperationalFailure({
+        category: "tool-projector",
+        stage: "subsession-projector",
+      });
       if (!turn.terminal && this.activeTurn === turn) {
-        this.handleRuntimeFailure("OMP subagent reconciliation failed");
+        this.subsessions?.terminalize("failed");
+        this.resumeDeferredAgentEnd();
       }
     });
     return true;
@@ -4625,6 +4761,7 @@ export class OmpProviderSession {
       return;
     }
     if (turn.userEchoObserved) {
+      turn.operationalTerminalStage = "unresolved";
       this.handleRuntimeFailure("OMP agent_end state could not be confirmed");
       return;
     }
@@ -4684,6 +4821,7 @@ export class OmpProviderSession {
       await this.finishTurn(turn, "completed");
       return;
     }
+    turn.operationalTerminalStage = outcome === "failed" ? "failed" : "unresolved";
     const error =
       outcome === "failed" ? "OMP assistant turn failed" : unknownTerminalOutcomeError(event, turn);
     this.subsessions?.terminalize("failed");
@@ -4826,6 +4964,12 @@ export class OmpProviderSession {
           usageSampled: true,
         };
       }
+      if (outcome.state === "failed") {
+        this.recordOperationalFailure({
+          category: "terminal-outcome",
+          stage: turn.operationalTerminalStage ?? "failed",
+        });
+      }
       this.imageMaterializer.clear();
       turn.terminal = true;
       if (this.usageSample?.turn === turn) this.usageSample = null;
@@ -4839,7 +4983,15 @@ export class OmpProviderSession {
       }
       this.publishPendingUsers(turn);
       this.resolveTurnPermissions(turn.turnId);
-      this.projector.finishTurn(turn.turnId, preserveCompactions);
+      try {
+        this.projector.finishTurn(turn.turnId, preserveCompactions);
+      } catch (error) {
+        this.recordOperationalFailure({
+          category: "tool-projector",
+          stage: "timeline-projector",
+        });
+        throw error;
+      }
       this.unclaimedBranchEntries.length = 0;
       this.emit({
         type: "session.turn",
@@ -4897,6 +5049,7 @@ export class OmpProviderSession {
     this.publishPromptResult(turn, { type: "failed", error: { message } });
     if (turn.started) void this.finishTurn(turn, "failed", { message }, true, true);
     else {
+      this.recordOperationalFailure({ category: "terminal-outcome", stage: "failed" });
       turn.steerReady.resolve();
       turn.terminal = true;
       this.projector.finishTurn(turn.turnId);