@omercnet/paseo-omp 1.3.1 → 1.3.2-next.231.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@omercnet/paseo-omp",
-  "version": "1.3.1",
+  "version": "1.3.2-next.231.1",
   "type": "module",
   "description": "Paseo integration for OMP, including its direct provider and workspace tooling.",
   "license": "MIT",
@@ -38,10 +38,11 @@
     "server",
     "shared",
     "paseo-plugin.json",
-    "OVERVIEW.md"
+    "OVERVIEW.md",
+    "npm-shrinkwrap.json"
   ],
   "scripts": {
-    "check": "biome check .",
+    "check": "biome check . && node ../scripts/shrinkwrap.mjs --check .",
     "check:write": "biome check --write .",
     "test": "vitest run",
     "test:coverage": "PASEO_OMP_COVERAGE=1 vitest run --coverage",
@@ -52,16 +53,16 @@
     "typecheck": "tsc --noEmit -p tsconfig.client.json && tsc --noEmit -p tsconfig.server.json && tsc --noEmit -p tsconfig.tests.json"
   },
   "dependencies": {
-    "@getpaseo/protocol": "0.11.0-beta.5",
+    "@getpaseo/protocol": "0.11.1",
     "@modelcontextprotocol/sdk": "1.30.0",
     "yaml": "^2.9.0"
   },
   "devDependencies": {
     "@biomejs/biome": "^2.5.10",
-    "@getpaseo/cli": "0.11.0-beta.5",
-    "@getpaseo/client": "0.11.0-beta.5",
-    "@getpaseo/plugin": "0.11.0-beta.5",
-    "@getpaseo/server": "0.11.0-beta.5",
+    "@getpaseo/cli": "0.11.1",
+    "@getpaseo/client": "0.11.1",
+    "@getpaseo/plugin": "0.11.1",
+    "@getpaseo/server": "0.11.1",
     "@oh-my-pi/pi-agent-core": "18.2.0",
     "@oh-my-pi/pi-coding-agent": "18.2.0",
     "@tanstack/react-query": "^5.102.3",
@@ -69,9 +70,9 @@
     "@types/react": "^19.2.18",
     "@vitest/coverage-v8": "^5.0.0",
     "esbuild": "0.28.2",
+    "pino": "10.3.1",
     "react": "19.1.0",
     "react-native": "0.81.5",
-    "pino": "10.3.1",
     "tsx": "^4.20.6",
     "typescript": "^7.0.2",
     "vitest": "^5.0.0",

package/scripts/prepare-dependencies.mjs

@@ -42,7 +42,7 @@ export function prepareDependencies(root = projectRoot, execute = execFileSync)
   stageManifest(root, catalog, () => {
     execute(
       process.platform === "win32" ? "npm.cmd" : "npm",
-      ["install", "--omit=dev", "--ignore-scripts", "--no-package-lock", "--workspaces=false"],
+      ["ci", "--omit=dev", "--ignore-scripts", "--workspaces=false"],
       {
         cwd: root,
         stdio: "inherit",

package/server/package-version.ts

@@ -1,2 +1,2 @@
 /** Release Please keeps this bundle-safe constant aligned with package.json. */
-export const PASEO_OMP_PACKAGE_VERSION = "1.3.1"; // x-release-please-version
+export const PASEO_OMP_PACKAGE_VERSION = "1.3.2-next.231.1"; // x-release-please-version

package/server/provider/config-normalization.ts

@@ -12,6 +12,7 @@ type ProviderCatalogOptionsCompat = {
 import { MAX_INHERITED_ENVIRONMENT_NAMES } from "../../shared/provider-launch-settings";
 import { parseOmpProviderOptions } from "./provider-options";
 import { OmpPublicError } from "./security";
+import { withoutOmpSessionPurpose } from "./session-purpose";
 import { OmpModeSchema } from "./settings";
 
 const OMP_BUILTIN_TOOL_NAMES = [
@@ -84,7 +85,7 @@ export function normalizeOmpCatalogOptions(
     mode: "full",
     noSession: true,
     ...(providerOptions.command ? { command: providerOptions.command } : {}),
-    ...(providerOptions.env ? { env: providerOptions.env } : {}),
+    ...(providerOptions.env ? { env: withoutOmpSessionPurpose(providerOptions.env) } : {}),
     ...(inheritEnv ? { inheritEnv } : {}),
     outputRedaction: providerOptions.outputRedaction,
     ...(params.sessionDir ? { sessionDir: params.sessionDir } : {}),
@@ -136,7 +137,7 @@ export function normalizeOmpSessionConfig(
     .deniedTools;
   const tools = allowedOmpTools(deniedTools);
   const params = options.params ?? {};
-  const env = { ...options.env, ...config.env };
+  const env = withoutOmpSessionPurpose({ ...options.env, ...config.env });
   const inheritEnv = mergeOmpInheritedEnvironmentNames(hostInheritEnv, options.inheritEnv);
   return {
     cwd: config.cwd,

package/server/provider/connection.ts

@@ -32,7 +32,9 @@ import {
   OmpPublicError,
   utf8Bytes,
 } from "./security";
-import { OmpProviderSession, ompPersistenceSessionId } from "./session";
+import { type OmpOpenedSession, OmpProviderSession, ompPersistenceSessionId } from "./session";
+import { OmpHistorySession } from "./session-history";
+import { isOmpHistoryOnlyOpen } from "./session-purpose";
 
 type ProviderConfigurationCompat = {
   providerOptions?: Readonly<Record<string, unknown>>;
@@ -747,7 +749,7 @@ export function createOmpConnection(
     string,
     {
       token: symbol;
-      session: OmpProviderSession;
+      session: OmpOpenedSession;
       nativeSessionId?: string;
       removeBrowserAuthorization?: () => void;
     }
@@ -909,10 +911,15 @@ export function createOmpConnection(
         opening.set(input.sessionId, { token, controller, settled: openingSettled.promise });
         let nativeSessionId: string | undefined;
         let persistentOpening = false;
-        let session: OmpProviderSession | undefined;
+        let historyOnly = false;
+        let session: OmpOpenedSession | undefined;
         try {
+          historyOnly = isOmpHistoryOnlyOpen(input);
           nativeSessionId = ompPersistenceSessionId(input);
-          if (nativeSessionId) {
+          if (historyOnly) {
+            // History reads one authorized transcript and runs nothing, so it takes no native
+            // session reservation and neither blocks nor is blocked by an interactive session.
+          } else if (nativeSessionId) {
             await nativeReservations.reserve(nativeSessionId, token, controller.signal);
           } else if (input.config.persist) {
             await nativeReservations.beginPersistentOpen(token, controller.signal);
@@ -955,23 +962,35 @@ export function createOmpConnection(
           const retireRewindSession = () => {
             deleteSession(input.sessionId, token);
           };
-          session = await OmpProviderSession.open(
-            input,
-            runtime,
-            safeCapabilities,
-            sessionEmit,
-            transitionNativeSession,
-            quarantineRewindCleanup,
-            retireRewindSession,
-            scheduler,
-            replayTimeoutMs,
-            controller.signal,
-            environment,
-            mcpConnector,
-            mcpInitializationTimeoutMs,
-            reportOperationalFailure,
-            (await resolveHostInheritEnv?.()) ?? [],
-          );
+          const hostInheritEnv = (await resolveHostInheritEnv?.()) ?? [];
+          session = historyOnly
+            ? await OmpHistorySession.open(
+                input,
+                runtime,
+                safeCapabilities,
+                sessionEmit,
+                replayTimeoutMs,
+                environment,
+                hostInheritEnv,
+                scheduler,
+              )
+            : await OmpProviderSession.open(
+                input,
+                runtime,
+                safeCapabilities,
+                sessionEmit,
+                transitionNativeSession,
+                quarantineRewindCleanup,
+                retireRewindSession,
+                scheduler,
+                replayTimeoutMs,
+                controller.signal,
+                environment,
+                mcpConnector,
+                mcpInitializationTimeoutMs,
+                reportOperationalFailure,
+                hostInheritEnv,
+              );
           const discoveredNativeSessionId = session.persistenceSessionId;
           if (discoveredNativeSessionId) nativeSessionId = discoveredNativeSessionId;
           if (persistentOpening) {
@@ -995,10 +1014,13 @@ export function createOmpConnection(
             return;
           }
           const browserAgentId = input.config.env.PASEO_AGENT_ID?.trim() || input.sessionId;
-          const browserAuthorization = browserAuthorizationRegistry?.register(
-            browserAgentId,
-            session.openPaseoBrowser.bind(session),
-          );
+          // A history session has no live Paseo browser tools to authorize.
+          const browserAuthorization = historyOnly
+            ? undefined
+            : browserAuthorizationRegistry?.register(
+                browserAgentId,
+                session.openPaseoBrowser.bind(session),
+              );
           session.setBrowserAuthorizationIssuer(browserAuthorization?.issue ?? null);
           const removeBrowserAuthorization = browserAuthorization
             ? () => {
@@ -1155,7 +1177,7 @@ export function createOmpConnection(
     for (const result of operationResults) {
       if (result.status === "rejected") failures.push(result.reason);
     }
-    const seenSessions = new Set<OmpProviderSession>();
+    const seenSessions = new Set<OmpOpenedSession>();
     const seenCleanups = new Set<Promise<void>>();
     const cleanupBatch: Promise<void>[] = [];
     for (const [sessionId, { session, nativeSessionId, token }] of sessions) {

package/server/provider/host-tools.ts

@@ -29,6 +29,7 @@ import {
   truncateUtf8,
   utf8Bytes,
 } from "./security";
+import { withOmpSessionPurpose } from "./session-purpose";
 
 type HostToolFailureStage = Extract<
   OmpOperationalFailure,
@@ -1025,3 +1026,19 @@ export function withOmpWorkspaceIdentity<
   else delete env.PASEO_WORKSPACE_ID;
   return { ...request, env };
 }
+
+/**
+ * The complete env transform for an OMP `agent.session_open` hook: the caller's identity plus the
+ * host-decided launch purpose. Registered once by the plugin and exercised directly by tests.
+ */
+export function withOmpSessionOpenEnv<
+  T extends {
+    agentId: string;
+    workspaceId: string | null;
+    reason?: string;
+    purpose?: string;
+    env: Record<string, string>;
+  },
+>(request: T) {
+  return withOmpSessionPurpose(withOmpWorkspaceIdentity(request));
+}

package/server/provider/session-history.ts

@@ -0,0 +1,330 @@
+import type {
+  ProviderConfigState,
+  ProviderEvent,
+  ProviderInput,
+  ProviderSessionConfig,
+} from "@getpaseo/plugin/server/provider";
+import { normalizeOmpSessionConfig } from "./config-normalization";
+import type { OmpRuntime } from "./omp-rpc";
+import { buildOmpSpawnRequest } from "./omp-rpc-environment";
+import {
+  configuredOutputRedactionValues,
+  OmpPublicDataSerializer,
+  OmpPublicError,
+  utf8Bytes,
+} from "./security";
+import {
+  authorizeNativeSession,
+  fixedSessionMode,
+  type OmpOpenedSession,
+  ompPersistenceSessionId,
+  REPLAY_TIMEOUT_MS,
+  waitForReplay,
+} from "./session";
+import { OmpSubsessionProjector } from "./subsessions";
+import {
+  defaultOmpTimelineScheduler,
+  OmpTimelineProjector,
+  type OmpTimelineScheduler,
+} from "./timeline-projector";
+
+type SessionOpenInput = Extract<ProviderInput, { type: "session.open" }>;
+type SessionPromptInput = Extract<ProviderInput, { type: "session.prompt" }>;
+type SessionInterruptInput = Extract<ProviderInput, { type: "session.interrupt" }>;
+type SessionConfigureInput = Extract<ProviderInput, { type: "session.configure" }>;
+type SessionRevertInput = Extract<ProviderInput, { type: "session.revert" }>;
+type SessionCloseInput = Extract<ProviderInput, { type: "session.close" }>;
+type SessionPermissionInput = Extract<ProviderInput, { type: "session.permission" }>;
+type Emit = (event: ProviderEvent) => void;
+
+// A history session replays a persisted journal and runs nothing. It advertises no prompt,
+// permission, configuration, or rewind capability, so the host rejects those requests itself.
+const HISTORY_CAPABILITIES: readonly string[] = [
+  "session.persistence",
+  "session.subsession",
+  "timeline.plugin",
+];
+const READ_ONLY_MESSAGE = "OMP history sessions are read-only";
+
+/**
+ * Serves a persisted OMP session from its authorized transcript alone. It exists for sessions
+ * whose recorded working directory is gone: no runtime process is spawned, no MCP server is
+ * connected, and the working directory is never touched. The native session identity, workspace
+ * authorization, and transcript ownership checks are the same ones a live resume performs.
+ */
+export class OmpHistorySession implements OmpOpenedSession {
+  readonly id: string;
+  readonly cwd: string;
+
+  private readonly lifetime = new AbortController();
+  private readonly dataFilter: OmpPublicDataSerializer;
+  private readonly projector: OmpTimelineProjector;
+  private readonly subsessions: OmpSubsessionProjector | null;
+  private disposed = false;
+  private sessionClosedPublished = false;
+
+  private constructor(
+    id: string,
+    private readonly config: ProviderSessionConfig,
+    private readonly runtime: OmpRuntime,
+    private readonly readTranscript: NonNullable<OmpRuntime["readPersistedSessionTranscript"]>,
+    private readonly nativeSessionId: string,
+    private readonly transcriptFile: string,
+    private readonly configState: ProviderConfigState,
+    redactionValues: readonly string[],
+    private readonly capabilities: readonly string[],
+    private readonly emit: Emit,
+    private readonly replayTimeoutMs: number,
+    scheduler: OmpTimelineScheduler,
+  ) {
+    this.id = id;
+    this.cwd = config.cwd;
+    this.dataFilter = new OmpPublicDataSerializer(redactionValues);
+    const pluginTimeline = capabilities.includes("timeline.plugin");
+    this.projector = new OmpTimelineProjector(
+      id,
+      emit,
+      scheduler,
+      redactionValues,
+      false,
+      pluginTimeline,
+    );
+    // Same identity key as a live persisted session, so child session ids stay stable across
+    // a history load and a later interactive resume of the same native session.
+    this.subsessions = capabilities.includes("session.subsession")
+      ? new OmpSubsessionProjector(
+          id,
+          `persisted:${nativeSessionId}`,
+          transcriptFile,
+          config.cwd,
+          emit,
+          scheduler,
+          () => {},
+          redactionValues,
+          pluginTimeline,
+        )
+      : null;
+  }
+
+  get persistenceSessionId(): string {
+    return this.nativeSessionId;
+  }
+
+  static async open(
+    input: SessionOpenInput,
+    runtime: OmpRuntime,
+    capabilities: readonly string[],
+    emit: Emit,
+    replayTimeoutMs = REPLAY_TIMEOUT_MS,
+    environment?: NodeJS.ProcessEnv,
+    hostInheritEnv: readonly string[] = [],
+    scheduler: OmpTimelineScheduler = defaultOmpTimelineScheduler,
+  ): Promise<OmpHistorySession> {
+    const nativeSessionId = ompPersistenceSessionId(input);
+    if (!nativeSessionId || input.history !== "replay" || !input.config.persist) {
+      throw new OmpPublicError("OMP history purpose requires a persisted session replay");
+    }
+    const normalized = normalizeOmpSessionConfig(
+      input.config,
+      capabilities.includes("permission"),
+      hostInheritEnv,
+    );
+    if (input.config.title && utf8Bytes(input.config.title) > 256) {
+      throw new OmpPublicError("OMP session title is too large");
+    }
+    const readTranscript = runtime.readPersistedSessionTranscript?.bind(runtime);
+    if (!readTranscript) throw new OmpPublicError("OMP session history cannot be replayed safely");
+    // The same workspace and native-identity authorization as a live resume; only the spawn is
+    // skipped. The recorded cwd is compared, never opened.
+    const descriptor = await authorizeNativeSession(
+      runtime,
+      nativeSessionId,
+      input.config.cwd,
+      normalized.sessionDir,
+    );
+    if (!descriptor.transcriptFile) {
+      throw new OmpPublicError("OMP session transcript could not be resolved in this workspace");
+    }
+    const configuredValues = configuredOutputRedactionValues(
+      normalized.outputRedaction ?? "none",
+      normalized.env,
+      input.config.mcpServers,
+    );
+    // Inherited values are redacted exactly as a live session would: they come from the same
+    // spawn-request builder, which only reads the server environment.
+    const redactionValues =
+      normalized.outputRedaction === "configured-values"
+        ? [
+            ...configuredValues,
+            ...buildOmpSpawnRequest({
+              ...normalized,
+              environment,
+              // A resume never reapplies the system prompt or thinking selection.
+              systemPrompt: undefined,
+              thinkingOption: undefined,
+              resumeSessionId: nativeSessionId,
+              resumeSessionFile: descriptor.transcriptFile,
+            }).inheritedRedactionValues,
+          ]
+        : configuredValues;
+    const configState: ProviderConfigState = {
+      ...(input.config.model ? { model: input.config.model } : {}),
+      mode: normalized.mode ?? "full",
+      ...(input.config.thinkingOption ? { thinkingOption: input.config.thinkingOption } : {}),
+      models: [],
+      modes: [fixedSessionMode(normalized.mode)],
+      thinkingOptions: [],
+      settings: [],
+    };
+    return new OmpHistorySession(
+      input.sessionId,
+      input.config,
+      runtime,
+      readTranscript,
+      nativeSessionId,
+      descriptor.transcriptFile,
+      configState,
+      redactionValues,
+      capabilities.filter((capability) => HISTORY_CAPABILITIES.includes(capability)),
+      emit,
+      replayTimeoutMs,
+      scheduler,
+    );
+  }
+
+  async publishOpened(requestId: string): Promise<void> {
+    this.emit({
+      type: "session.opened",
+      requestId,
+      sessionId: this.id,
+      capabilities: this.capabilities,
+      restoration: "core",
+      cwd: this.cwd,
+      persistence: { version: 1, data: { sessionId: this.nativeSessionId } },
+      ...(this.config.title ? { title: this.dataFilter.text(this.config.title, 256) } : {}),
+    });
+    this.emit({ type: "session.config", sessionId: this.id, config: this.configState });
+    await this.replayHistory();
+    this.emit({ type: "session.ready", requestId, sessionId: this.id });
+  }
+
+  private async replayHistory(): Promise<void> {
+    this.lifetime.signal.throwIfAborted();
+    const replay = new AbortController();
+    const onAbort = () =>
+      replay.abort(new OmpPublicError("OMP session history replay was canceled"));
+    this.lifetime.signal.addEventListener("abort", onAbort, { once: true });
+    const timeoutHandle = setTimeout(
+      () => replay.abort(new OmpPublicError("OMP session history replay timed out")),
+      this.replayTimeoutMs,
+    );
+    try {
+      const transcript = await waitForReplay(
+        this.readTranscript({
+          sessionFile: this.transcriptFile,
+          sessionId: this.nativeSessionId,
+          cwd: this.cwd,
+          signal: replay.signal,
+        }),
+        replay.signal,
+      );
+      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.",
+          },
+        });
+      }
+      for (const message of transcript.messages) {
+        replay.signal.throwIfAborted();
+        this.projector.projectReplayMessage(message);
+      }
+      this.projector.finishReplay();
+      await this.subsessions?.replay(transcript.messages, undefined, this.runtime, replay.signal);
+      replay.signal.throwIfAborted();
+    } catch (error) {
+      if (replay.signal.aborted) throw replay.signal.reason;
+      throw error;
+    } finally {
+      clearTimeout(timeoutHandle);
+      this.lifetime.signal.removeEventListener("abort", onAbort);
+    }
+  }
+
+  openPaseoBrowser(): Promise<void> {
+    return Promise.reject(new OmpPublicError(READ_ONLY_MESSAGE));
+  }
+
+  setBrowserAuthorizationIssuer(issue: ((url: string) => string | undefined) | null): void {
+    this.projector.setBrowserAuthorizationIssuer(issue);
+  }
+
+  prompt(input: SessionPromptInput): Promise<void> {
+    this.emit({
+      type: "session.prompt_result",
+      sessionId: this.id,
+      clientMessageId: input.prompt.clientMessageId,
+      result: { type: "failed", error: { message: READ_ONLY_MESSAGE } },
+    });
+    return Promise.resolve();
+  }
+
+  permission(_input: SessionPermissionInput): Promise<void> {
+    return Promise.reject(new OmpPublicError("OMP history sessions have no pending permissions"));
+  }
+
+  configure(input: SessionConfigureInput): Promise<void> {
+    this.emit({
+      type: "request.failed",
+      requestId: input.requestId,
+      error: { message: READ_ONLY_MESSAGE },
+    });
+    return Promise.resolve();
+  }
+
+  revert(input: SessionRevertInput): Promise<void> {
+    this.emit({
+      type: "request.failed",
+      requestId: input.requestId,
+      error: { message: READ_ONLY_MESSAGE },
+    });
+    return Promise.resolve();
+  }
+
+  interrupt(input: SessionInterruptInput): Promise<void> {
+    this.emit({ type: "request.completed", requestId: input.requestId });
+    return Promise.resolve();
+  }
+
+  beginConnectionShutdown(): void {
+    this.lifetime.abort(new Error("OMP provider connection closed"));
+  }
+
+  abortOpen(): Promise<void> {
+    this.dispose();
+    return Promise.resolve();
+  }
+
+  close(input?: SessionCloseInput): Promise<void> {
+    this.dispose();
+    if (!this.sessionClosedPublished) {
+      this.sessionClosedPublished = true;
+      this.emit({ type: "session.closed", sessionId: this.id });
+    }
+    if (input) this.emit({ type: "request.completed", requestId: input.requestId });
+    return Promise.resolve();
+  }
+
+  private dispose(): void {
+    if (this.disposed) return;
+    this.disposed = true;
+    this.lifetime.abort(new Error("OMP provider session closed"));
+    this.subsessions?.close();
+    this.projector.close();
+  }
+}

package/server/provider/session-purpose.ts

@@ -0,0 +1,56 @@
+import type { ProviderInput } from "@getpaseo/plugin/server/provider";
+import { OmpPublicError } from "./security";
+
+type SessionOpenInput = Extract<ProviderInput, { type: "session.open" }>;
+
+/**
+ * Paseo tells plugins why a session is being opened only through `before("agent.session_open")`
+ * hooks, whose sole writable field is `env`; the plugin provider protocol forwards that env
+ * untouched as `session.open.config.env`. The hook is therefore the single writer of this launch
+ * marker and the connection is the single reader. It is never part of the stored agent config.
+ */
+export const OMP_SESSION_PURPOSE_ENV = "PASEO_OMP_SESSION_PURPOSE";
+const HISTORY_PURPOSE = "history";
+
+/**
+ * Derives the launch marker from the host-decided purpose. Any marker already present is caller
+ * input (for example `env` on agent creation), so it is always discarded first: only a host
+ * resume whose purpose is history can produce it, and an absent purpose (older hosts) never does.
+ */
+export function withOmpSessionPurpose<
+  T extends { reason?: string; purpose?: string; env: Record<string, string> },
+>(request: T): Omit<T, "env"> & { env: Record<string, string> } {
+  const env: Record<string, string> = { ...request.env };
+  delete env[OMP_SESSION_PURPOSE_ENV];
+  if (request.purpose === HISTORY_PURPOSE && request.reason === "resume") {
+    env[OMP_SESSION_PURPOSE_ENV] = HISTORY_PURPOSE;
+  }
+  return { ...request, env };
+}
+
+/**
+ * True when this open must be served from the persisted transcript alone, without a runtime
+ * process or any working-directory access. The marker only narrows a persisted replay: it can
+ * never be satisfied by a create, a non-replaying open, or a non-persisted config.
+ */
+export function isOmpHistoryOnlyOpen(input: SessionOpenInput): boolean {
+  const marker = input.config.env[OMP_SESSION_PURPOSE_ENV];
+  if (marker === undefined) return false;
+  if (marker !== HISTORY_PURPOSE) throw new OmpPublicError("Invalid OMP session purpose");
+  if (input.history !== "replay" || !input.persistence || !input.config.persist) {
+    throw new OmpPublicError("OMP history purpose requires a persisted session replay");
+  }
+  return true;
+}
+
+/**
+ * Removes the reserved launch marker from any env bound for an OMP process. The marker steers
+ * the plugin only; it must never be forwarded to, or settable through per-agent provider options
+ * for, a real OMP runtime.
+ */
+export function withoutOmpSessionPurpose(
+  env: Readonly<Record<string, string>>,
+): Record<string, string> {
+  const { [OMP_SESSION_PURPOSE_ENV]: _reserved, ...rest } = env;
+  return rest;
+}