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

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,
+});

package/shared/omp-settings.ts

@@ -17,6 +17,163 @@ export type OmpSettingType = z.infer<typeof OmpSettingTypeSchema>;
 export const OmpScalarValueSchema = z.union([z.boolean(), z.number(), z.string()]);
 export type OmpScalarValue = z.infer<typeof OmpScalarValueSchema>;
 
+const MAX_ROUTING_ENTRIES = 64;
+const MAX_FALLBACK_CHAIN_LENGTH = 16;
+const MAX_AGENT_MODEL_CHOICES = 8;
+const MAX_MODEL_SELECTOR_LENGTH = 513;
+
+function containsControlCharacter(value: string): boolean {
+  for (const character of value) {
+    const codePoint = character.codePointAt(0) ?? 0;
+    if (codePoint < 32 || codePoint === 127) return true;
+  }
+  return false;
+}
+
+function utf8ByteLength(value: string): number {
+  let bytes = 0;
+  for (const character of value) {
+    const codePoint = character.codePointAt(0) ?? 0;
+    bytes += codePoint <= 0x7f ? 1 : codePoint <= 0x7ff ? 2 : codePoint <= 0xffff ? 3 : 4;
+  }
+  return bytes;
+}
+
+export const OmpRoleNameSchema = z
+  .string()
+  .min(1)
+  .max(64)
+  .regex(
+    /^[A-Za-z][A-Za-z0-9_-]*$/,
+    "Role names must start with a letter and use only letters, digits, _ or -.",
+  );
+
+export const OmpModelSelectorSchema = z
+  .string()
+  .min(1)
+  .max(MAX_MODEL_SELECTOR_LENGTH)
+  .refine(
+    (value) => utf8ByteLength(value) <= MAX_MODEL_SELECTOR_LENGTH,
+    `Model selectors must not exceed ${MAX_MODEL_SELECTOR_LENGTH} UTF-8 bytes.`,
+  )
+  .refine(
+    (value) => value === value.trim() && !/\s/u.test(value) && !containsControlCharacter(value),
+    {
+      message: "Model selectors must be a single printable token.",
+    },
+  );
+
+export function isValidOmpModelSelector(value: string): boolean {
+  return OmpModelSelectorSchema.safeParse(value).success;
+}
+
+const OmpAgentNameSchema = z
+  .string()
+  .min(1)
+  .max(128)
+  .refine((value) => value === value.trim() && !containsControlCharacter(value), {
+    message: "Agent names cannot have surrounding whitespace or control characters.",
+  });
+
+export const OmpModelRolesSchema = z
+  .record(OmpRoleNameSchema, OmpModelSelectorSchema)
+  .refine((value) => Object.keys(value).length <= MAX_ROUTING_ENTRIES, "Too many model roles.");
+
+const OmpFallbackKeySchema = z.string().superRefine((value, context) => {
+  const schema = value.includes("/") ? OmpModelSelectorSchema : OmpRoleNameSchema;
+  const result = schema.safeParse(value);
+  if (!result.success) {
+    context.addIssue({
+      code: "custom",
+      message: result.error.issues[0]?.message ?? "Invalid fallback chain key.",
+    });
+  }
+});
+
+export const OmpFallbackChainsSchema = z
+  .record(OmpFallbackKeySchema, z.array(OmpModelSelectorSchema).max(MAX_FALLBACK_CHAIN_LENGTH))
+  .refine((value) => Object.keys(value).length <= MAX_ROUTING_ENTRIES, "Too many fallback chains.");
+
+export const OmpCycleOrderSchema = z
+  .array(OmpRoleNameSchema)
+  .max(MAX_ROUTING_ENTRIES)
+  .refine((value) => new Set(value).size === value.length, "Cycle roles must be unique.");
+
+export const OmpAgentModelOverridesSchema = z
+  .record(
+    OmpAgentNameSchema,
+    z.union([
+      OmpModelSelectorSchema,
+      z.array(OmpModelSelectorSchema).min(1).max(MAX_AGENT_MODEL_CHOICES),
+    ]),
+  )
+  .refine(
+    (value) => Object.keys(value).length <= MAX_ROUTING_ENTRIES,
+    "Too many agent model overrides.",
+  );
+
+export const OmpAgentServiceTierOverridesSchema = z
+  .record(
+    OmpAgentNameSchema,
+    z.enum(["inherit", "none", "auto", "default", "flex", "scale", "priority"]),
+  )
+  .refine(
+    (value) => Object.keys(value).length <= MAX_ROUTING_ENTRIES,
+    "Too many agent service tier overrides.",
+  );
+
+const OmpAgentToggleOrSelectorSchema = z.union([z.enum(["on", "off"]), OmpModelSelectorSchema]);
+
+export const OmpAgentPrewalkSchema = z
+  .record(OmpAgentNameSchema, OmpAgentToggleOrSelectorSchema)
+  .refine(
+    (value) => Object.keys(value).length <= MAX_ROUTING_ENTRIES,
+    "Too many agent prewalk overrides.",
+  );
+
+export const OmpAgentAdvisorSchema = z
+  .record(OmpAgentNameSchema, OmpAgentToggleOrSelectorSchema)
+  .refine(
+    (value) => Object.keys(value).length <= MAX_ROUTING_ENTRIES,
+    "Too many agent advisor overrides.",
+  );
+
+export const OMP_STRUCTURED_SETTING_PATHS = [
+  "modelRoles",
+  "retry.fallbackChains",
+  "cycleOrder",
+  "task.agentModelOverrides",
+  "task.agentServiceTierOverrides",
+  "task.agentPrewalk",
+  "task.agentAdvisor",
+] as const;
+export type OmpStructuredSettingPath = (typeof OMP_STRUCTURED_SETTING_PATHS)[number];
+
+export function parseOmpStructuredSettingValue(path: string, value: unknown): unknown | undefined {
+  switch (path) {
+    case "modelRoles":
+      return OmpModelRolesSchema.safeParse(value).data;
+    case "retry.fallbackChains":
+      return OmpFallbackChainsSchema.safeParse(value).data;
+    case "cycleOrder":
+      return OmpCycleOrderSchema.safeParse(value).data;
+    case "task.agentModelOverrides":
+      return OmpAgentModelOverridesSchema.safeParse(value).data;
+    case "task.agentServiceTierOverrides":
+      return OmpAgentServiceTierOverridesSchema.safeParse(value).data;
+    case "task.agentPrewalk":
+      return OmpAgentPrewalkSchema.safeParse(value).data;
+    case "task.agentAdvisor":
+      return OmpAgentAdvisorSchema.safeParse(value).data;
+    default:
+      return undefined;
+  }
+}
+
+export function isOmpStructuredSettingPath(path: string): path is OmpStructuredSettingPath {
+  return (OMP_STRUCTURED_SETTING_PATHS as readonly string[]).includes(path);
+}
+
 export const OmpSettingSchema = z
   .object({
     path: z.string(),
@@ -184,9 +341,76 @@ export const listOmpSettings = defineRpc({
   }),
 });
 
-const OmpSettingChangeSchema = z.discriminatedUnion("operation", [
-  z.object({ operation: z.literal("set"), path: z.string().min(1), value: OmpScalarValueSchema }),
-  z.object({ operation: z.literal("reset"), path: z.string().min(1) }),
+const OmpScalarSettingPathSchema = z
+  .string()
+  .min(1)
+  .refine(
+    (path) => !isOmpStructuredSettingPath(path),
+    "Structured routing settings require typed values.",
+  );
+
+const OmpStructuredSettingChangeSchema = z.discriminatedUnion("path", [
+  z
+    .object({
+      operation: z.literal("set"),
+      path: z.literal("modelRoles"),
+      value: OmpModelRolesSchema,
+    })
+    .strict(),
+  z
+    .object({
+      operation: z.literal("set"),
+      path: z.literal("retry.fallbackChains"),
+      value: OmpFallbackChainsSchema,
+    })
+    .strict(),
+  z
+    .object({
+      operation: z.literal("set"),
+      path: z.literal("cycleOrder"),
+      value: OmpCycleOrderSchema,
+    })
+    .strict(),
+  z
+    .object({
+      operation: z.literal("set"),
+      path: z.literal("task.agentModelOverrides"),
+      value: OmpAgentModelOverridesSchema,
+    })
+    .strict(),
+  z
+    .object({
+      operation: z.literal("set"),
+      path: z.literal("task.agentServiceTierOverrides"),
+      value: OmpAgentServiceTierOverridesSchema,
+    })
+    .strict(),
+  z
+    .object({
+      operation: z.literal("set"),
+      path: z.literal("task.agentPrewalk"),
+      value: OmpAgentPrewalkSchema,
+    })
+    .strict(),
+  z
+    .object({
+      operation: z.literal("set"),
+      path: z.literal("task.agentAdvisor"),
+      value: OmpAgentAdvisorSchema,
+    })
+    .strict(),
+]);
+
+const OmpSettingChangeSchema = z.union([
+  z
+    .object({
+      operation: z.literal("set"),
+      path: OmpScalarSettingPathSchema,
+      value: OmpScalarValueSchema,
+    })
+    .strict(),
+  OmpStructuredSettingChangeSchema,
+  z.object({ operation: z.literal("reset"), path: z.string().min(1) }).strict(),
 ]);
 
 export const updateOmpSettings = defineRpc({

package/shared/support-diagnostics.ts

@@ -0,0 +1,32 @@
+import { defineRpc } from "@getpaseo/plugin";
+import { z } from "zod";
+import { OmpWorkspaceCwdSchema } from "./hub";
+import { OmpStoreSchema } from "./omp-store";
+
+export const OMP_SUPPORT_REPORT_SCHEMA_VERSION = 1 as const;
+export const OMP_SUPPORT_REPORT_MAX_BYTES = 64 * 1024;
+export const OMP_SUPPORT_ISSUE_URL =
+  "https://github.com/omercnet/paseo-plugins/issues/new?template=omp-plugin.yml";
+
+export function supportReportByteLength(value: string): number {
+  return new TextEncoder().encode(value).byteLength;
+}
+
+export const OmpSupportReportTextSchema = z
+  .string()
+  .min(1)
+  .refine((value) => supportReportByteLength(value) <= OMP_SUPPORT_REPORT_MAX_BYTES, {
+    message: "OMP support report exceeds 64 KiB",
+  });
+
+export const getOmpSupportReport = defineRpc({
+  name: "paseo-omp.get-support-report",
+  input: z
+    .object({
+      store: OmpStoreSchema.optional(),
+      force: z.boolean().optional(),
+      cwd: OmpWorkspaceCwdSchema.optional(),
+    })
+    .strict(),
+  output: z.object({ report: OmpSupportReportTextSchema }).strict(),
+});