@omercnet/paseo-omp 0.2.1-next.72.1

package/server/provider/catalog.ts

@@ -0,0 +1,172 @@
+import { createHash } from "node:crypto";
+import type {
+  ProviderCatalog,
+  ProviderMode,
+  ProviderModel,
+  ProviderThinkingOption,
+} from "@getpaseo/plugin/server/provider";
+import type { NormalizedOmpStartOptions } from "./config-normalization";
+import type { OmpModel, OmpRuntime, OmpRuntimeSession } from "./omp-rpc";
+import {
+  configuredOutputRedactionValues,
+  OmpCleanupFailure,
+  OmpPublicDataSerializer,
+  OmpPublicError,
+} from "./security";
+
+export const OMP_MODES: readonly ProviderMode[] = [
+  {
+    id: "full",
+    label: "Full Access",
+    description: "Runs all tools without approval prompts.",
+    icon: "ShieldOff",
+    colorTier: "dangerous",
+    isUnattended: true,
+  },
+  {
+    id: "write",
+    label: "Write Approval",
+    description: "Runs reads without approval; writes require approval.",
+    icon: "ShieldAlert",
+    colorTier: "moderate",
+  },
+  {
+    id: "ask",
+    label: "Always Ask",
+    description: "Requires approval for write and execution tools.",
+    icon: "ShieldCheck",
+    colorTier: "safe",
+  },
+];
+
+const THINKING_OPTIONS: readonly ProviderThinkingOption[] = [
+  { id: "off", label: "Off", description: "No extra reasoning" },
+  { id: "minimal", label: "Minimal", description: "Light reasoning" },
+  { id: "low", label: "Low", description: "Faster reasoning" },
+  { id: "medium", label: "Medium", description: "Balanced reasoning", isDefault: true },
+  { id: "high", label: "High", description: "Deeper reasoning" },
+  { id: "xhigh", label: "XHigh", description: "Extra-high reasoning" },
+  { id: "max", label: "Max", description: "Maximum reasoning" },
+];
+
+export function nativeOmpModelId(model: OmpModel): string {
+  if (model.provider.includes("/")) {
+    throw new OmpPublicError("OMP reported an invalid model provider");
+  }
+  return `${model.provider}/${model.id}`;
+}
+
+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[] {
+  const seenIds = new Map<string, string>();
+  return models.map((model) => {
+    const thinkingOptions = thinkingForModel(model);
+    const id = ompModelId(model);
+    const nativeIdentity = nativeOmpModelId(model);
+    const existing = seenIds.get(id);
+    if (existing !== undefined && existing !== nativeIdentity) {
+      throw new Error("OMP model identity collision");
+    }
+    if (existing !== undefined) throw new Error("OMP reported a duplicate model identity");
+    seenIds.set(id, nativeIdentity);
+    const provider = serializer.text(model.provider, 256);
+    const modelId = serializer.text(model.id, 256);
+    const name = model.name ? serializer.text(model.name, 256) : modelId;
+    return {
+      id,
+      label: `${provider}/${name}`,
+      description: `${provider}/${modelId}`,
+      ...(typeof model.contextWindow === "number"
+        ? { contextWindowMaxTokens: model.contextWindow }
+        : {}),
+      ...(thinkingOptions.length > 0
+        ? {
+            thinkingOptions,
+            defaultThinkingOptionId:
+              thinkingOptions.find((option) => option.isDefault)?.id ?? thinkingOptions[0]?.id,
+          }
+        : {}),
+      metadata: { provider, modelId },
+    };
+  });
+}
+
+export function thinkingForModel(model: OmpModel | null | undefined): ProviderThinkingOption[] {
+  if (!model?.reasoning) return [];
+  const efforts = model.thinking?.efforts ?? [];
+  const supported = THINKING_OPTIONS.filter((option) => efforts.includes(option.id));
+  const defaultLevel = model.thinking?.defaultLevel;
+  const selectedDefault = supported.some((option) => option.id === defaultLevel)
+    ? defaultLevel
+    : supported[0]?.id;
+  return supported.map((option) => ({ ...option, isDefault: option.id === selectedDefault }));
+}
+
+async function closeCatalogSession(session: OmpRuntimeSession): Promise<void> {
+  const cleanup = session.close();
+  try {
+    await cleanup;
+  } catch {
+    throw new OmpCleanupFailure("OMP catalog cleanup failed", cleanup);
+  }
+}
+
+export async function discoverOmpCatalog(
+  runtime: OmpRuntime,
+  options: NormalizedOmpStartOptions,
+  signal?: AbortSignal,
+  environment?: NodeJS.ProcessEnv,
+): Promise<ProviderCatalog> {
+  const session = await runtime.startSession({
+    ...options,
+    signal,
+    environment,
+  });
+  try {
+    const [nativeModels, state] = await Promise.all([
+      session.getAvailableModels(),
+      session.getState(),
+    ]);
+    const configuredValues = configuredOutputRedactionValues(
+      options.outputRedaction ?? "none",
+      options.env,
+    );
+    const serializer = new OmpPublicDataSerializer(
+      options.outputRedaction === "configured-values"
+        ? [...configuredValues, ...(session.inheritedRedactionValues ?? [])]
+        : configuredValues,
+    );
+    const models = mapOmpModels(nativeModels, 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(
+          (model) => model.provider === state.model?.provider && model.id === state.model.id,
+        )
+      : nativeModels[0];
+    if (state.model && !currentModel) throw new Error("OMP reported an unadvertised active model");
+    const thinkingOptions = thinkingForModel(currentModel);
+    const defaultThinkingOption = thinkingOptions.some(
+      (option) => option.id === state.thinkingLevel,
+    )
+      ? state.thinkingLevel
+      : undefined;
+    return {
+      models,
+      modes: OMP_MODES,
+      thinkingOptions,
+      defaultModel,
+      defaultMode: "full",
+      ...(defaultThinkingOption ? { defaultThinkingOption } : {}),
+    };
+  } finally {
+    await closeCatalogSession(session);
+  }
+}

package/server/provider/config-normalization.ts

@@ -0,0 +1,148 @@
+import type { ProviderSessionConfig } from "@getpaseo/plugin/server/provider";
+import type { OmpStartOptions } from "./omp-rpc";
+
+type ProviderCatalogOptionsCompat = {
+  scope: "global" | "workspace";
+  cwd?: string;
+  force?: boolean;
+  providerOptions?: Readonly<Record<string, unknown>>;
+  settings?: Readonly<Record<string, unknown>>;
+};
+
+import { parseOmpProviderOptions } from "./provider-options";
+import { OmpPublicError } from "./security";
+import { OmpModeSchema } from "./settings";
+
+const OMP_BUILTIN_TOOL_NAMES = [
+  "read",
+  "bash",
+  "edit",
+  "ast_grep",
+  "ast_edit",
+  "ask",
+  "debug",
+  "eval",
+  "github",
+  "glob",
+  "grep",
+  "lsp",
+  "checkpoint",
+  "rewind",
+  "security_scan",
+  "task",
+  "hub",
+  "todo",
+  "web_search",
+  "write",
+  "memory_edit",
+  "retain",
+  "recall",
+  "reflect",
+  "learn",
+  "manage_skill",
+] as const;
+const OMP_BUILTIN_TOOL_NAME_SET: Readonly<Record<string, true>> = Object.fromEntries(
+  OMP_BUILTIN_TOOL_NAMES.map((name) => [name, true]),
+);
+
+function allowedOmpTools(deniedTools: readonly string[] | undefined): string[] | undefined {
+  if (!deniedTools?.length) return;
+  const denied = new Set(deniedTools.map((name) => name.trim().toLowerCase()));
+  const unsupported = [...denied].filter((name) => OMP_BUILTIN_TOOL_NAME_SET[name] !== true);
+  if (unsupported.length > 0) {
+    throw new OmpPublicError(
+      `OMP cannot enforce unknown denied tools: ${unsupported.sort().join(", ")}`,
+    );
+  }
+  return OMP_BUILTIN_TOOL_NAMES.filter((name) => !denied.has(name));
+}
+
+export type NormalizedOmpStartOptions = Omit<OmpStartOptions, "environment" | "signal">;
+export type OmpRecoveryOptions = Omit<OmpStartOptions, "resumeSessionId" | "signal">;
+export function normalizeOmpCatalogOptions(
+  options: ProviderCatalogOptionsCompat,
+  cwd: string,
+): Omit<OmpStartOptions, "environment" | "signal"> {
+  const providerOptions = parseOmpProviderOptions(options.providerOptions);
+  const params = providerOptions.params ?? {};
+  return {
+    cwd,
+    mode: "full",
+    noSession: true,
+    ...(providerOptions.command ? { command: providerOptions.command } : {}),
+    ...(providerOptions.env ? { env: providerOptions.env } : {}),
+    ...(providerOptions.inheritEnv ? { inheritEnv: providerOptions.inheritEnv } : {}),
+    outputRedaction: providerOptions.outputRedaction,
+    ...(params.sessionDir ? { sessionDir: params.sessionDir } : {}),
+    ...(params.rpcTimeoutMs
+      ? { readyTimeoutMs: params.rpcTimeoutMs, requestTimeoutMs: params.rpcTimeoutMs }
+      : {}),
+    ...((params.smolModel || params.slowModel || params.planModel) && {
+      roleModels: {
+        ...(params.smolModel ? { smol: params.smolModel } : {}),
+        ...(params.slowModel ? { slow: params.slowModel } : {}),
+        ...(params.planModel ? { plan: params.planModel } : {}),
+      },
+    }),
+  };
+}
+/** Replace only runtime-committed selection fields on an immutable recovery template. */
+export function withCommittedOmpSelection(
+  template: OmpRecoveryOptions,
+  selection: Readonly<{ model?: string; thinkingOption?: string }>,
+): OmpRecoveryOptions {
+  const next = { ...template };
+  if (selection.model === undefined) delete next.model;
+  else next.model = selection.model;
+  if (selection.thinkingOption === undefined) delete next.thinkingOption;
+  else next.thinkingOption = selection.thinkingOption;
+  return next;
+}
+
+/** Convert the public plugin session envelope into the native OMP launch contract. */
+export function normalizeOmpSessionConfig(
+  config: ProviderSessionConfig,
+  permissionSupported = false,
+): NormalizedOmpStartOptions {
+  if (Object.keys(config.settings).length > 0) {
+    throw new OmpPublicError("OMP does not expose live provider settings");
+  }
+  const parsedMode = OmpModeSchema.safeParse(config.mode ?? "full");
+  if (!parsedMode.success) {
+    throw new OmpPublicError(`Unsupported OMP mode '${String(config.mode)}'`);
+  }
+  if (parsedMode.data !== "full" && !permissionSupported) {
+    throw new OmpPublicError(
+      `OMP mode '${parsedMode.data}' requires negotiated permission support`,
+    );
+  }
+  const options = parseOmpProviderOptions(config.providerOptions);
+  const deniedTools = (config as ProviderSessionConfig & { deniedTools?: readonly string[] })
+    .deniedTools;
+  const tools = allowedOmpTools(deniedTools);
+  const params = options.params ?? {};
+  const env = { ...options.env, ...config.env };
+  return {
+    cwd: config.cwd,
+    ...(options.command ? { command: options.command } : {}),
+    ...(Object.keys(env).length > 0 ? { env } : {}),
+    ...(options.inheritEnv ? { inheritEnv: options.inheritEnv } : {}),
+    outputRedaction: options.outputRedaction,
+    mode: parsedMode.data,
+    thinkingOption: config.thinkingOption,
+    systemPrompt: config.systemPrompt,
+    noSession: !config.persist,
+    ...(params.sessionDir ? { sessionDir: params.sessionDir } : {}),
+    ...(params.rpcTimeoutMs
+      ? { readyTimeoutMs: params.rpcTimeoutMs, requestTimeoutMs: params.rpcTimeoutMs }
+      : {}),
+    ...((params.smolModel || params.slowModel || params.planModel) && {
+      roleModels: {
+        ...(params.smolModel ? { smol: params.smolModel } : {}),
+        ...(params.slowModel ? { slow: params.slowModel } : {}),
+        ...(params.planModel ? { plan: params.planModel } : {}),
+      },
+    }),
+    ...(tools ? { tools } : {}),
+  };
+}