@omercnet/paseo-omp 0.2.1

package/client/provider-diagnostics-state.ts

@@ -0,0 +1,250 @@
+import type { PaseoApi, PaseoProviderSnapshotResult } from "@getpaseo/client";
+import type {
+  OmpLspDiagnostics,
+  OmpMcpDiagnostics,
+  OmpProcessDiagnostics,
+  OmpProviderHealth,
+  OmpVersion,
+  OmpVersionStatus,
+  PathState,
+} from "../shared/provider-diagnostics";
+
+export type ProviderHealthTone = "ok" | "warning" | "danger" | "muted";
+export const OMP_PROVIDER_IDS = ["omp", "omp-plugin"] as const;
+const OMP_PROVIDER_ID_SET: ReadonlySet<string> = new Set(OMP_PROVIDER_IDS);
+
+export function isUnsupportedHostError(error: unknown): boolean {
+  if (typeof error !== "object" || error === null) return false;
+  const candidate = error as { code?: unknown; name?: unknown };
+  return (
+    candidate.name === "PaseoUpdateHostError" ||
+    candidate.code === "UPDATE_HOST_REQUIRED" ||
+    candidate.code === "UNSUPPORTED_FEATURE"
+  );
+}
+
+type ProviderActions = Pick<PaseoApi["providers"], "refresh" | "snapshot" | "waitForReady">;
+
+/** Initial and post-refresh discovery waits for a settled snapshot; only known old-host errors
+ * fall back to the immediate snapshot API. */
+export async function loadReadyProviderSnapshot(
+  providers: ProviderActions,
+): Promise<PaseoProviderSnapshotResult> {
+  try {
+    return await providers.waitForReady({ timeoutMs: 60_000 });
+  } catch (error) {
+    if (!isUnsupportedHostError(error)) throw error;
+    return providers.snapshot({});
+  }
+}
+
+export interface RefreshDiagnosticsOptions {
+  providers: ProviderActions;
+  loadForcedHealth(): Promise<OmpProviderHealth>;
+  cacheHealth(health: OmpProviderHealth): void;
+  cacheProviders(snapshot: PaseoProviderSnapshotResult): void;
+}
+
+/** Provider refresh and forced health run independently. Each successful result reaches its
+ * cache even when another branch fails; the boolean reports any non-suppressed partial failure. */
+export async function refreshProviderDiagnostics(
+  options: RefreshDiagnosticsOptions,
+): Promise<{ failed: boolean }> {
+  const [providerRefresh, forcedHealth] = await Promise.allSettled([
+    options.providers.refresh({ providers: [...OMP_PROVIDER_IDS] }),
+    options.loadForcedHealth(),
+  ]);
+  if (forcedHealth.status === "fulfilled") options.cacheHealth(forcedHealth.value);
+
+  const providerSnapshot = await Promise.allSettled([loadReadyProviderSnapshot(options.providers)]);
+  if (providerSnapshot[0].status === "fulfilled") {
+    options.cacheProviders(providerSnapshot[0].value);
+  }
+  const providerRefreshFailed =
+    providerRefresh.status === "rejected" && !isUnsupportedHostError(providerRefresh.reason);
+  return {
+    failed:
+      providerRefreshFailed ||
+      forcedHealth.status === "rejected" ||
+      providerSnapshot[0].status === "rejected",
+  };
+}
+
+const VERSION_STATUS_LABELS: Record<OmpVersionStatus, string> = {
+  ok: "Installed",
+  "not-found": "Not installed",
+  unrunnable: "Found but could not run",
+  timeout: "Version check timed out",
+  "probe-failed": "Version check failed",
+  malformed: "Unrecognized version output",
+};
+
+const VERSION_STATUS_TONES: Record<OmpVersionStatus, ProviderHealthTone> = {
+  ok: "ok",
+  "not-found": "danger",
+  unrunnable: "danger",
+  timeout: "warning",
+  "probe-failed": "warning",
+  malformed: "warning",
+};
+
+export function formatOmpVersion(version: OmpVersion): string {
+  const core = `${version.major}.${version.minor}.${version.patch}`;
+  return version.prerelease ? `${core}-${version.prerelease}` : core;
+}
+
+export interface BinaryHealthSummary {
+  label: string;
+  tone: ProviderHealthTone;
+}
+
+/** Combines version status and the parsed version into one display-ready label and tone. */
+export function summarizeBinaryHealth(binary: OmpProviderHealth["binary"]): BinaryHealthSummary {
+  const label =
+    binary.versionStatus === "ok" && binary.version
+      ? `${VERSION_STATUS_LABELS.ok} (${formatOmpVersion(binary.version)})`
+      : VERSION_STATUS_LABELS[binary.versionStatus];
+  return { label, tone: VERSION_STATUS_TONES[binary.versionStatus] };
+}
+
+/** Distinguishes "not supported" from "we could not tell" so the UI never overclaims. */
+export function summarizeRpcUiSupport(rpcUi: OmpProviderHealth["rpcUi"]): string {
+  if (!rpcUi.checked) return "Unknown (omp binary unavailable)";
+  if (rpcUi.supported === null) return "Unknown (probe failed, empty, or truncated)";
+  return rpcUi.supported ? "Supported" : "Not advertised by this build";
+}
+
+export function rpcUiTone(rpcUi: OmpProviderHealth["rpcUi"]): ProviderHealthTone {
+  if (!rpcUi.checked || rpcUi.supported === null) return "muted";
+  return rpcUi.supported ? "ok" : "muted";
+}
+
+export function summarizeLspSupport(lsp: OmpLspDiagnostics): string {
+  if (lsp.status === "supported") return "Supported";
+  if (lsp.status === "not-advertised") return "Not advertised by this build";
+  return "Unknown (probe failed, empty, or truncated)";
+}
+
+export function lspTone(lsp: OmpLspDiagnostics): ProviderHealthTone {
+  return lsp.status === "supported" ? "ok" : "muted";
+}
+
+export function summarizeMcpDiagnostics(mcp: OmpMcpDiagnostics): string {
+  if (mcp.status === "configured") return `${mcp.serverCount ?? 0} configured`;
+  const label =
+    mcp.status === "unavailable"
+      ? "Unavailable"
+      : mcp.status === "unreadable"
+        ? "Unreadable"
+        : mcp.status === "wrong-type"
+          ? "Wrong type"
+          : "Invalid";
+  return `${label} (${mcp.reason ?? "no detail"})`;
+}
+
+export function mcpTone(mcp: OmpMcpDiagnostics): ProviderHealthTone {
+  if (mcp.status === "configured") return "ok";
+  if (mcp.status === "unavailable") return "muted";
+  return "warning";
+}
+
+export function summarizeProcessDiagnostics(diagnostics: OmpProcessDiagnostics): string {
+  if (diagnostics.status === "unavailable") return "No hub run directory found";
+  if (diagnostics.status === "unknown") return "Unknown (could not read the hub run directory)";
+  const count = diagnostics.trackedCount ?? 0;
+  if (diagnostics.status === "partial") return `${count} tracked (partial: some inaccessible)`;
+  return `${count} tracked`;
+}
+
+export function processTone(diagnostics: OmpProcessDiagnostics): ProviderHealthTone {
+  if (diagnostics.status === "unknown") return "warning";
+  if (diagnostics.status === "partial") return "warning";
+  if (diagnostics.status === "unavailable") return "muted";
+  return diagnostics.trackedCount && diagnostics.trackedCount > 0 ? "ok" : "muted";
+}
+
+const PATH_STATE_LABELS: Record<PathState, string> = {
+  available: "Found",
+  missing: "Missing",
+  unreadable: "Unreadable",
+  invalid: "Invalid",
+  "wrong-type": "Wrong type on disk",
+};
+
+const PATH_STATE_TONES: Record<PathState, ProviderHealthTone> = {
+  available: "ok",
+  missing: "danger",
+  unreadable: "warning",
+  invalid: "warning",
+  "wrong-type": "warning",
+};
+
+export interface PathStateSummary {
+  label: string;
+  tone: ProviderHealthTone;
+}
+
+/** Never collapses unreadable/invalid/wrong-type into missing; each state gets its own label. */
+export function summarizePathState(state: PathState): PathStateSummary {
+  return { label: PATH_STATE_LABELS[state], tone: PATH_STATE_TONES[state] };
+}
+
+/**
+ * A null memory backend is ambiguous on its own: the config could be genuinely unset, or simply
+ * unavailable/invalid/wrong-type. Only a truly "available" config licenses "Not configured";
+ * every other state reports its own unavailability instead of guessing.
+ */
+export function summarizeMemoryBackend(health: OmpProviderHealth): string {
+  if (health.roots.configState !== "available") {
+    return `Unknown (config ${PATH_STATE_LABELS[health.roots.configState].toLowerCase()})`;
+  }
+  return health.memoryBackend ?? "Not configured";
+}
+
+export interface KnownOmpProviderSummary {
+  id: string;
+  label: string;
+  status: string;
+  enabled: boolean;
+}
+
+export interface ProviderStatusSummary {
+  label: string;
+  tone: ProviderHealthTone;
+}
+
+export function summarizeProviderStatus(
+  provider: Pick<KnownOmpProviderSummary, "enabled" | "status">,
+): ProviderStatusSummary {
+  if (!provider.enabled) return { label: "Disabled", tone: "muted" };
+  switch (provider.status) {
+    case "ready":
+      return { label: "Ready", tone: "ok" };
+    case "loading":
+      return { label: "Loading", tone: "warning" };
+    case "error":
+      return { label: "Error", tone: "danger" };
+    case "unavailable":
+      return { label: "Unavailable", tone: "danger" };
+    default:
+      return { label: "Unknown", tone: "muted" };
+  }
+}
+
+/** Narrows a full provider snapshot to the native and plugin OMP identities. */
+export function selectKnownOmpProviders(
+  entries: readonly PaseoProviderSnapshotResult["entries"][number][],
+): KnownOmpProviderSummary[] {
+  return entries.flatMap((entry) =>
+    OMP_PROVIDER_ID_SET.has(entry.provider)
+      ? [
+          {
+            id: entry.provider,
+            label: entry.label ?? entry.provider,
+            status: entry.status,
+            enabled: entry.enabled ?? true,
+          },
+        ]
+      : [],
+  );
+}

package/client/provider-icon.tsx

@@ -0,0 +1,27 @@
+import type { PluginButtonIconProps } from "@getpaseo/plugin/client";
+import { Icon } from "@getpaseo/plugin/client/react-native";
+import type { ComponentType } from "react";
+import { View } from "react-native";
+import { type QuotaSeverity, quotaProviderIconName } from "./quota-state";
+
+export function quotaProviderIcon(
+  provider: string | null,
+  severity: QuotaSeverity,
+): ComponentType<PluginButtonIconProps> {
+  function ProviderIcon({ size, color, theme }: PluginButtonIconProps) {
+    const severityColor =
+      severity === "danger"
+        ? theme.colors.statusDanger
+        : severity === "warning"
+          ? theme.colors.statusWarning
+          : severity === "ok"
+            ? theme.colors.statusSuccess
+            : color;
+    return (
+      <View style={{ width: size, height: size, alignItems: "center", justifyContent: "center" }}>
+        <Icon name={quotaProviderIconName(provider)} size={size} color={severityColor} />
+      </View>
+    );
+  }
+  return ProviderIcon;
+}

package/client/provider-image.tsx

@@ -0,0 +1,66 @@
+import type { PluginTimelineItemProps } from "@getpaseo/plugin/client";
+import { useMemo, useState } from "react";
+import { Image, Text, View } from "react-native";
+import { type OmpImageTimelineData, visibleOmpImageText } from "../shared/provider-image";
+
+export function OmpImageTimeline({ item, theme }: PluginTimelineItemProps<OmpImageTimelineData>) {
+  const styles = useMemo(
+    () => ({
+      root: { gap: 8 },
+      label: { color: theme.colors.foregroundMuted, fontSize: 12, fontWeight: "600" as const },
+      text: { color: theme.colors.foreground, fontSize: 13 },
+      image: {
+        width: "100%" as const,
+        minHeight: 220,
+        aspectRatio: 16 / 9,
+        borderRadius: 8,
+        backgroundColor: theme.colors.surface1,
+      },
+      imageFallback: {
+        alignItems: "center" as const,
+        justifyContent: "center" as const,
+        padding: 16,
+        borderWidth: 1,
+        borderColor: theme.colors.border,
+      },
+      imageFallbackText: {
+        color: theme.colors.foregroundMuted,
+        fontSize: 12,
+        textAlign: "center" as const,
+      },
+    }),
+    [theme],
+  );
+  const [failedImageIds, setFailedImageIds] = useState<ReadonlySet<string>>(() => new Set());
+  const visibleText = useMemo(() => visibleOmpImageText(item.data.text), [item.data.text]);
+  return (
+    <View style={styles.root}>
+      <Text style={styles.label}>{item.data.label}</Text>
+      {visibleText ? <Text style={styles.text}>{visibleText}</Text> : null}
+      {item.data.images.map((image, index) =>
+        failedImageIds.has(image.id) ? (
+          <View key={image.id} style={[styles.image, styles.imageFallback]}>
+            <Text style={styles.imageFallbackText}>
+              {image.mimeType.replace("image/", "").toUpperCase()} image could not be rendered on
+              this Paseo client.
+            </Text>
+          </View>
+        ) : (
+          <Image
+            key={image.id}
+            source={{ uri: `data:${image.mimeType};base64,${image.data}` }}
+            resizeMode="contain"
+            accessibilityLabel={`${item.data.label} image ${index + 1}`}
+            onError={() =>
+              setFailedImageIds((current) => {
+                if (current.has(image.id)) return current;
+                return new Set([...current, image.id]);
+              })
+            }
+            style={styles.image}
+          />
+        ),
+      )}
+    </View>
+  );
+}

package/client/quota-popover.tsx

@@ -0,0 +1,150 @@
+import { type PluginButtonContentProps, useAgent, useRpc } from "@getpaseo/plugin/client";
+import { Icon } from "@getpaseo/plugin/client/react-native";
+import { useQuery } from "@tanstack/react-query";
+import { useMemo } from "react";
+import { Text, View } from "react-native";
+import { listOmpQuotas } from "../shared/quota";
+import {
+  type QuotaProviderGroup,
+  quotaProviderFromSession,
+  quotaProviderGroups,
+  quotaProviderIconName,
+  quotaProviderLabel,
+  quotaResetLabel,
+  quotaSeverityFromFraction,
+} from "./quota-state";
+
+const QUOTA_POLL_MS = 30_000;
+
+export function QuotaPopover(props: PluginButtonContentProps) {
+  const { theme, layout } = props;
+  const agentId = props.context === "agent" ? props.agentId : "";
+  const session = useAgent(agentId, (agent) => ({ model: agent.model, provider: agent.provider }));
+  const currentProvider = quotaProviderFromSession(session?.provider ?? "", session?.model ?? null);
+  const loadQuotas = useRpc(listOmpQuotas);
+  const quotas = useQuery({
+    queryKey: ["paseo-omp", "quotas"],
+    queryFn: () => loadQuotas({}),
+    refetchInterval: QUOTA_POLL_MS,
+  });
+
+  function severityColor(severity: ReturnType<typeof quotaSeverityFromFraction>): string {
+    if (severity === "danger") return theme.colors.statusDanger;
+    if (severity === "warning") return theme.colors.statusWarning;
+    if (severity === "ok") return theme.colors.statusSuccess;
+    return theme.colors.foregroundMuted;
+  }
+
+  const styles = useMemo(
+    () => ({
+      root: { gap: layout.compact ? 8 : 10, minWidth: layout.compact ? undefined : 260 },
+      muted: { color: theme.colors.foregroundMuted, fontSize: 13 },
+      error: { color: theme.colors.statusDanger, fontSize: 13 },
+      group: (current: boolean) => ({
+        gap: 6,
+        padding: layout.compact ? 10 : 12,
+        borderRadius: 10,
+        borderWidth: current ? 2 : 1,
+        borderColor: current ? theme.colors.accent : theme.colors.border,
+        backgroundColor: theme.colors.surface1,
+      }),
+      groupHeader: { flexDirection: "row" as const, alignItems: "center" as const, gap: 6 },
+      groupLabel: {
+        color: theme.colors.foreground,
+        fontSize: 14,
+        fontWeight: "700" as const,
+        flex: 1,
+      },
+      badge: {
+        color: theme.colors.accentForeground,
+        backgroundColor: theme.colors.accent,
+        fontSize: 10,
+        fontWeight: "700" as const,
+        paddingHorizontal: 6,
+        paddingVertical: 2,
+        borderRadius: 999,
+        overflow: "hidden" as const,
+      },
+      row: { gap: 3 },
+      rowHeader: {
+        flexDirection: "row" as const,
+        justifyContent: "space-between" as const,
+        gap: 8,
+      },
+      rowLabel: { color: theme.colors.foreground, fontSize: 12, flex: 1 },
+      rowValue: { fontSize: 12, fontWeight: "600" as const },
+      track: {
+        height: 5,
+        borderRadius: 3,
+        backgroundColor: theme.colors.surface2,
+        overflow: "hidden" as const,
+      },
+      detail: { color: theme.colors.foregroundMuted, fontSize: 11 },
+    }),
+    [layout.compact, theme],
+  );
+
+  if (quotas.isLoading) return <Text style={styles.muted}>Loading omp quotas…</Text>;
+  if (quotas.error) return <Text style={styles.error}>Could not read omp quota state.</Text>;
+
+  const groups = quotaProviderGroups(quotas.data?.quotas ?? [], currentProvider);
+  const hasCurrent = groups.some((group) => group.provider === currentProvider);
+
+  if (groups.length === 0) {
+    return <Text style={styles.muted}>No provider quota data available.</Text>;
+  }
+
+  return (
+    <View style={styles.root}>
+      {currentProvider && !hasCurrent ? (
+        <Text style={styles.muted}>
+          {`No recorded quota yet for ${quotaProviderLabel(currentProvider)} (this session's provider).`}
+        </Text>
+      ) : null}
+      {groups.map((group: QuotaProviderGroup) => {
+        const current = group.provider === currentProvider;
+        return (
+          <View key={group.provider} style={styles.group(current)}>
+            <View style={styles.groupHeader}>
+              <Icon
+                name={quotaProviderIconName(group.provider)}
+                size={16}
+                color={severityColor(group.severity)}
+              />
+              <Text style={styles.groupLabel}>{quotaProviderLabel(group.provider)}</Text>
+              {current ? <Text style={styles.badge}>CURRENT</Text> : null}
+            </View>
+            {group.quotas.map((quota) => {
+              const severity = quotaSeverityFromFraction(quota.usedFraction);
+              const color = severityColor(severity);
+              const pct =
+                quota.usedFraction === null
+                  ? 0
+                  : Math.min(100, Math.round(quota.usedFraction * 100));
+              return (
+                <View key={`${quota.label}:${quota.windowLabel}`} style={styles.row}>
+                  <View style={styles.rowHeader}>
+                    <Text numberOfLines={1} style={styles.rowLabel}>
+                      {quota.label}
+                    </Text>
+                    <Text style={[styles.rowValue, { color }]}>
+                      {quota.usedFraction === null ? "Unknown" : `${pct}%`}
+                    </Text>
+                  </View>
+                  <View style={styles.track}>
+                    <View style={{ height: "100%", width: `${pct}%`, backgroundColor: color }} />
+                  </View>
+                  <Text style={styles.detail}>
+                    {[quota.windowLabel, quotaResetLabel(quota.resetsAt)]
+                      .filter(Boolean)
+                      .join(" · ")}
+                  </Text>
+                </View>
+              );
+            })}
+          </View>
+        );
+      })}
+    </View>
+  );
+}

package/client/quota-state.ts

@@ -0,0 +1,131 @@
+import type { OmpQuota } from "../shared/quota";
+
+const PROVIDER_LABELS: Record<string, string> = {
+  anthropic: "Anthropic",
+  cursor: "Cursor",
+  "google-antigravity": "Google",
+  "openai-codex": "OpenAI",
+};
+
+// Paseo's own provider brand icons (@getpaseo/protocol names such as "claude" or "omp") are
+// host-internal: passing one as a button `icon` string fails host validation, and rendering it
+// through `Icon` draws nothing. Plugin icons resolve Lucide names only, so each provider maps
+// to the Lucide vector closest to its mark.
+const PROVIDER_ICON_NAMES: Record<string, string> = {
+  anthropic: "Asterisk",
+  azure: "Cloud",
+  cursor: "MousePointer2",
+  "google-antigravity": "Gem",
+  openai: "Atom",
+  "openai-codex": "Atom",
+};
+
+export function quotaProviderIconName(provider: string | null): string {
+  return (provider ? PROVIDER_ICON_NAMES[provider] : undefined) ?? "Gauge";
+}
+
+export type QuotaSeverity = "ok" | "warning" | "danger" | "unknown";
+
+export function quotaSeverityFromFraction(fraction: number | null): QuotaSeverity {
+  if (fraction === null) return "unknown";
+  if (fraction >= 0.9) return "danger";
+  if (fraction >= 0.7) return "warning";
+  return "ok";
+}
+export function quotaProviderFromSession(
+  provider: string,
+  model: string | null = null,
+): string | null {
+  const [runtime, modelProvider] = provider.split("/");
+  if (runtime !== "omp") return null;
+  if (modelProvider) return modelProvider;
+  return model?.split("/")[0] ?? null;
+}
+
+export function quotaProviderLabel(provider: string | null): string {
+  return provider
+    ? (PROVIDER_LABELS[provider] ?? `${provider.slice(0, 1).toUpperCase()}${provider.slice(1)}`)
+    : "Provider";
+}
+
+export function quotasForProvider(
+  quotas: readonly OmpQuota[],
+  provider: string | null,
+): OmpQuota[] {
+  return provider ? quotas.filter((quota) => quota.provider === provider) : [];
+}
+
+export function quotaSummaryForProvider(
+  quotas: readonly OmpQuota[],
+  provider: string | null,
+): { visible: boolean; label: string } {
+  const matching = quotasForProvider(quotas, provider);
+  const used = matching.flatMap((quota) =>
+    quota.usedFraction === null ? [] : [quota.usedFraction],
+  );
+  if (used.length === 0) {
+    return provider
+      ? { visible: true, label: `${quotaProviderLabel(provider)} · —` }
+      : { visible: false, label: "Quota" };
+  }
+  const peak = Math.round(Math.max(...used) * 100);
+  return { visible: true, label: `${quotaProviderLabel(provider)} · ${peak}%` };
+}
+
+export function quotaSeverityForProvider(
+  quotas: readonly OmpQuota[],
+  provider: string | null,
+): QuotaSeverity {
+  const used = quotasForProvider(quotas, provider).flatMap((quota) =>
+    quota.usedFraction === null ? [] : [quota.usedFraction],
+  );
+  return used.length === 0 ? "unknown" : quotaSeverityFromFraction(Math.max(...used));
+}
+
+export type QuotaProviderGroup = {
+  provider: string;
+  quotas: OmpQuota[];
+  peakFraction: number | null;
+  severity: QuotaSeverity;
+};
+
+/** Groups every recorded provider (not just the active session's) so a popover can show the
+ * full comparison a user needs to decide which provider to switch to. The active session's
+ * provider always sorts first; the rest fall back to worst-quota-first. */
+export function quotaProviderGroups(
+  quotas: readonly OmpQuota[],
+  currentProvider: string | null,
+): QuotaProviderGroup[] {
+  const byProvider = new Map<string, OmpQuota[]>();
+  for (const quota of quotas) {
+    const group = byProvider.get(quota.provider);
+    if (group) group.push(quota);
+    else byProvider.set(quota.provider, [quota]);
+  }
+  const groups = [...byProvider.entries()].map(([provider, providerQuotas]) => {
+    const used = providerQuotas.flatMap((quota) =>
+      quota.usedFraction === null ? [] : [quota.usedFraction],
+    );
+    const peakFraction = used.length === 0 ? null : Math.max(...used);
+    return {
+      provider,
+      quotas: [...providerQuotas].sort((a, b) => (b.usedFraction ?? -1) - (a.usedFraction ?? -1)),
+      peakFraction,
+      severity: quotaSeverityFromFraction(peakFraction),
+    };
+  });
+  groups.sort((a, b) => {
+    if (a.provider === currentProvider) return -1;
+    if (b.provider === currentProvider) return 1;
+    return (b.peakFraction ?? -1) - (a.peakFraction ?? -1);
+  });
+  return groups;
+}
+
+export function quotaResetLabel(resetsAtMs: number | null, nowMs: number = Date.now()): string {
+  if (resetsAtMs === null) return "";
+  const remainingMs = Math.max(0, resetsAtMs - nowMs);
+  const hours = Math.floor(remainingMs / 3_600_000);
+  const minutes = Math.floor((remainingMs % 3_600_000) / 60_000);
+  return hours > 0 ? `resets ${hours}h ${minutes}m` : `resets ${minutes}m`;
+}