@omercnet/paseo-omp 0.2.1

package/server/omp-settings.ts

@@ -0,0 +1,291 @@
+import { createHash } from "node:crypto";
+import { delimiter, isAbsolute } from "node:path";
+import type { RpcInput } from "@getpaseo/plugin";
+import {
+  type listOmpSettings,
+  OMP_SETTINGS_CATALOG_VERSION,
+  type OmpScalarValue,
+  type OmpSetting,
+  type OmpSettingType,
+  OmpSettingTypeSchema,
+  type updateOmpSettings,
+} from "../shared/omp-settings";
+import { SerialMutationQueue } from "./mutation-queue";
+import { readOmpConfigFrom } from "./omp-config";
+import {
+  type BoundedRun,
+  buildStatefulCommandEnv,
+  defaultSpawn,
+  resolveExecutablePath,
+  runBounded,
+} from "./provider-diagnostics";
+
+const MAX_CONFIG_OUTPUT_BYTES = 2 * 1024 * 1024;
+const CONFIG_TIMEOUT_MS = 15_000;
+const KILL_GRACE_MS = 1_000;
+const WINDOWS_DEFAULT_PATHEXT = ".COM;.EXE;.BAT;.CMD";
+const CREDENTIAL_KEY =
+  /(?:^|_)(?:API_KEY|ACCESS_KEY|ACCESS_TOKEN|AUTHORIZATION|COOKIE|CREDENTIAL|CREDENTIALS|OAUTH|PASSWORD|PRIVATE_KEY|REFRESH_TOKEN|SECRET|SESSION_TOKEN|TOKEN)(?:$|_)/u;
+
+type OmpSettingRecord = {
+  value?: unknown;
+  redacted?: unknown;
+  type?: unknown;
+  description?: unknown;
+};
+
+export type ParsedOmpSettings = { settings: OmpSetting[]; droppedCount: number };
+type CatalogResult = {
+  catalogVersion: typeof OMP_SETTINGS_CATALOG_VERSION;
+  available: boolean;
+  revision?: string;
+  droppedCount: number;
+  settings: OmpSetting[];
+  path?: string;
+  error?: string;
+};
+
+export type OmpSettingsUpdateResult = {
+  conflict: boolean;
+  appliedPaths: string[];
+  failed?: { path: string; message: string };
+  catalog: CatalogResult;
+};
+
+export interface OmpSettingsDependencies {
+  resolveExecutable(): Promise<string | null>;
+  runConfig(executable: string, args: readonly string[]): Promise<BoundedRun>;
+}
+
+function isCredentialSetting(path: string, type: OmpSettingType): boolean {
+  if (type !== "string" && type !== "record") return false;
+  const normalized = path
+    .replace(/([a-z0-9])([A-Z])/gu, "$1_$2")
+    .replace(/[^A-Za-z0-9]+/gu, "_")
+    .toUpperCase();
+  return CREDENTIAL_KEY.test(normalized);
+}
+
+export function parseOmpSettingsList(raw: unknown): ParsedOmpSettings {
+  if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+    throw new Error("OMP returned an invalid settings document");
+  }
+
+  const settings: OmpSetting[] = [];
+  let droppedCount = 0;
+  for (const [path, candidate] of Object.entries(raw)) {
+    if (candidate === null || typeof candidate !== "object" || Array.isArray(candidate)) {
+      droppedCount += 1;
+      continue;
+    }
+    const entry = candidate as OmpSettingRecord;
+    const parsedType = OmpSettingTypeSchema.safeParse(entry.type);
+    if (!parsedType.success) {
+      droppedCount += 1;
+      continue;
+    }
+
+    const redacted = entry.redacted === true || isCredentialSetting(path, parsedType.data);
+    const configured = redacted && entry.redacted !== true ? entry.value !== undefined : undefined;
+    settings.push({
+      path,
+      type: parsedType.data,
+      description: typeof entry.description === "string" ? entry.description : "",
+      ...(redacted
+        ? { redacted: true, ...(configured === undefined ? {} : { configured }) }
+        : { value: entry.value }),
+    });
+  }
+  return { settings, droppedCount };
+}
+
+async function resolveOmpExecutable(): Promise<string | null> {
+  return resolveExecutablePath(
+    process.env.OMP_COMMAND ?? "omp",
+    (process.env.PATH ?? "").split(delimiter),
+    {
+      cwd: process.cwd(),
+      platform: process.platform,
+      pathExt: process.env.PATHEXT ?? WINDOWS_DEFAULT_PATHEXT,
+    },
+  );
+}
+
+async function runOmpConfig(executable: string, args: readonly string[]) {
+  return runBounded(
+    defaultSpawn,
+    executable,
+    ["config", ...args],
+    buildStatefulCommandEnv(process.env),
+    CONFIG_TIMEOUT_MS,
+    KILL_GRACE_MS,
+    MAX_CONFIG_OUTPUT_BYTES,
+    process.cwd(),
+  );
+}
+
+const DEFAULT_DEPENDENCIES: OmpSettingsDependencies = {
+  resolveExecutable: resolveOmpExecutable,
+  runConfig: runOmpConfig,
+};
+
+async function loadCatalog(
+  executable: string | null | undefined,
+  dependencies: OmpSettingsDependencies,
+): Promise<CatalogResult> {
+  const resolved = executable === undefined ? await dependencies.resolveExecutable() : executable;
+  if (!resolved) {
+    return {
+      catalogVersion: OMP_SETTINGS_CATALOG_VERSION,
+      available: false,
+      droppedCount: 0,
+      settings: [],
+      error: "The OMP executable could not be resolved.",
+    };
+  }
+
+  const result = await dependencies.runConfig(resolved, ["list", "--json"]);
+  if (result.outcome !== "exited" || result.exitCode !== 0 || result.truncated) {
+    return {
+      catalogVersion: OMP_SETTINGS_CATALOG_VERSION,
+      available: false,
+      droppedCount: 0,
+      settings: [],
+      error:
+        result.outcome === "timeout"
+          ? "OMP settings discovery timed out."
+          : "OMP settings discovery failed.",
+    };
+  }
+
+  let path: string | undefined;
+  const pathResult = await dependencies.runConfig(resolved, ["path"]);
+  const agentDir =
+    pathResult.outcome === "exited" && pathResult.exitCode === 0 ? pathResult.stdout.trim() : "";
+  if (agentDir && isAbsolute(agentDir) && !agentDir.includes("\0")) {
+    path = (await readOmpConfigFrom(agentDir)).path;
+  }
+
+  try {
+    const parsed: unknown = JSON.parse(result.stdout);
+    const catalog = parseOmpSettingsList(parsed);
+    return {
+      catalogVersion: OMP_SETTINGS_CATALOG_VERSION,
+      available: true,
+      revision: createHash("sha256").update(result.stdout).digest("hex"),
+      droppedCount: catalog.droppedCount,
+      ...(path ? { path } : {}),
+      settings: catalog.settings,
+    };
+  } catch {
+    return {
+      catalogVersion: OMP_SETTINGS_CATALOG_VERSION,
+      available: false,
+      droppedCount: 0,
+      settings: [],
+      error: "OMP returned invalid settings metadata.",
+    };
+  }
+}
+
+function serializeScalar(type: OmpSettingType, value: OmpScalarValue): string | null {
+  if (type === "boolean") return typeof value === "boolean" ? String(value) : null;
+  if (type === "number")
+    return typeof value === "number" && Number.isFinite(value) ? String(value) : null;
+  if (type === "string" || type === "enum") return typeof value === "string" ? value : null;
+  return null;
+}
+
+export async function listOmpSettingsWithDependencies(
+  _input: RpcInput<typeof listOmpSettings>,
+  dependencies: OmpSettingsDependencies,
+): Promise<CatalogResult> {
+  return loadCatalog(undefined, dependencies);
+}
+
+export async function resolveListOmpSettings(
+  input: RpcInput<typeof listOmpSettings>,
+): Promise<CatalogResult> {
+  return listOmpSettingsWithDependencies(input, DEFAULT_DEPENDENCIES);
+}
+
+export async function updateOmpSettingsWithDependencies(
+  input: RpcInput<typeof updateOmpSettings>,
+  dependencies: OmpSettingsDependencies,
+): Promise<OmpSettingsUpdateResult> {
+  const executable = await dependencies.resolveExecutable();
+  const current = await loadCatalog(executable, dependencies);
+  if (!executable || !current.available || !current.revision) {
+    return {
+      conflict: false,
+      appliedPaths: [],
+      failed: {
+        path: input.changes[0]?.path ?? "configuration",
+        message: current.error ?? "OMP settings are unavailable.",
+      },
+      catalog: current,
+    };
+  }
+  if (current.revision !== input.revision) {
+    return { conflict: true, appliedPaths: [], catalog: current };
+  }
+
+  const byPath = new Map(current.settings.map((setting) => [setting.path, setting]));
+  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)
+    ) {
+      return {
+        conflict: false,
+        appliedPaths,
+        failed: { path: change.path, message: "This setting cannot be edited as a scalar value." },
+        catalog: await loadCatalog(executable, dependencies),
+      };
+    }
+    let args: string[] | null;
+    if (change.operation === "reset") {
+      args = ["reset", change.path];
+    } else {
+      const value = serializeScalar(setting.type, change.value);
+      args = value === null ? null : ["set", change.path, "--json", "--", value];
+    }
+    if (!args) {
+      return {
+        conflict: false,
+        appliedPaths,
+        failed: { path: change.path, message: `Expected a ${setting.type} value.` },
+        catalog: appliedPaths.length ? await loadCatalog(executable, dependencies) : current,
+      };
+    }
+    const result = await dependencies.runConfig(executable, args);
+    if (result.outcome !== "exited" || result.exitCode !== 0) {
+      return {
+        conflict: false,
+        appliedPaths,
+        failed: { path: change.path, message: "OMP rejected this setting change." },
+        catalog: await loadCatalog(executable, dependencies),
+      };
+    }
+    appliedPaths.push(change.path);
+  }
+
+  return {
+    conflict: false,
+    appliedPaths,
+    catalog: await loadCatalog(executable, dependencies),
+  };
+}
+
+const settingsMutationQueue = new SerialMutationQueue();
+
+export function resolveUpdateOmpSettings(
+  input: RpcInput<typeof updateOmpSettings>,
+): Promise<OmpSettingsUpdateResult> {
+  return settingsMutationQueue.run(() =>
+    updateOmpSettingsWithDependencies(input, DEFAULT_DEPENDENCIES),
+  );
+}

package/server/paths.ts

@@ -0,0 +1,64 @@
+import { closeSync, constants, fstatSync, openSync, readSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+
+const MAX_SETTINGS_BYTES = 64 * 1024;
+
+/** Root of omp's per-machine agent state (`agent.db`, `history.db`, `memories/`). */
+export function ompAgentDir(environment: NodeJS.ProcessEnv = process.env): string {
+  const home = environment.HOME ?? environment.USERPROFILE ?? homedir();
+  return (
+    environment.PASEO_OMP_AGENT_DIR ??
+    environment.OMP_AGENT_DIR ??
+    environment.PI_CODING_AGENT_DIR ??
+    join(home, environment.PI_CONFIG_DIR ?? ".omp", "agent")
+  );
+}
+
+function configuredSessionDir(agentDir: string): string | undefined {
+  for (const settingsPath of [
+    join(agentDir, "settings.json"),
+    join(agentDir, "..", "settings.json"),
+  ]) {
+    let descriptor: number;
+    try {
+      descriptor = openSync(
+        settingsPath,
+        constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0) | (constants.O_NONBLOCK ?? 0),
+      );
+    } catch {
+      continue;
+    }
+    try {
+      const stat = fstatSync(descriptor);
+      if (!stat.isFile() || stat.size > MAX_SETTINGS_BYTES) continue;
+      const buffer = Buffer.allocUnsafe(stat.size);
+      const length = readSync(descriptor, buffer, 0, buffer.length, 0);
+      const parsed: unknown = JSON.parse(
+        new TextDecoder("utf-8", { fatal: true }).decode(buffer.subarray(0, length)),
+      );
+      if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) continue;
+      const value = (parsed as Record<string, unknown>).sessionDir;
+      if (
+        typeof value !== "string" ||
+        !value ||
+        value.includes("\0") ||
+        Buffer.byteLength(value) > 4_096
+      )
+        continue;
+      return isAbsolute(value) ? value : resolve(dirname(settingsPath), value);
+    } catch {
+    } finally {
+      closeSync(descriptor);
+    }
+  }
+  return;
+}
+
+/** OMP's effective session root, honoring its documented environment and settings precedence. */
+export function ompSessionDir(environment: NodeJS.ProcessEnv = process.env): string {
+  const explicit = environment.OMP_SESSION_DIR ?? environment.PI_CODING_AGENT_SESSION_DIR;
+  if (explicit) return resolve(explicit);
+  const agentDir = ompAgentDir(environment);
+  return configuredSessionDir(agentDir) ?? join(agentDir, "sessions");
+}

package/server/provider/catalog.ts

@@ -0,0 +1,173 @@
+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: "Launches OMP with yolo approval mode so tools run without prompts.",
+    icon: "ShieldOff",
+    colorTier: "dangerous",
+    isUnattended: true,
+  },
+  {
+    id: "write",
+    label: "Write Approval",
+    description:
+      "Launches OMP with write approval mode; reads are free and writes require approval.",
+    icon: "ShieldAlert",
+    colorTier: "moderate",
+  },
+  {
+    id: "ask",
+    label: "Always Ask",
+    description: "Launches OMP with always-ask approval mode for write and exec 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 } : {}),
+  };
+}