@omercnet/paseo-omp 0.3.0-next.104.1 → 0.3.0-next.106.1

package/client/omp-routing-editor.tsx

@@ -0,0 +1,307 @@
+import type { PluginSurfaceProps } from "@getpaseo/plugin/client";
+import { TextInput } from "@getpaseo/plugin/client/react-native";
+import { useState } from "react";
+import { Pressable, Text, View } from "react-native";
+import {
+  formatOmpSettingLabel,
+  isOmpStructuredSettingPath,
+  type OmpSetting,
+  parseOmpStructuredSettingValue,
+} from "../shared/omp-settings";
+import type { OmpConfigStyles } from "./omp-config-surface";
+import { OmpModelPicker } from "./omp-model-picker";
+import {
+  aliasChoices,
+  type OmpModelPickerModel,
+  updatePickerValue,
+} from "./omp-model-picker-state";
+
+type RoutingRecord = Record<string, unknown>;
+
+export type OmpModelCatalogState = {
+  models: readonly OmpModelPickerModel[];
+  loading: boolean;
+  error?: string;
+};
+
+type StructuredRoutingEditorProps = {
+  setting: OmpSetting;
+  value: unknown;
+  disabled: boolean;
+  resetLabel: string;
+  showReset: boolean;
+  resetPending: boolean;
+  styles: OmpConfigStyles;
+  theme: PluginSurfaceProps["theme"];
+  modelCatalog: OmpModelCatalogState;
+  modelRoles: Readonly<Record<string, unknown>>;
+  onSet(value: unknown): void;
+  onReset(): void;
+};
+
+function asRecord(value: unknown): RoutingRecord {
+  return value !== null && typeof value === "object" && !Array.isArray(value)
+    ? (value as RoutingRecord)
+    : {};
+}
+
+function asStringArray(value: unknown): string[] {
+  return Array.isArray(value) ? value.map((item) => (typeof item === "string" ? item : "")) : [];
+}
+
+function replaceRecordKey(record: RoutingRecord, oldKey: string, newKey: string): RoutingRecord {
+  const next: RoutingRecord = {};
+  for (const [key, value] of Object.entries(record)) next[key === oldKey ? newKey : key] = value;
+  return next;
+}
+
+function removeRecordKey(record: RoutingRecord, removedKey: string): RoutingRecord {
+  return Object.fromEntries(Object.entries(record).filter(([key]) => key !== removedKey));
+}
+
+function nextRecordKey(record: RoutingRecord, prefix: string): string {
+  let suffix = 1;
+  while (Object.hasOwn(record, `${prefix}${suffix}`)) suffix += 1;
+  return `${prefix}${suffix}`;
+}
+
+function RowButton({
+  label,
+  disabled,
+  styles,
+  onPress,
+}: {
+  label: string;
+  disabled: boolean;
+  styles: OmpConfigStyles;
+  onPress(): void;
+}) {
+  return (
+    <Pressable
+      accessibilityRole="button"
+      accessibilityLabel={label}
+      disabled={disabled}
+      onPress={onPress}
+      style={styles.editorAction}
+    >
+      <Text style={styles.editorActionText}>{label}</Text>
+    </Pressable>
+  );
+}
+
+function OrderedRoleEditor({
+  value,
+  disabled,
+  styles,
+  onSet,
+}: Pick<StructuredRoutingEditorProps, "value" | "disabled" | "styles" | "onSet">) {
+  const roles = asStringArray(value);
+  return (
+    <View style={styles.recordList}>
+      {roles.map((role, index) => (
+        // biome-ignore lint/suspicious/noArrayIndexKey: ordered rows are edited by position and must keep input identity while their value changes.
+        <View key={index} style={styles.recordRow}>
+          <Text style={styles.recordKey}>{index + 1}</Text>
+          <TextInput
+            accessibilityLabel={`Cycle role ${index + 1}`}
+            editable={!disabled}
+            value={role}
+            onChangeText={(nextRole) =>
+              onSet(roles.map((current, position) => (position === index ? nextRole : current)))
+            }
+            style={styles.scalarInput}
+          />
+          <RowButton
+            label={`Remove cycle role ${index + 1}`}
+            disabled={disabled}
+            styles={styles}
+            onPress={() => onSet(roles.filter((_, position) => position !== index))}
+          />
+        </View>
+      ))}
+      <RowButton
+        label="Add cycle role"
+        disabled={disabled}
+        styles={styles}
+        onPress={() => onSet([...roles, ""])}
+      />
+    </View>
+  );
+}
+
+function RecordRoutingEditor({
+  setting,
+  value,
+  disabled,
+  styles,
+  theme,
+  modelCatalog,
+  modelRoles,
+  onSet,
+}: Pick<
+  StructuredRoutingEditorProps,
+  "setting" | "value" | "disabled" | "styles" | "onSet" | "theme" | "modelCatalog" | "modelRoles"
+>) {
+  const record = asRecord(value);
+  const [keyErrors, setKeyErrors] = useState<Record<string, string>>({});
+  const entries = Object.entries(record);
+  const fallbackChains = setting.path === "retry.fallbackChains";
+  const agentModels = setting.path === "task.agentModelOverrides";
+  const keyLabel = setting.path.startsWith("task.")
+    ? "Agent"
+    : fallbackChains
+      ? "Role or model"
+      : "Role";
+  const valueLabel = fallbackChains
+    ? "Fallback selectors, comma separated"
+    : agentModels
+      ? "Model selectors, comma separated"
+      : setting.path === "task.agentServiceTierOverrides"
+        ? "Service tier"
+        : setting.path === "task.agentPrewalk" || setting.path === "task.agentAdvisor"
+          ? "on, off, or model selector"
+          : "Model selector";
+  const supportsModelPicker = setting.path !== "task.agentServiceTierOverrides";
+
+  return (
+    <View style={styles.recordList}>
+      {entries.map(([key, rawValue], index) => {
+        const textValue = Array.isArray(rawValue)
+          ? rawValue.filter((item): item is string => typeof item === "string").join(", ")
+          : typeof rawValue === "string"
+            ? rawValue
+            : "";
+        return (
+          // biome-ignore lint/suspicious/noArrayIndexKey: record keys are editable, so row position preserves input identity.
+          <View key={index} style={styles.recordRow}>
+            <TextInput
+              accessibilityLabel={`${formatOmpSettingLabel(setting.path)} ${keyLabel} ${index + 1}`}
+              editable={!disabled}
+              value={key}
+              onChangeText={(newKey) => {
+                if (newKey !== key && Object.hasOwn(record, newKey)) {
+                  setKeyErrors((current) => ({
+                    ...current,
+                    [key]: `Another entry already uses ${newKey}.`,
+                  }));
+                  return;
+                }
+                setKeyErrors((current) => {
+                  const next = { ...current };
+                  delete next[key];
+                  delete next[newKey];
+                  return next;
+                });
+                onSet(replaceRecordKey(record, key, newKey));
+              }}
+              style={styles.scalarInput}
+            />
+            {keyErrors[key] ? (
+              <Text accessibilityRole="alert" style={styles.error}>
+                {keyErrors[key]}
+              </Text>
+            ) : null}
+            <TextInput
+              accessibilityLabel={`${formatOmpSettingLabel(setting.path)} ${valueLabel} ${index + 1}`}
+              editable={!disabled}
+              value={textValue}
+              onChangeText={(newValue) => {
+                const next = { ...record };
+                if (fallbackChains || agentModels) {
+                  const selectors = newValue
+                    .split(",")
+                    .map((selector) => selector.trim())
+                    .filter(Boolean);
+                  next[key] = agentModels && selectors.length === 1 ? selectors[0] : selectors;
+                } else {
+                  next[key] = newValue;
+                }
+                onSet(next);
+              }}
+              style={styles.scalarInput}
+            />
+            {supportsModelPicker ? (
+              <OmpModelPicker
+                theme={theme}
+                models={modelCatalog.models}
+                aliases={
+                  setting.path === "modelRoles"
+                    ? []
+                    : aliasChoices(modelRoles, fallbackChains ? key : undefined)
+                }
+                role={
+                  setting.path === "task.agentAdvisor"
+                    ? "advisor"
+                    : setting.path === "task.agentPrewalk"
+                      ? ""
+                      : key.replace(/^@/u, "")
+                }
+                disabled={disabled}
+                loading={modelCatalog.loading}
+                error={modelCatalog.error}
+                onSelect={(selector) => {
+                  const next = { ...record };
+                  if (fallbackChains || agentModels) {
+                    next[key] = updatePickerValue(
+                      Array.isArray(rawValue)
+                        ? rawValue.filter((item): item is string => typeof item === "string")
+                        : typeof rawValue === "string"
+                          ? rawValue
+                          : [],
+                      selector,
+                      "append",
+                    );
+                  } else {
+                    next[key] = updatePickerValue(textValue, selector, "replace");
+                  }
+                  onSet(next);
+                }}
+              />
+            ) : null}
+            <RowButton
+              label={`Remove ${key || "routing entry"}`}
+              disabled={disabled}
+              styles={styles}
+              onPress={() => onSet(removeRecordKey(record, key))}
+            />
+          </View>
+        );
+      })}
+      <RowButton
+        label={`Add ${setting.path === "modelRoles" ? "model role" : fallbackChains ? "fallback chain" : "agent override"}`}
+        disabled={disabled}
+        styles={styles}
+        onPress={() => {
+          const key = nextRecordKey(record, setting.path.startsWith("task.") ? "agent" : "role");
+          onSet({ ...record, [key]: fallbackChains || agentModels ? [] : "" });
+        }}
+      />
+    </View>
+  );
+}
+
+export function StructuredRoutingEditor(props: StructuredRoutingEditorProps) {
+  if (!isOmpStructuredSettingPath(props.setting.path)) return null;
+  const parsed = parseOmpStructuredSettingValue(props.setting.path, props.value);
+  return (
+    <View style={props.styles.recordList}>
+      {props.resetPending ? (
+        <Text style={props.styles.muted}>{props.resetLabel} when changes are applied</Text>
+      ) : props.setting.path === "cycleOrder" ? (
+        <OrderedRoleEditor {...props} />
+      ) : (
+        <RecordRoutingEditor {...props} />
+      )}
+      {!props.resetPending && parsed === undefined ? (
+        <Text accessibilityRole="alert" style={props.styles.error}>
+          Complete every routing name and value before applying changes.
+        </Text>
+      ) : null}
+      {props.showReset ? (
+        <Pressable accessibilityRole="button" disabled={props.disabled} onPress={props.onReset}>
+          <Text style={props.styles.resetAction}>{props.resetLabel}</Text>
+        </Pressable>
+      ) : null}
+    </View>
+  );
+}

package/docs/configuration.md

@@ -1,6 +1,6 @@
 # Configuration
 
-Open the global **OMP** sidebar to browse and edit machine-wide state, or open the workspace **OMP** panel from the workspace tab or Explorer to manage project-scoped state. Scalar edits in the global surface use OMP's native `config set` and `config reset` commands. Workspace edits create validated overrides in `<workspace>/.omp/config.yml`; removing an override restores the effective global or default value. Arrays, records, and credentials remain read-only in both surfaces.
+Open the global **OMP** sidebar to browse and edit machine-wide state, or open the workspace **OMP** panel from the workspace tab or Explorer to manage project-scoped state. Scalar edits in the global surface use OMP's native `config set` and `config reset` commands. The same view provides bounded row editors for `modelRoles`, `retry.fallbackChains`, `cycleOrder`, `task.agentModelOverrides`, `task.agentServiceTierOverrides`, `task.agentPrewalk`, and `task.agentAdvisor` when OMP includes them in its native settings catalog. Workspace edits create validated overrides in `<workspace>/.omp/config.yml`; removing an override restores the effective global or default value. Other arrays and records, and all credentials, remain read-only.
 
 The **Plugin** tab documents the supported `omp-plugin` launch options, including names-only inherited environment configuration. Paseo's public plugin API does not expose the effective provider options for active launches, so the tab does not claim profile values are active. Choose **OMP Plugin** when creating an agent. Model, mode, thinking level, system prompt, persistence, MCP servers, workspace, and agent environment use Paseo's standard provider controls.
 

package/index.server.ts

@@ -6,6 +6,7 @@ import {
 } from "./server/mcp-browser";
 import { resolveListOmpMemory } from "./server/memory";
 import { resolveListOmpConfig } from "./server/omp-config";
+import { resolveListOmpModels } from "./server/omp-models";
 import {
   resolveInspectOmpPluginConfig,
   resolveListOmpPlugins,
@@ -29,6 +30,7 @@ import { listHubProcesses, tailHubLog } from "./shared/hub";
 import { openOmpMcpAuthorizationInPaseoBrowser } from "./shared/mcp";
 import { listOmpMemory } from "./shared/memory";
 import { listOmpConfig } from "./shared/omp-config";
+import { listOmpModels } from "./shared/omp-models";
 import {
   inspectOmpPluginConfig,
   listOmpPlugins,
@@ -59,6 +61,7 @@ export default function contribute(server: PluginServerContext) {
   server.handle(listOmpMemory, scoped(resolveListOmpMemory));
   server.handle(listOmpSessions, scoped(resolveListOmpSessions));
   server.handle(listOmpConfig, scoped(resolveListOmpConfig));
+  server.handle(listOmpModels, scoped(resolveListOmpModels));
   server.handle(listOmpPlugins, scoped(resolveListOmpPlugins));
   server.handle(inspectOmpPluginConfig, scoped(resolveInspectOmpPluginConfig));
   server.handle(mutateOmpPlugin, scoped(resolveMutateOmpPlugin));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@omercnet/paseo-omp",
-  "version": "0.3.0-next.104.1",
+  "version": "0.3.0-next.106.1",
   "type": "module",
   "description": "Paseo integration for OMP, including its direct provider and workspace tooling.",
   "license": "MIT",

package/server/omp-models.ts

@@ -0,0 +1,59 @@
+import { homedir } from "node:os";
+import { isAbsolute } from "node:path";
+import type { RpcInput } from "@getpaseo/plugin";
+import type { listOmpModels, OmpModelCandidate, OmpModelListResult } from "../shared/omp-models";
+import { currentOmpEnvironment } from "./paths";
+import {
+  type OmpModel,
+  OmpRpcRuntime,
+  type OmpRuntime,
+  type OmpRuntimeSession,
+} from "./provider/omp-rpc";
+import { OmpCleanupFailure, OmpPublicDataSerializer, OmpPublicError } from "./provider/security";
+
+function mapOmpModel(model: OmpModel, serializer: OmpPublicDataSerializer): OmpModelCandidate {
+  const provider = serializer.text(model.provider, 256);
+  const id = serializer.text(model.id, 256);
+  return {
+    selector: `${provider}/${id}`,
+    provider,
+    id,
+    ...(model.name !== undefined ? { name: serializer.text(model.name, 256) } : {}),
+    reasoning: model.reasoning === true,
+    input: (model.input ?? []).map((value) => serializer.text(value, 256)),
+    ...(model.contextWindow !== undefined ? { contextWindow: model.contextWindow } : {}),
+    thinkingLevels: (model.thinking?.efforts ?? []).map((value) => serializer.text(value, 32)),
+  };
+}
+
+async function closeModelCatalogSession(session: OmpRuntimeSession): Promise<void> {
+  const cleanup = session.close();
+  try {
+    await cleanup;
+  } catch {
+    throw new OmpCleanupFailure("OMP model catalog cleanup failed", cleanup);
+  }
+}
+
+export async function resolveListOmpModels(
+  input: RpcInput<typeof listOmpModels>,
+  runtime: OmpRuntime = new OmpRpcRuntime({ environment: currentOmpEnvironment() }),
+): Promise<OmpModelListResult> {
+  const cwd = input.cwd ?? homedir();
+  if (!isAbsolute(cwd) || cwd.includes("\0")) {
+    throw new OmpPublicError("The workspace path is invalid.");
+  }
+  const session = await runtime.startSession({
+    cwd,
+    environment: currentOmpEnvironment(),
+    noSession: true,
+  });
+  try {
+    const serializer = new OmpPublicDataSerializer();
+    return {
+      models: (await session.getAvailableModels()).map((model) => mapOmpModel(model, serializer)),
+    };
+  } finally {
+    await closeModelCatalogSession(session);
+  }
+}

package/server/omp-settings.ts

@@ -5,12 +5,13 @@ import { delimiter, dirname, isAbsolute, join } from "node:path";
 import type { RpcInput } from "@getpaseo/plugin";
 import { parseDocument, parse as parseYaml } from "yaml";
 import {
+  isOmpStructuredSettingPath,
   type listOmpSettings,
   OMP_SETTINGS_CATALOG_VERSION,
-  type OmpScalarValue,
   type OmpSetting,
   type OmpSettingType,
   OmpSettingTypeSchema,
+  parseOmpStructuredSettingValue,
   type updateOmpSettings,
 } from "../shared/omp-settings";
 import { SerialMutationQueue } from "./mutation-queue";
@@ -305,14 +306,28 @@ async function loadCatalog(
   }
 }
 
-function serializeScalar(type: OmpSettingType, value: OmpScalarValue): string | null {
-  if (type === "boolean") return typeof value === "boolean" ? String(value) : null;
-  if (type === "number")
+function serializeSettingValue(setting: OmpSetting, value: unknown): string | null {
+  if (isOmpStructuredSettingPath(setting.path)) {
+    const expectedType = setting.path === "cycleOrder" ? "array" : "record";
+    if (setting.type !== expectedType) return null;
+    const parsed = parseOmpStructuredSettingValue(setting.path, value);
+    return parsed === undefined ? null : JSON.stringify(parsed);
+  }
+  if (setting.type === "boolean") return typeof value === "boolean" ? String(value) : null;
+  if (setting.type === "number")
     return typeof value === "number" && Number.isFinite(value) ? String(value) : null;
-  if (type === "string" || type === "enum") return typeof value === "string" ? value : null;
+  if (setting.type === "string" || setting.type === "enum")
+    return typeof value === "string" ? value : null;
   return null;
 }
 
+function isEditableSetting(setting: OmpSetting): boolean {
+  if (setting.redacted) return false;
+  if (["boolean", "number", "string", "enum"].includes(setting.type)) return true;
+  if (!isOmpStructuredSettingPath(setting.path)) return false;
+  return setting.type === (setting.path === "cycleOrder" ? "array" : "record");
+}
+
 export async function listOmpSettingsWithDependencies(
   input: RpcInput<typeof listOmpSettings>,
   dependencies: OmpSettingsDependencies,
@@ -373,26 +388,22 @@ export async function updateOmpSettingsWithDependencies(
   if (input.cwd) {
     for (const change of input.changes) {
       const setting = byPath.get(change.path);
-      if (
-        !setting ||
-        setting.redacted ||
-        !["boolean", "number", "string", "enum"].includes(setting.type)
-      ) {
+      if (!setting || !isEditableSetting(setting)) {
         return {
           conflict: false,
           appliedPaths: [],
           failed: {
             path: change.path,
-            message: "This setting cannot be edited as a workspace scalar value.",
+            message: "This setting cannot be edited through the focused configuration editor.",
           },
           catalog: current,
         };
       }
-      if (change.operation === "set" && serializeScalar(setting.type, change.value) === null) {
+      if (change.operation === "set" && serializeSettingValue(setting, change.value) === null) {
         return {
           conflict: false,
           appliedPaths: [],
-          failed: { path: change.path, message: `Expected a ${setting.type} value.` },
+          failed: { path: change.path, message: `Invalid ${change.path} value.` },
           catalog: current,
         };
       }
@@ -440,15 +451,14 @@ export async function updateOmpSettingsWithDependencies(
   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)
-    ) {
+    if (!setting || !isEditableSetting(setting)) {
       return {
         conflict: false,
         appliedPaths,
-        failed: { path: change.path, message: "This setting cannot be edited as a scalar value." },
+        failed: {
+          path: change.path,
+          message: "This setting cannot be edited through the focused configuration editor.",
+        },
         catalog: await loadCatalog(executable, dependencies, input.cwd),
       };
     }
@@ -456,7 +466,7 @@ export async function updateOmpSettingsWithDependencies(
     if (change.operation === "reset") {
       args = ["reset", change.path];
     } else {
-      const value = serializeScalar(setting.type, change.value);
+      const value = serializeSettingValue(setting, change.value);
       args = value === null ? null : ["set", change.path, "--json", "--", value];
     }
     if (!args) {