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

package/index.server.ts

@@ -6,6 +6,7 @@ import {
 } from "./server/mcp-browser";
 import { resolveListOmpMemory } from "./server/memory";
 import { resolveListOmpConfig } from "./server/omp-config";
+import { resolveListOmpModels } from "./server/omp-models";
 import {
   resolveInspectOmpPluginConfig,
   resolveListOmpPlugins,
@@ -13,7 +14,9 @@ import {
   resolveMutateOmpPluginConfig,
 } from "./server/omp-plugins";
 import { resolveListOmpSettings, resolveUpdateOmpSettings } from "./server/omp-settings";
+import { OmpOperationalFailureCollector } from "./server/operational-failure-diagnostics";
 import { withOmpStore } from "./server/paths";
+import { OmpProtocolViolationCollector } from "./server/protocol-violation-diagnostics";
 import { withOmpWorkspaceIdentity } from "./server/provider/host-tools";
 import {
   createProfileOmpProvider,
@@ -24,11 +27,13 @@ import { createOmpProvider } from "./server/provider/registration";
 import { resolveGetOmpProviderHealth } from "./server/provider-diagnostics";
 import { resolveListOmpQuotas } from "./server/quota";
 import { resolveListOmpSessions } from "./server/sessions";
+import { resolveGetOmpSupportReport } from "./server/support-diagnostics";
 import { composerPillSettings } from "./shared/composer-pill-settings";
 import { listHubProcesses, tailHubLog } from "./shared/hub";
 import { openOmpMcpAuthorizationInPaseoBrowser } from "./shared/mcp";
 import { listOmpMemory } from "./shared/memory";
 import { listOmpConfig } from "./shared/omp-config";
+import { listOmpModels } from "./shared/omp-models";
 import {
   inspectOmpPluginConfig,
   listOmpPlugins,
@@ -40,6 +45,7 @@ import { listOmpStores, type OmpStore } from "./shared/omp-store";
 import { getOmpProviderHealth } from "./shared/provider-diagnostics";
 import { listOmpQuotas } from "./shared/quota";
 import { listOmpSessions } from "./shared/sessions";
+import { getOmpSupportReport } from "./shared/support-diagnostics";
 
 function scoped<T extends { store?: OmpStore }, R>(handler: (input: T) => R) {
   return (input: T): R => withOmpStore(input.store, () => handler(input));
@@ -48,10 +54,18 @@ function scoped<T extends { store?: OmpStore }, R>(handler: (input: T) => R) {
 export default function contribute(server: PluginServerContext) {
   server.registerSettings(composerPillSettings);
   const browserAuthorizationRegistry = new OmpBrowserAuthorizationRegistry();
+  const protocolViolations = new OmpProtocolViolationCollector();
+  const operationalFailures = new OmpOperationalFailureCollector();
   const profiles = discoverOmpProfilesSync();
   server.handle(listOmpStores, async () => ({ profiles: await discoverOmpProfiles() }));
   for (const profile of profiles) {
-    server.registerProvider(createProfileOmpProvider(profile, { browserAuthorizationRegistry }));
+    server.registerProvider(
+      createProfileOmpProvider(profile, {
+        browserAuthorizationRegistry,
+        reportProtocolViolation: protocolViolations.report,
+        reportOperationalFailure: operationalFailures.report,
+      }),
+    );
   }
   server.handle(listHubProcesses, resolveListHubProcesses);
   server.handle(tailHubLog, resolveTailHubLog);
@@ -59,6 +73,7 @@ export default function contribute(server: PluginServerContext) {
   server.handle(listOmpMemory, scoped(resolveListOmpMemory));
   server.handle(listOmpSessions, scoped(resolveListOmpSessions));
   server.handle(listOmpConfig, scoped(resolveListOmpConfig));
+  server.handle(listOmpModels, scoped(resolveListOmpModels));
   server.handle(listOmpPlugins, scoped(resolveListOmpPlugins));
   server.handle(inspectOmpPluginConfig, scoped(resolveInspectOmpPluginConfig));
   server.handle(mutateOmpPlugin, scoped(resolveMutateOmpPlugin));
@@ -66,6 +81,10 @@ export default function contribute(server: PluginServerContext) {
   server.handle(listOmpSettings, scoped(resolveListOmpSettings));
   server.handle(updateOmpSettings, scoped(resolveUpdateOmpSettings));
   server.handle(getOmpProviderHealth, scoped(resolveGetOmpProviderHealth));
+  server.handle(
+    getOmpSupportReport,
+    scoped((input) => resolveGetOmpSupportReport(input, protocolViolations, operationalFailures)),
+  );
   server.handle(openOmpMcpAuthorizationInPaseoBrowser, (input) =>
     resolveOpenOmpMcpAuthorizationInPaseoBrowser(input, browserAuthorizationRegistry),
   );
@@ -73,7 +92,13 @@ export default function contribute(server: PluginServerContext) {
     if (request.provider !== "omp-plugin" && !request.provider.startsWith("omp-plugin-")) return;
     return withOmpWorkspaceIdentity(request);
   });
-  server.registerProvider(createOmpProvider({ browserAuthorizationRegistry }));
+  server.registerProvider(
+    createOmpProvider({
+      browserAuthorizationRegistry,
+      reportProtocolViolation: protocolViolations.report,
+      reportOperationalFailure: operationalFailures.report,
+    }),
+  );
   return () => {
     browserAuthorizationRegistry.clear();
     removeIdentityHook();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@omercnet/paseo-omp",
-  "version": "0.3.0",
+  "version": "0.4.0-next.114.1",
   "type": "module",
   "description": "Paseo integration for OMP, including its direct provider and workspace tooling.",
   "license": "MIT",
@@ -29,21 +29,15 @@
     "coding-agents"
   ],
   "files": [
-    "package-lock.json",
-    "CHANGELOG.md",
     "LICENSE",
     "README.md",
-    "SUPPORT.md",
-    "TESTING.md",
-    "docs",
     "scripts/prepare-dependencies.mjs",
     "index.client.tsx",
     "index.server.ts",
     "client",
     "server",
     "shared",
-    "paseo-plugin.json",
-    "tsconfig.json"
+    "paseo-plugin.json"
   ],
   "scripts": {
     "check": "biome check .",

package/paseo-plugin.json

@@ -1,5 +1,5 @@
 {
   "id": "paseo-omp",
-  "requirements": { "paseo": ">=0.8.0 <0.10.0" },
+  "requirements": { "paseo": ">=0.9.0-beta.1 <0.10.0" },
   "build": [["node", "scripts/prepare-dependencies.mjs"]]
 }

package/server/omp-models.ts

@@ -0,0 +1,59 @@
+import { homedir } from "node:os";
+import { isAbsolute } from "node:path";
+import type { RpcInput } from "@getpaseo/plugin";
+import type { listOmpModels, OmpModelCandidate, OmpModelListResult } from "../shared/omp-models";
+import { currentOmpEnvironment } from "./paths";
+import {
+  type OmpModel,
+  OmpRpcRuntime,
+  type OmpRuntime,
+  type OmpRuntimeSession,
+} from "./provider/omp-rpc";
+import { OmpCleanupFailure, OmpPublicDataSerializer, OmpPublicError } from "./provider/security";
+
+function mapOmpModel(model: OmpModel, serializer: OmpPublicDataSerializer): OmpModelCandidate {
+  const provider = serializer.text(model.provider, 256);
+  const id = serializer.text(model.id, 256);
+  return {
+    selector: `${provider}/${id}`,
+    provider,
+    id,
+    ...(model.name !== undefined ? { name: serializer.text(model.name, 256) } : {}),
+    reasoning: model.reasoning === true,
+    input: (model.input ?? []).map((value) => serializer.text(value, 256)),
+    ...(model.contextWindow !== undefined ? { contextWindow: model.contextWindow } : {}),
+    thinkingLevels: (model.thinking?.efforts ?? []).map((value) => serializer.text(value, 32)),
+  };
+}
+
+async function closeModelCatalogSession(session: OmpRuntimeSession): Promise<void> {
+  const cleanup = session.close();
+  try {
+    await cleanup;
+  } catch {
+    throw new OmpCleanupFailure("OMP model catalog cleanup failed", cleanup);
+  }
+}
+
+export async function resolveListOmpModels(
+  input: RpcInput<typeof listOmpModels>,
+  runtime: OmpRuntime = new OmpRpcRuntime({ environment: currentOmpEnvironment() }),
+): Promise<OmpModelListResult> {
+  const cwd = input.cwd ?? homedir();
+  if (!isAbsolute(cwd) || cwd.includes("\0")) {
+    throw new OmpPublicError("The workspace path is invalid.");
+  }
+  const session = await runtime.startSession({
+    cwd,
+    environment: currentOmpEnvironment(),
+    noSession: true,
+  });
+  try {
+    const serializer = new OmpPublicDataSerializer();
+    return {
+      models: (await session.getAvailableModels()).map((model) => mapOmpModel(model, serializer)),
+    };
+  } finally {
+    await closeModelCatalogSession(session);
+  }
+}

package/server/omp-settings.ts

@@ -5,12 +5,13 @@ import { delimiter, dirname, isAbsolute, join } from "node:path";
 import type { RpcInput } from "@getpaseo/plugin";
 import { parseDocument, parse as parseYaml } from "yaml";
 import {
+  isOmpStructuredSettingPath,
   type listOmpSettings,
   OMP_SETTINGS_CATALOG_VERSION,
-  type OmpScalarValue,
   type OmpSetting,
   type OmpSettingType,
   OmpSettingTypeSchema,
+  parseOmpStructuredSettingValue,
   type updateOmpSettings,
 } from "../shared/omp-settings";
 import { SerialMutationQueue } from "./mutation-queue";
@@ -305,14 +306,28 @@ async function loadCatalog(
   }
 }
 
-function serializeScalar(type: OmpSettingType, value: OmpScalarValue): string | null {
-  if (type === "boolean") return typeof value === "boolean" ? String(value) : null;
-  if (type === "number")
+function serializeSettingValue(setting: OmpSetting, value: unknown): string | null {
+  if (isOmpStructuredSettingPath(setting.path)) {
+    const expectedType = setting.path === "cycleOrder" ? "array" : "record";
+    if (setting.type !== expectedType) return null;
+    const parsed = parseOmpStructuredSettingValue(setting.path, value);
+    return parsed === undefined ? null : JSON.stringify(parsed);
+  }
+  if (setting.type === "boolean") return typeof value === "boolean" ? String(value) : null;
+  if (setting.type === "number")
     return typeof value === "number" && Number.isFinite(value) ? String(value) : null;
-  if (type === "string" || type === "enum") return typeof value === "string" ? value : null;
+  if (setting.type === "string" || setting.type === "enum")
+    return typeof value === "string" ? value : null;
   return null;
 }
 
+function isEditableSetting(setting: OmpSetting): boolean {
+  if (setting.redacted) return false;
+  if (["boolean", "number", "string", "enum"].includes(setting.type)) return true;
+  if (!isOmpStructuredSettingPath(setting.path)) return false;
+  return setting.type === (setting.path === "cycleOrder" ? "array" : "record");
+}
+
 export async function listOmpSettingsWithDependencies(
   input: RpcInput<typeof listOmpSettings>,
   dependencies: OmpSettingsDependencies,
@@ -373,26 +388,22 @@ export async function updateOmpSettingsWithDependencies(
   if (input.cwd) {
     for (const change of input.changes) {
       const setting = byPath.get(change.path);
-      if (
-        !setting ||
-        setting.redacted ||
-        !["boolean", "number", "string", "enum"].includes(setting.type)
-      ) {
+      if (!setting || !isEditableSetting(setting)) {
         return {
           conflict: false,
           appliedPaths: [],
           failed: {
             path: change.path,
-            message: "This setting cannot be edited as a workspace scalar value.",
+            message: "This setting cannot be edited through the focused configuration editor.",
           },
           catalog: current,
         };
       }
-      if (change.operation === "set" && serializeScalar(setting.type, change.value) === null) {
+      if (change.operation === "set" && serializeSettingValue(setting, change.value) === null) {
         return {
           conflict: false,
           appliedPaths: [],
-          failed: { path: change.path, message: `Expected a ${setting.type} value.` },
+          failed: { path: change.path, message: `Invalid ${change.path} value.` },
           catalog: current,
         };
       }
@@ -440,15 +451,14 @@ export async function updateOmpSettingsWithDependencies(
   const appliedPaths: string[] = [];
   for (const change of input.changes) {
     const setting = byPath.get(change.path);
-    if (
-      !setting ||
-      setting.redacted ||
-      !["boolean", "number", "string", "enum"].includes(setting.type)
-    ) {
+    if (!setting || !isEditableSetting(setting)) {
       return {
         conflict: false,
         appliedPaths,
-        failed: { path: change.path, message: "This setting cannot be edited as a scalar value." },
+        failed: {
+          path: change.path,
+          message: "This setting cannot be edited through the focused configuration editor.",
+        },
         catalog: await loadCatalog(executable, dependencies, input.cwd),
       };
     }
@@ -456,7 +466,7 @@ export async function updateOmpSettingsWithDependencies(
     if (change.operation === "reset") {
       args = ["reset", change.path];
     } else {
-      const value = serializeScalar(setting.type, change.value);
+      const value = serializeSettingValue(setting, change.value);
       args = value === null ? null : ["set", change.path, "--json", "--", value];
     }
     if (!args) {

package/server/operational-failure-diagnostics.ts

@@ -0,0 +1,76 @@
+export const OMP_OPERATIONAL_FAILURES = [
+  { category: "session-open", stage: "startup" },
+  { category: "session-open", stage: "catalog" },
+  { category: "replay-recovery", stage: "persisted-replay" },
+  { category: "replay-recovery", stage: "runtime-recovery" },
+  { category: "replay-recovery", stage: "rewind" },
+  { category: "tool-projector", stage: "host-tool-unknown" },
+  { category: "tool-projector", stage: "host-tool-capacity" },
+  { category: "tool-projector", stage: "host-tool-normalization" },
+  { category: "tool-projector", stage: "host-tool-call" },
+  { category: "tool-projector", stage: "host-tool-timeout" },
+  { category: "tool-projector", stage: "host-tool-delivery" },
+  { category: "tool-projector", stage: "timeline-projector" },
+  { category: "tool-projector", stage: "subsession-projector" },
+  { category: "terminal-outcome", stage: "failed" },
+  { category: "terminal-outcome", stage: "unresolved" },
+] as const;
+
+export type OmpOperationalFailure = (typeof OMP_OPERATIONAL_FAILURES)[number];
+export type OmpOperationalFailureCategory = OmpOperationalFailure["category"];
+export type OmpOperationalFailureStage = OmpOperationalFailure["stage"];
+export type OmpOperationalFailureReporter = (failure: OmpOperationalFailure) => void;
+
+export type OmpOperationalFailureSummary = OmpOperationalFailure & {
+  occurrenceCount: number;
+  firstAt: string | null;
+  lastAt: string | null;
+};
+
+const FAILURE_KEYS: Readonly<Record<string, true>> = Object.fromEntries(
+  OMP_OPERATIONAL_FAILURES.map(({ category, stage }) => [`${category}:${stage}`, true]),
+);
+
+function timestamp(now: () => Date): string | null {
+  try {
+    const value = now();
+    return Number.isFinite(value.getTime()) ? value.toISOString() : null;
+  } catch {
+    return null;
+  }
+}
+
+/** Fixed category/stage cells make aggregation constant-space for one plugin subprocess lifetime. */
+export class OmpOperationalFailureCollector {
+  private readonly summaries = Object.fromEntries(
+    OMP_OPERATIONAL_FAILURES.map(({ category, stage }) => [
+      `${category}:${stage}`,
+      { category, stage, occurrenceCount: 0, firstAt: null, lastAt: null },
+    ]),
+  ) as Record<string, OmpOperationalFailureSummary>;
+
+  constructor(private readonly now: () => Date = () => new Date()) {}
+
+  report: OmpOperationalFailureReporter = (failure) => {
+    try {
+      const key = `${failure.category}:${failure.stage}`;
+      if (!FAILURE_KEYS[key]) return;
+      const summary = this.summaries[key];
+      if (!summary) return;
+      summary.occurrenceCount = Math.min(Number.MAX_SAFE_INTEGER, summary.occurrenceCount + 1);
+      const recordedAt = timestamp(this.now);
+      if (recordedAt) {
+        summary.firstAt ??= recordedAt;
+        summary.lastAt = recordedAt;
+      }
+    } catch {
+      // Diagnostics must never affect provider or session flow.
+    }
+  };
+
+  snapshot(): OmpOperationalFailureSummary[] {
+    return OMP_OPERATIONAL_FAILURES.map(({ category, stage }) => ({
+      ...this.summaries[`${category}:${stage}`],
+    }));
+  }
+}

package/server/package-version.ts

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

package/server/protocol-violation-diagnostics.ts

@@ -0,0 +1,169 @@
+import {
+  OMP_PROTOCOL_VIOLATION_CATEGORIES,
+  OMP_PROTOCOL_VIOLATION_REASONS,
+  type OmpProtocolViolationCategory,
+  type OmpProtocolViolationDiagnostic,
+  type OmpProtocolViolationReason,
+} from "./provider/omp-rpc";
+
+export interface OmpProtocolViolationSummary {
+  category: OmpProtocolViolationCategory;
+  occurrenceCount: number;
+  batchCount: number;
+  maxOccurrenceCount: number;
+  firstAt: string | null;
+  lastAt: string | null;
+  reasonCounts: Record<OmpProtocolViolationReason, number>;
+  latestReason: OmpProtocolViolationDiagnostic["reason"] | null;
+  latestPhase: OmpProtocolViolationDiagnostic["phase"] | null;
+  latestEventType: OmpProtocolViolationDiagnostic["eventType"] | null;
+  latestFrameType: OmpProtocolViolationDiagnostic["frameType"] | null;
+  latestField: OmpProtocolViolationDiagnostic["field"] | null;
+  latestExpected: OmpProtocolViolationDiagnostic["expected"] | null;
+  latestActualType: OmpProtocolViolationDiagnostic["actualType"] | null;
+  maxByteSize: number | null;
+  latestLimitBytes: number | null;
+}
+
+type MutableSummary = OmpProtocolViolationSummary;
+
+const FRAME_TYPES: Record<NonNullable<OmpProtocolViolationDiagnostic["frameType"]>, true> = {
+  ready: true,
+  response: true,
+  rpc_chunk: true,
+  rpc_frame_error: true,
+  notice: true,
+};
+
+function boundedCount(value: unknown): number {
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) return 0;
+  return Math.min(value, Number.MAX_SAFE_INTEGER);
+}
+
+function boundedAdd(left: number, right: number): number {
+  return Math.min(Number.MAX_SAFE_INTEGER, left + right);
+}
+
+function safeTimestamp(now: () => Date): string | null {
+  try {
+    const value = now();
+    return Number.isFinite(value.getTime()) ? value.toISOString() : null;
+  } catch {
+    return null;
+  }
+}
+
+function logProtocolViolation(message: string, diagnostic: OmpProtocolViolationDiagnostic): void {
+  const fields = [
+    `category: ${diagnostic.category}`,
+    `reason: ${diagnostic.reason}`,
+    `occurrenceCount: ${diagnostic.occurrenceCount}`,
+    `phase: ${diagnostic.phase}`,
+    ...(diagnostic.eventType ? [`eventType: ${diagnostic.eventType}`] : []),
+    ...(diagnostic.frameType ? [`frameType: ${diagnostic.frameType}`] : []),
+    ...(diagnostic.field ? [`field: ${diagnostic.field}`] : []),
+    ...(diagnostic.expected ? [`expected: ${diagnostic.expected}`] : []),
+    ...(diagnostic.actualType ? [`actualType: ${diagnostic.actualType}`] : []),
+    ...(diagnostic.maxByteSize ? [`maxByteSize: ${diagnostic.maxByteSize}`] : []),
+    ...(diagnostic.limitBytes ? [`limitBytes: ${diagnostic.limitBytes}`] : []),
+  ];
+  console.error(`${message} { ${fields.join(", ")} }`);
+}
+
+/** Fixed-category, saturating in-process aggregation. A new instance is created on each reload. */
+export class OmpProtocolViolationCollector {
+  private readonly summaries = Object.fromEntries(
+    OMP_PROTOCOL_VIOLATION_CATEGORIES.map((category) => [
+      category,
+      {
+        category,
+        occurrenceCount: 0,
+        batchCount: 0,
+        maxOccurrenceCount: 0,
+        firstAt: null,
+        lastAt: null,
+        reasonCounts: Object.fromEntries(
+          OMP_PROTOCOL_VIOLATION_REASONS.map((reason) => [reason, 0]),
+        ),
+        latestReason: null,
+        latestPhase: null,
+        latestEventType: null,
+        latestFrameType: null,
+        latestField: null,
+        latestExpected: null,
+        latestActualType: null,
+        maxByteSize: null,
+        latestLimitBytes: null,
+      },
+    ]),
+  ) as Record<OmpProtocolViolationCategory, MutableSummary>;
+
+  constructor(
+    private readonly now: () => Date = () => new Date(),
+    private readonly log: (
+      message: string,
+      diagnostic: OmpProtocolViolationDiagnostic,
+    ) => void | PromiseLike<void> = logProtocolViolation,
+  ) {}
+
+  report = (diagnostic: OmpProtocolViolationDiagnostic): void => {
+    try {
+      const summary = this.summaries[diagnostic.category];
+      if (!summary) return;
+      const occurrenceCount = boundedCount(diagnostic.occurrenceCount);
+      const timestamp = safeTimestamp(this.now);
+      summary.occurrenceCount = boundedAdd(summary.occurrenceCount, occurrenceCount);
+      summary.batchCount = boundedAdd(summary.batchCount, 1);
+      summary.maxOccurrenceCount = Math.max(summary.maxOccurrenceCount, occurrenceCount);
+      if (timestamp) {
+        summary.firstAt ??= timestamp;
+        summary.lastAt = timestamp;
+      }
+      summary.reasonCounts[diagnostic.reason] = boundedAdd(
+        summary.reasonCounts[diagnostic.reason],
+        occurrenceCount,
+      );
+      summary.latestReason = diagnostic.reason;
+      summary.latestPhase = diagnostic.phase;
+      summary.latestEventType = diagnostic.eventType ?? null;
+      summary.latestFrameType =
+        diagnostic.frameType && FRAME_TYPES[diagnostic.frameType] ? diagnostic.frameType : null;
+      summary.latestField = diagnostic.field ?? null;
+      summary.latestExpected = diagnostic.expected ?? null;
+      summary.latestActualType = diagnostic.actualType ?? null;
+      const byteSize = boundedCount(diagnostic.maxByteSize);
+      if (byteSize > 0) summary.maxByteSize = Math.max(summary.maxByteSize ?? 0, byteSize);
+      const limitBytes = boundedCount(diagnostic.limitBytes);
+      summary.latestLimitBytes = limitBytes || null;
+
+      const safeDiagnostic: OmpProtocolViolationDiagnostic = {
+        category: diagnostic.category,
+        reason: diagnostic.reason,
+        phase: diagnostic.phase,
+        occurrenceCount,
+        ...(summary.latestEventType ? { eventType: summary.latestEventType } : {}),
+        ...(summary.latestFrameType ? { frameType: summary.latestFrameType } : {}),
+        ...(summary.latestField ? { field: summary.latestField } : {}),
+        ...(summary.latestExpected ? { expected: summary.latestExpected } : {}),
+        ...(summary.latestActualType ? { actualType: summary.latestActualType } : {}),
+        ...(byteSize > 0 ? { maxByteSize: byteSize } : {}),
+        ...(limitBytes > 0 ? { limitBytes } : {}),
+      };
+      try {
+        const logging = this.log("OMP protocol violation", safeDiagnostic);
+        if (logging) void Promise.resolve(logging).catch(() => undefined);
+      } catch {
+        // Diagnostics must never affect transport or provider flow.
+      }
+    } catch {
+      // Diagnostics must never affect transport or provider flow.
+    }
+  };
+
+  snapshot(): OmpProtocolViolationSummary[] {
+    return OMP_PROTOCOL_VIOLATION_CATEGORIES.map((category) => ({
+      ...this.summaries[category],
+      reasonCounts: { ...this.summaries[category].reasonCounts },
+    }));
+  }
+}

package/server/provider/catalog.ts

@@ -48,6 +48,27 @@ const THINKING_OPTIONS: readonly ProviderThinkingOption[] = [
   { id: "xhigh", label: "XHigh", description: "Extra-high reasoning" },
   { id: "max", label: "Max", description: "Maximum reasoning" },
 ];
+export const OMP_MAX_CATALOG_MODELS = 256;
+
+export function selectOmpModels(
+  models: readonly OmpModel[],
+  activeModel: OmpModel | null | undefined,
+): OmpModel[] {
+  if (models.length <= OMP_MAX_CATALOG_MODELS) return [...models];
+  const selected = models.slice(0, OMP_MAX_CATALOG_MODELS);
+  if (!activeModel) return selected;
+  const active = models.find(
+    (model) => model.provider === activeModel.provider && model.id === activeModel.id,
+  );
+  if (
+    !active ||
+    selected.some((model) => model.provider === active.provider && model.id === active.id)
+  ) {
+    return selected;
+  }
+  selected[OMP_MAX_CATALOG_MODELS - 1] = active;
+  return selected;
+}
 
 export function nativeOmpModelId(model: OmpModel): string {
   if (model.provider.includes("/")) {
@@ -60,14 +81,9 @@ export function ompModelId(model: OmpModel): string {
   const nativeIdentity = `${Buffer.byteLength(model.provider, "utf8")}:${model.provider}${Buffer.byteLength(model.id, "utf8")}:${model.id}`;
   return `omp:model:${createHash("sha256").update(nativeIdentity).digest("hex")}`;
 }
-
-export function mapOmpModels(
-  models: readonly OmpModel[],
-  serializer = new OmpPublicDataSerializer(),
-): ProviderModel[] {
+export function validateOmpModelIdentities(models: readonly OmpModel[]): void {
   const seenIds = new Map<string, string>();
-  return models.map((model) => {
-    const thinkingOptions = thinkingForModel(model);
+  for (const model of models) {
     const id = ompModelId(model);
     const nativeIdentity = nativeOmpModelId(model);
     const existing = seenIds.get(id);
@@ -76,6 +92,17 @@ export function mapOmpModels(
     }
     if (existing !== undefined) throw new Error("OMP reported a duplicate model identity");
     seenIds.set(id, nativeIdentity);
+  }
+}
+
+export function mapOmpModels(
+  models: readonly OmpModel[],
+  serializer = new OmpPublicDataSerializer(),
+): ProviderModel[] {
+  validateOmpModelIdentities(models);
+  return models.map((model) => {
+    const thinkingOptions = thinkingForModel(model);
+    const id = ompModelId(model);
     const provider = serializer.text(model.provider, 256);
     const modelId = serializer.text(model.id, 256);
     const name = model.name ? serializer.text(model.name, 256) : modelId;
@@ -143,14 +170,16 @@ export async function discoverOmpCatalog(
         ? [...configuredValues, ...(session.inheritedRedactionValues ?? [])]
         : configuredValues,
     );
-    const models = mapOmpModels(nativeModels, serializer);
+    validateOmpModelIdentities(nativeModels);
+    const selectedNativeModels = selectOmpModels(nativeModels, state.model);
+    const models = mapOmpModels(selectedNativeModels, serializer);
     if (models.length === 0) throw new Error("OMP reported no available models");
     const defaultModel = state.model ? ompModelId(state.model) : models[0]?.id;
     const currentModel = state.model
-      ? nativeModels.find(
+      ? selectedNativeModels.find(
           (model) => model.provider === state.model?.provider && model.id === state.model.id,
         )
-      : nativeModels[0];
+      : selectedNativeModels[0];
     if (state.model && !currentModel) throw new Error("OMP reported an unadvertised active model");
     const thinkingOptions = thinkingForModel(currentModel);
     const defaultThinkingOption = thinkingOptions.some(