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

package/server/provider/timeline-projector.ts

@@ -6,17 +6,25 @@ import type {
 } from "@getpaseo/plugin/server/provider";
 import { OMP_MCP_AUTH_TIMELINE_KIND } from "../../shared/mcp";
 import { isOmpImageMimeType, isValidImagePayload, type OmpImageMimeType } from "./image";
-import { OMP_MAX_CONTENT_PARTS, type OmpMessage, type OmpRpcEvent } from "./omp-rpc";
+import {
+  OMP_MAX_CONTENT_PARTS,
+  OMP_MESSAGE_REPLAY_POLICIES,
+  type OmpMessage,
+  type OmpRpcEvent,
+} from "./omp-rpc";
 import {
   boundedJsonBytes,
   type JsonValue,
   OmpPublicDataSerializer,
   OmpPublicError,
+  truncateUtf8,
   utf8Bytes,
 } from "./security";
 
 const STREAM_FRAME_MS = 32;
 const MAX_STREAM_TEXT_LENGTH = 4 * 1024 * 1024;
+const MAX_RAW_STREAM_TEXT_LENGTH = 8 * 1024 * 1024;
+const MAX_REDACTED_STREAM_TEXT_LENGTH = MAX_RAW_STREAM_TEXT_LENGTH * 3;
 const MAX_ACTIVE_TOOLS = 64;
 const MAX_TODOS = 256;
 const MAX_TURN_NATIVE_IDENTITIES = 1_024;
@@ -131,6 +139,10 @@ function imageBlock(data: string, mimeType: string): StreamBlockSnapshot | undef
 }
 
 type OmpAssistantMessage = Extract<OmpMessage, { role: "assistant" }>;
+type OmpCustomDisplayMessage = Extract<
+  OmpMessage,
+  { role: "bashExecution" | "pythonExecution" | "custom" | "hookMessage" }
+>;
 
 function blockText(
   message: OmpAssistantMessage,
@@ -414,16 +426,35 @@ export class OmpTimelineProjector {
         return;
       }
     }
+    if (
+      (event.type === "message_start" ||
+        event.type === "message_update" ||
+        event.type === "message_end") &&
+      OMP_MESSAGE_REPLAY_POLICIES[event.message.role] === "ignore"
+    ) {
+      return;
+    }
     if (
       event.type === "todo_reminder" ||
       event.type === "todo_auto_clear" ||
+      event.type === "goal_updated" ||
+      event.type === "auto_retry_start" ||
+      event.type === "auto_retry_end" ||
+      event.type === "retry_fallback_applied" ||
+      event.type === "retry_fallback_succeeded" ||
       event.type === "notice" ||
       event.type === "extension_ui_request" ||
       event.type === "auto_compaction_start" ||
       event.type === "auto_compaction_end" ||
       event.type === "compaction_start" ||
       event.type === "compaction_end" ||
-      event.type === "advisor_yielded"
+      event.type === "advisor_yielded" ||
+      event.type === "config_warnings_changed" ||
+      event.type === "advisor_cost_changed" ||
+      event.type === "ttsr_triggered" ||
+      event.type === "irc_message" ||
+      event.type === "model_changed" ||
+      event.type === "thinking_level_changed"
     ) {
       this.projectPassive(event);
       return;
@@ -446,7 +477,12 @@ export class OmpTimelineProjector {
         this.scheduleFlush();
         return;
       case "message_end":
-        if (event.message.role === "custom" || event.message.role === "bashExecution") {
+        if (
+          event.message.role === "custom" ||
+          event.message.role === "hookMessage" ||
+          event.message.role === "bashExecution" ||
+          event.message.role === "pythonExecution"
+        ) {
           this.publishCustomMessage(event.message);
           return;
         }
@@ -496,12 +532,13 @@ export class OmpTimelineProjector {
         if (!snapshot.silent) this.publishTool(snapshot, "running");
         return;
       }
-      case "tool_execution_update": {
+      case "tool_execution_update":
+      case "tool_stream_update": {
         const previous = this.tools.get(event.toolCallId);
         if (!previous) return;
         if (previous.turnId !== turnId || previous.generation !== this.runtimeGeneration) return;
         const output = this.dataFilter.json(
-          event.partialResult,
+          event.type === "tool_execution_update" ? event.partialResult : event.update,
           MAX_PUBLIC_TOOL_PAYLOAD_BYTES,
           MAX_PUBLIC_TOOL_PAYLOAD_BYTES,
         );
@@ -597,6 +634,10 @@ export class OmpTimelineProjector {
       this.publishRetryFallback(event);
       return;
     }
+    if (event.type === "irc_message") {
+      this.publishCustomMessage(event.message as OmpCustomDisplayMessage);
+      return;
+    }
     if (event.type === "notice") {
       this.noticeSequence += 1;
       this.publish({
@@ -836,8 +877,9 @@ export class OmpTimelineProjector {
 
   projectReplayMessage(message: OmpMessage): void {
     if (this.closed) return;
-    const nativeIdentity = assistantIdentity(message);
     this.replaySequence += 1;
+    if (OMP_MESSAGE_REPLAY_POLICIES[message.role] === "ignore") return;
+
     if (message.role === "user") {
       this.replayToolCalls.clear();
       if (this.replayTurnId) this.finishTurn(this.replayTurnId);
@@ -858,7 +900,9 @@ export class OmpTimelineProjector {
       }
       return;
     }
+
     if (message.role === "assistant") {
+      const nativeIdentity = assistantIdentity(message);
       this.replayTurnId ??= `omp:replay-turn:${this.replaySequence}`;
       this.projectingReplay = true;
       try {
@@ -877,6 +921,7 @@ export class OmpTimelineProjector {
       if (nativeIdentity) this.rememberReplayOccurrence(nativeIdentity, message);
       return;
     }
+
     this.replayTurnId ??= `omp:replay-turn:${this.replaySequence}`;
     if (message.role === "toolResult") {
       const replayCall = this.replayToolCalls.get(message.toolCallId);
@@ -907,13 +952,18 @@ export class OmpTimelineProjector {
       );
       return;
     }
-    if (message.role === "bashExecution") {
-      const text = message.output
-        ? `$ ${message.command}\n${message.output}`
-        : `$ ${message.command}`;
-      this.project({ type: "command_output", text }, this.replayTurnId);
-      this.finishTurn(this.replayTurnId);
-      this.replayTurnId = null;
+
+    if (
+      message.role === "bashExecution" ||
+      message.role === "pythonExecution" ||
+      message.role === "custom" ||
+      message.role === "hookMessage"
+    ) {
+      this.publishCustomMessage(message);
+      if (message.role === "bashExecution" || message.role === "pythonExecution") {
+        this.finishTurn(this.replayTurnId);
+        this.replayTurnId = null;
+      }
     }
   }
 
@@ -1007,13 +1057,28 @@ export class OmpTimelineProjector {
     if (!this.stream || this.closed || this.stream.dirtyBlocks.size === 0) return;
     const stream = this.stream;
     if (!stream.nativeIdentity && !finalizeFallback) return;
-    const indexes = [...stream.dirtyBlocks].sort((left, right) => left - right);
+    const indexes = [...stream.blocks.keys()].sort((left, right) => left - right);
+    let remainingTextBytes = MAX_STREAM_TEXT_LENGTH;
     stream.dirtyBlocks.clear();
     for (const contentIndex of indexes) {
       const block = stream.blocks.get(contentIndex);
-      if (!block?.text) continue;
-      const publicText = block.kind === "image" ? block.text : this.dataFilter.text(block.text);
-      if (!publicText || block.publishedText === publicText) continue;
+      if (!block) continue;
+      const publicText =
+        block.kind === "image"
+          ? block.text
+          : truncateUtf8(
+              this.dataFilter.text(block.text, MAX_REDACTED_STREAM_TEXT_LENGTH),
+              remainingTextBytes,
+            );
+      if (block.kind !== "image") {
+        remainingTextBytes = Math.max(0, remainingTextBytes - utf8Bytes(publicText));
+      }
+      if (
+        block.publishedText === publicText ||
+        (!publicText && block.publishedText === undefined)
+      ) {
+        continue;
+      }
       const nextPublishedBytes = utf8Bytes(publicText);
       if (
         stream.retainedBytes + stream.publishedBytes + nextPublishedBytes >
@@ -1267,7 +1332,7 @@ export class OmpTimelineProjector {
       (snapshot.kind === "image" ? 0 : snapshotBytes);
     if (
       retainedBytes + stream.publishedBytes > MAX_STREAM_TOTAL_BYTES ||
-      textBytes > MAX_STREAM_TEXT_LENGTH
+      textBytes > MAX_RAW_STREAM_TEXT_LENGTH
     ) {
       return;
     }
@@ -1291,7 +1356,7 @@ export class OmpTimelineProjector {
 
   private publishCommand(turnId: string): void {
     if (!this.commandText) return;
-    const publicText = this.dataFilter.text(this.commandText);
+    const publicText = this.dataFilter.text(this.commandText, MAX_STREAM_TEXT_LENGTH);
     if (!publicText || publicText === this.commandPublishedText) return;
     this.commandPublishedText = publicText;
     this.publish({
@@ -1335,9 +1400,17 @@ export class OmpTimelineProjector {
     return undefined;
   }
 
-  private publishCustomMessage(message: OmpMessage): void {
-    if (message.display === false) return;
-    const rawType = message.customType ?? message.role;
+  private publishCustomMessage(message: OmpCustomDisplayMessage): void {
+    if (
+      (message.role === "custom" || message.role === "hookMessage") &&
+      message.display === false
+    ) {
+      return;
+    }
+    const rawType =
+      message.role === "custom" || message.role === "hookMessage"
+        ? (message.customType ?? message.role)
+        : message.role;
     const publicType = this.dataFilter.text(rawType, 256);
     const lowerType = rawType.toLowerCase();
     const details = jsonRecord(this.dataFilter.json(message.details ?? null));
@@ -1346,7 +1419,9 @@ export class OmpTimelineProjector {
     const id = nativeIdentity
       ? `omp:custom:${createHash("sha256").update(nativeIdentity).digest("base64url").slice(0, 12)}`
       : `omp:custom:${this.customSequence}`;
-    const contentParts = Array.isArray(message.content) ? message.content : [];
+    const messageContent =
+      message.role === "custom" || message.role === "hookMessage" ? message.content : undefined;
+    const contentParts = Array.isArray(messageContent) ? messageContent : [];
     const imageResult = nativeImageResult(
       {
         content:
@@ -1358,16 +1433,26 @@ export class OmpTimelineProjector {
       this.dataFilter,
     );
     const content =
-      typeof message.content === "string"
-        ? message.content
+      typeof messageContent === "string"
+        ? messageContent
         : contentParts
             .flatMap((part) => (part.type === "text" && part.text ? [part.text] : []))
             .join("\n\n");
-    if (message.role === "bashExecution" || /bash|shell|python/u.test(lowerType)) {
+    const execution = message.role === "bashExecution" || message.role === "pythonExecution";
+    if (execution || /bash|shell|python/u.test(lowerType)) {
+      const nativeCommand =
+        message.role === "bashExecution"
+          ? message.command
+          : message.role === "pythonExecution"
+            ? message.code
+            : undefined;
       const command = this.dataFilter.text(
-        message.command ?? firstString(details, "command", "input") ?? publicType,
+        nativeCommand ?? firstString(details, "command", "input") ?? publicType,
       );
-      const output = message.output ?? content;
+      const output = execution ? (message.output ?? content) : content;
+      const exitCode = execution ? message.exitCode : undefined;
+      const cancelled = execution ? message.cancelled : undefined;
+      const truncated = execution ? message.truncated : undefined;
       this.publish({
         type: "tool_call",
         id,
@@ -1377,14 +1462,22 @@ export class OmpTimelineProjector {
           type: "shell",
           command,
           ...(firstString(details, "cwd") ? { cwd: firstString(details, "cwd") } : {}),
-          ...(output ? { output: this.dataFilter.text(output) } : {}),
-          ...(typeof message.exitCode === "number" || message.exitCode === null
-            ? { exitCode: message.exitCode }
+          ...(output ? { output: this.dataFilter.text(output, MAX_STREAM_TEXT_LENGTH) } : {}),
+          ...(typeof exitCode === "number" || exitCode === null
+            ? { exitCode }
             : typeof details?.exitCode === "number"
               ? { exitCode: details.exitCode }
               : {}),
         },
-        status: message.cancelled ? "canceled" : "completed",
+        ...(cancelled !== undefined || truncated !== undefined
+          ? {
+              metadata: {
+                ...(cancelled !== undefined ? { cancelled } : {}),
+                ...(truncated !== undefined ? { truncated } : {}),
+              },
+            }
+          : {}),
+        status: cancelled ? "canceled" : "completed",
         error: null,
       });
       if (imageResult) this.publishImages(id, publicType, imageResult.image);

package/server/support-diagnostics.ts

@@ -0,0 +1,284 @@
+import { arch, platform } from "node:os";
+import type { RpcInput } from "@getpaseo/plugin";
+import { z } from "zod";
+import type { OmpProviderHealth, OmpVersion } from "../shared/provider-diagnostics";
+import {
+  type getOmpSupportReport,
+  OMP_SUPPORT_REPORT_MAX_BYTES,
+  OMP_SUPPORT_REPORT_SCHEMA_VERSION,
+  supportReportByteLength,
+} from "../shared/support-diagnostics";
+import type {
+  OmpOperationalFailureCollector,
+  OmpOperationalFailureSummary,
+} from "./operational-failure-diagnostics";
+import { PASEO_OMP_PACKAGE_VERSION } from "./package-version";
+import type {
+  OmpProtocolViolationCollector,
+  OmpProtocolViolationSummary,
+} from "./protocol-violation-diagnostics";
+import { resolveGetOmpProviderHealth } from "./provider-diagnostics";
+
+const PACKAGE_VERSION = z
+  .string()
+  .regex(/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]{1,48})?$/u)
+  .max(64);
+const NODE_VERSION = z
+  .string()
+  .regex(/^v\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]{1,48})?$/u)
+  .max(64);
+const KNOWN_PLATFORMS: Record<string, true> = {
+  aix: true,
+  android: true,
+  darwin: true,
+  freebsd: true,
+  linux: true,
+  openbsd: true,
+  sunos: true,
+  win32: true,
+};
+const KNOWN_ARCHITECTURES: Record<string, true> = {
+  arm: true,
+  arm64: true,
+  ia32: true,
+  loong64: true,
+  mips: true,
+  mipsel: true,
+  ppc: true,
+  ppc64: true,
+  riscv64: true,
+  s390: true,
+  s390x: true,
+  x64: true,
+};
+
+export interface OmpSupportReportData {
+  collectedAt: string;
+  pluginVersion: string;
+  platform: string;
+  architecture: string;
+  nodeVersion: string;
+  scope: "global" | "workspace";
+  store: "default" | "named-profile" | "custom-directory";
+  health: OmpProviderHealth | null;
+  violations: readonly OmpProtocolViolationSummary[];
+  operationalFailures: readonly OmpOperationalFailureSummary[];
+}
+
+const EXPECTATION_LABELS: Record<
+  NonNullable<OmpProtocolViolationSummary["latestExpected"]>,
+  string
+> = {
+  "complete-json-line": "newline-terminated JSON frame",
+  "within-byte-limit": "byte length within negotiated limit",
+  "valid-json": "valid UTF-8 JSON",
+  "object-envelope": "JSON object envelope",
+  "bounded-frame-type": "frame type string up to 64 bytes",
+  "valid-response-frame": "valid response envelope",
+  "valid-ready-frame": "valid ready handshake",
+  "single-ready-frame": "one ready handshake",
+  "valid-event-frame": "valid event payload",
+  "valid-event-state-transition": "event valid for current stream state",
+  "valid-message-event": "valid message event payload",
+  "valid-tool-event": "valid tool event payload",
+  "valid-lifecycle-event": "valid lifecycle event payload",
+  "valid-subagent-event": "valid subagent event payload",
+  "valid-configuration-event": "valid configuration event payload",
+  "valid-extension-ui-event": "valid extension UI event payload",
+  "known-event-type": "supported event type",
+  "notice-level-enum": "info, warning, or error",
+  "notice-message-string": "bounded string",
+  "valid-chunk-frame": "valid chunk metadata",
+  "valid-base64-chunk": "valid base64 chunk",
+  "first-chunk-index-zero": "first chunk index 0",
+  "contiguous-chunk-sequence": "contiguous chunk sequence",
+  "declared-chunk-byte-count": "decoded bytes equal declared byte length",
+  "chunk-before-deadline": "next chunk before timeout",
+  "no-interleaved-frame": "no interleaved frame during chunk assembly",
+  "no-remote-frame-error": "no remote frame error",
+};
+
+function finiteCount(value: number | null | undefined, maximum = Number.MAX_SAFE_INTEGER): string {
+  return value !== null && value !== undefined && Number.isSafeInteger(value) && value >= 0
+    ? String(Math.min(value, maximum))
+    : "unknown";
+}
+
+function usefulReportLine(line: string): boolean {
+  return !line.endsWith(": unavailable") && !line.endsWith(": unknown") && !line.endsWith(": 0");
+}
+
+function formatVersion(version: OmpVersion | null): string {
+  if (!version) return "unavailable";
+  const core = `${version.major}.${version.minor}.${version.patch}`;
+  return version.prerelease ? `${core}-${version.prerelease}` : core;
+}
+
+function formatHealth(health: OmpProviderHealth | null): string[] {
+  if (!health) return ["collection.provider_health: failed"];
+  return [
+    "collection.provider_health: complete",
+    `omp.installed: ${health.binary.installed}`,
+    `omp.version: ${formatVersion(health.binary.version)}`,
+    `omp.version_probe: ${health.binary.versionStatus}`,
+    `omp.process_cleanup: ${health.binary.processCleanupFailed ? "failed" : "ok"}`,
+    `compatibility.rpc_ui: ${!health.rpcUi.checked || health.rpcUi.supported === null ? "unknown" : health.rpcUi.supported ? "supported" : "not-advertised"}`,
+    `compatibility.lsp: ${health.lsp.status}`,
+    `mcp.status: ${health.mcp.status}`,
+    `mcp.server_count: ${finiteCount(health.mcp.serverCount, 4_096)}`,
+    `mcp.reason: ${health.mcp.reason ?? "unknown"}`,
+    `storage.agent_root: ${health.roots.agentRootState}`,
+    `storage.config: ${health.roots.configState}`,
+    `storage.session_root: ${health.roots.sessionRootState}`,
+    `storage.agent_database: ${health.databases.agentDbState}`,
+    `storage.history_database: ${health.databases.historyDbState}`,
+    `storage.memory_backend: ${health.memoryBackend ?? "unknown"}`,
+    `hub.status: ${health.process.status}`,
+    `hub.tracked_count: ${finiteCount(health.process.trackedCount, 100_000)}`,
+    `hub.active_count: ${finiteCount(health.process.activeCount, 100_000)}`,
+    `hub.historical_count: ${finiteCount(health.process.historicalCount, 100_000)}`,
+    `hub.unknown_count: ${finiteCount(health.process.unknownCount, 100_000)}`,
+  ];
+}
+
+/** Stable line ordering is part of the pasted support-report contract. */
+export function formatOmpSupportReport(data: OmpSupportReportData): string {
+  const lines = [
+    "OMP support diagnostics",
+    `schema_version: ${OMP_SUPPORT_REPORT_SCHEMA_VERSION}`,
+    `collected_at_utc: ${data.collectedAt}`,
+    `paseo_omp.version: ${data.pluginVersion}`,
+    `runtime.platform: ${data.platform}`,
+    `runtime.architecture: ${data.architecture}`,
+    `runtime.node: ${data.nodeVersion}`,
+    `selection.scope: ${data.scope}`,
+    `selection.store: ${data.store}`,
+    "selection.applies_to: provider-health",
+    "diagnostic_counters.scope: plugin-process-all-stores-workspaces",
+    "diagnostic_counters.lifetime: since-plugin-load",
+    ...formatHealth(data.health),
+  ];
+  for (const violation of data.violations) {
+    if (violation.occurrenceCount === 0) continue;
+    const prefix = `protocol.${violation.category}`;
+    lines.push(
+      `${prefix}.occurrence_count: ${finiteCount(violation.occurrenceCount)}`,
+      `${prefix}.batch_count: ${finiteCount(violation.batchCount)}`,
+      `${prefix}.max_batch_count: ${finiteCount(violation.maxOccurrenceCount)}`,
+    );
+    for (const [reason, count] of Object.entries(violation.reasonCounts)) {
+      if (count > 0) lines.push(`${prefix}.reason.${reason}.occurrence_count: ${count}`);
+    }
+    lines.push(
+      `${prefix}.latest_reason: ${violation.latestReason ?? "unknown"}`,
+      `${prefix}.latest_phase: ${violation.latestPhase ?? "unknown"}`,
+      `${prefix}.latest_event_type: ${violation.latestEventType ?? "unknown"}`,
+      `${prefix}.first_at_utc: ${violation.firstAt ?? "unavailable"}`,
+      `${prefix}.last_at_utc: ${violation.lastAt ?? "unavailable"}`,
+      `${prefix}.latest_frame_type: ${violation.latestFrameType ?? "unknown"}`,
+      `${prefix}.latest_field: ${violation.latestField ?? "unknown"}`,
+      `${prefix}.latest_expected: ${violation.latestExpected ? EXPECTATION_LABELS[violation.latestExpected] : "unknown"}`,
+      `${prefix}.latest_actual_type: ${violation.latestActualType ?? "unknown"}`,
+      `${prefix}.max_byte_size: ${finiteCount(violation.maxByteSize)}`,
+      `${prefix}.latest_limit_bytes: ${finiteCount(violation.latestLimitBytes)}`,
+    );
+  }
+  for (const failure of data.operationalFailures) {
+    if (failure.occurrenceCount === 0) continue;
+    const prefix = `operational.${failure.category}.${failure.stage}`;
+    lines.push(
+      `${prefix}.occurrence_count: ${finiteCount(failure.occurrenceCount)}`,
+      `${prefix}.first_at_utc: ${failure.firstAt ?? "unavailable"}`,
+      `${prefix}.last_at_utc: ${failure.lastAt ?? "unavailable"}`,
+    );
+  }
+  const report = `${lines.filter(usefulReportLine).join("\n")}\n`;
+  if (supportReportByteLength(report) > OMP_SUPPORT_REPORT_MAX_BYTES) {
+    return [
+      "OMP support diagnostics",
+      `schema_version: ${OMP_SUPPORT_REPORT_SCHEMA_VERSION}`,
+      `collected_at_utc: ${data.collectedAt}`,
+      "collection_status: failed",
+      "collection_error: report-size-limit",
+      "",
+    ].join("\n");
+  }
+  return report;
+}
+
+function collectedAt(now: () => Date): string {
+  try {
+    const value = now();
+    return Number.isFinite(value.getTime()) ? value.toISOString() : "unavailable";
+  } catch {
+    return "unavailable";
+  }
+}
+
+export async function resolveGetOmpSupportReport(
+  input: RpcInput<typeof getOmpSupportReport>,
+  violations: OmpProtocolViolationCollector,
+  operationalFailures: OmpOperationalFailureCollector,
+  dependencies: {
+    loadHealth?: typeof resolveGetOmpProviderHealth;
+    loadPluginVersion?: () => Promise<string>;
+    now?: () => Date;
+    platform?: () => string;
+    architecture?: () => string;
+    nodeVersion?: string;
+  } = {},
+): Promise<{ report: string }> {
+  const timestamp = collectedAt(dependencies.now ?? (() => new Date()));
+  try {
+    const [healthResult, pluginVersionResult] = await Promise.allSettled([
+      (dependencies.loadHealth ?? resolveGetOmpProviderHealth)(input),
+      (dependencies.loadPluginVersion ?? (() => Promise.resolve(PASEO_OMP_PACKAGE_VERSION)))(),
+    ]);
+    const platformValue = (dependencies.platform ?? platform)();
+    const architectureValue = (dependencies.architecture ?? arch)();
+    const nodeVersionValue = dependencies.nodeVersion ?? process.version;
+    return {
+      report: formatOmpSupportReport({
+        collectedAt: timestamp,
+        pluginVersion:
+          pluginVersionResult.status === "fulfilled" &&
+          PACKAGE_VERSION.safeParse(pluginVersionResult.value).success
+            ? pluginVersionResult.value
+            : "unavailable",
+        platform: KNOWN_PLATFORMS[platformValue] ? platformValue : "unknown",
+        architecture: KNOWN_ARCHITECTURES[architectureValue] ? architectureValue : "unknown",
+        nodeVersion: NODE_VERSION.safeParse(nodeVersionValue).success
+          ? nodeVersionValue
+          : "unavailable",
+        scope: input.cwd ? "workspace" : "global",
+        store: input.store?.profile
+          ? "named-profile"
+          : input.store?.agentDir
+            ? "custom-directory"
+            : "default",
+        health: healthResult.status === "fulfilled" ? healthResult.value : null,
+        violations: violations.snapshot(),
+        operationalFailures: operationalFailures.snapshot(),
+      }),
+    };
+  } catch {
+    return {
+      report: formatOmpSupportReport({
+        collectedAt: timestamp,
+        pluginVersion: "unavailable",
+        platform: "unknown",
+        architecture: "unknown",
+        nodeVersion: "unavailable",
+        scope: input.cwd ? "workspace" : "global",
+        store: input.store?.profile
+          ? "named-profile"
+          : input.store?.agentDir
+            ? "custom-directory"
+            : "default",
+        health: null,
+        violations: violations.snapshot(),
+        operationalFailures: operationalFailures.snapshot(),
+      }),
+    };
+  }
+}

package/shared/omp-models.ts

@@ -0,0 +1,49 @@
+import { defineRpc } from "@getpaseo/plugin";
+import { z } from "zod";
+import { OmpWorkspaceCwdSchema } from "./hub";
+import { OmpStoreSchema } from "./omp-store";
+
+const OMP_MODEL_TEXT_LIMIT = 256;
+const OMP_MODEL_SELECTOR_LIMIT = OMP_MODEL_TEXT_LIMIT * 2 + 1;
+const OMP_MODEL_LIST_LIMIT = 256;
+const OMP_MODEL_INPUT_LIMIT = 16;
+const OMP_THINKING_LEVEL_LIMIT = 16;
+const OMP_THINKING_LEVEL_TEXT_LIMIT = 32;
+const OMP_CONTEXT_WINDOW_LIMIT = 100_000_000;
+
+const OmpModelTextSchema = z.string().min(1).max(OMP_MODEL_TEXT_LIMIT);
+
+export const OmpModelCandidateSchema = z
+  .object({
+    selector: z.string().min(3).max(OMP_MODEL_SELECTOR_LIMIT),
+    provider: OmpModelTextSchema,
+    id: OmpModelTextSchema,
+    name: z.string().max(OMP_MODEL_TEXT_LIMIT).optional(),
+    reasoning: z.boolean(),
+    input: z.array(OmpModelTextSchema).max(OMP_MODEL_INPUT_LIMIT),
+    contextWindow: z
+      .number()
+      .int()
+      .nonnegative()
+      .max(OMP_CONTEXT_WINDOW_LIMIT)
+      .nullable()
+      .optional(),
+    thinkingLevels: z
+      .array(z.string().max(OMP_THINKING_LEVEL_TEXT_LIMIT))
+      .max(OMP_THINKING_LEVEL_LIMIT),
+  })
+  .strict();
+export type OmpModelCandidate = z.infer<typeof OmpModelCandidateSchema>;
+
+export const OmpModelListResultSchema = z
+  .object({ models: z.array(OmpModelCandidateSchema).max(OMP_MODEL_LIST_LIMIT) })
+  .strict();
+export type OmpModelListResult = z.infer<typeof OmpModelListResultSchema>;
+
+export const listOmpModels = defineRpc({
+  name: "paseo-omp.list-models",
+  input: z
+    .object({ store: OmpStoreSchema.optional(), cwd: OmpWorkspaceCwdSchema.optional() })
+    .strict(),
+  output: OmpModelListResultSchema,
+});