@iislee/opencodex 2.11.0

package/src/providers/provider-id-rewrite.ts

@@ -0,0 +1,150 @@
+import type { OcxConfig } from "../types";
+
+export interface ProviderRewriteResult {
+  /** Number of references re-pointed. */
+  changed: number;
+  /**
+   * Sites where the destination key already held a value, left untouched. A
+   * non-empty list means the caller must not treat the rewrite as complete —
+   * merging two settings is not a decision this function can make. The function
+   * is NOT transactional: earlier sites are already rewritten by the time a
+   * collision is found, so a caller that receives collisions must discard the
+   * config it passed in.
+   */
+  collisions: string[];
+}
+
+/**
+ * Re-point every config reference from one provider id to another.
+ *
+ * Three shapes exist and the difference matters: routed model strings
+ * (`"<provider>/<model>"`), bare provider ids (`customModels[].provider`,
+ * `combos[*].targets[].provider`), and keys that ARE provider ids or routes
+ * (`providerContextCaps`, `claudeCode.desktopProfile.assignments`). A rewrite
+ * that handles only the first leaves an orphaned context cap and — worse — a
+ * combo target naming a provider that no longer exists, which fails validation
+ * in `src/combos/types.ts` and makes `loadConfig` discard the whole config.
+ *
+ * `providers[*].selectedModels` is deliberately NOT rewritten: those are
+ * per-provider native model ids, and upstream ids may themselves contain a
+ * slash, so a prefix rewrite could mangle an unrelated provider's allowlist. A
+ * caller that moves a provider row handles its own allowlist, where the
+ * destination catalog is known.
+ */
+export function rewriteProviderReferences(config: OcxConfig, from: string, to: string): ProviderRewriteResult {
+  const prefix = `${from}/`;
+  const collisions: string[] = [];
+  let changed = 0;
+
+  /** Routed string: rewrite only an exact `<from>/…` prefix, never a longer id. */
+  const route = (value: unknown): string | undefined => {
+    if (typeof value !== "string" || !value.startsWith(prefix)) return undefined;
+    changed += 1;
+    return `${to}/${value.slice(prefix.length)}`;
+  };
+
+  /**
+   * Rewrite a routed-string list in place. Assigning the result unconditionally
+   * would add an own property with value `undefined` where the field was absent,
+   * which breaks the no-op contract. The key type is an explicit union rather
+   * than `keyof OcxConfig`: the latter also admits `customModels` and friends, so
+   * `map` would infer a union array that is not assignable back.
+   */
+  type RoutedListKey = "disabledModels" | "subagentModels" | "subagentModelFallback";
+  const routeListAt = (key: RoutedListKey): void => {
+    const list = config[key];
+    if (!list) return;
+    config[key] = list.map(id => route(id) ?? id);
+  };
+
+  const routeRecordValues = (record: Record<string, string> | undefined): void => {
+    if (!record) return;
+    for (const [key, value] of Object.entries(record)) {
+      const next = route(value);
+      if (next) record[key] = next;
+    }
+  };
+
+  if (config.defaultProvider === from) {
+    config.defaultProvider = to;
+    changed += 1;
+  }
+
+  routeListAt("disabledModels");
+  routeListAt("subagentModels");
+  routeListAt("subagentModelFallback");
+
+  const scalarOwners: Array<[Record<string, unknown> | undefined, string]> = [
+    [config as unknown as Record<string, unknown>, "injectionModel"],
+    [config.shadowCallIntercept as Record<string, unknown> | undefined, "model"],
+    [config.webSearchSidecar as Record<string, unknown> | undefined, "model"],
+    [config.visionSidecar as Record<string, unknown> | undefined, "model"],
+    [config.claudeCode as unknown as Record<string, unknown> | undefined, "model"],
+    [config.claudeCode as unknown as Record<string, unknown> | undefined, "smallFastModel"],
+    [config.claudeCode?.webSearchSidecar as Record<string, unknown> | undefined, "model"],
+    [config.claudeCode?.visionSidecar as Record<string, unknown> | undefined, "model"],
+  ];
+  for (const [owner, key] of scalarOwners) {
+    if (!owner) continue;
+    const next = route(owner[key]);
+    if (next) owner[key] = next;
+  }
+
+  routeRecordValues(config.claudeCode?.tierModels as Record<string, string> | undefined);
+  routeRecordValues(config.claudeCode?.modelMap as Record<string, string> | undefined);
+
+  // Bare provider ids.
+  for (const model of config.customModels ?? []) {
+    if (model.provider === from) {
+      model.provider = to;
+      changed += 1;
+    }
+  }
+  for (const combo of Object.values(config.combos ?? {})) {
+    for (const target of combo.targets ?? []) {
+      if (target.provider === from) {
+        target.provider = to;
+        changed += 1;
+      }
+    }
+  }
+
+  // Keys. `providerContextCaps` is KEYED by provider id — a prefix rewrite would
+  // silently orphan the cap — and a destination key may already be occupied.
+  const caps = config.providerContextCaps;
+  if (caps && Object.hasOwn(caps, from)) {
+    if (Object.hasOwn(caps, to)) {
+      collisions.push(`providerContextCaps.${to}`);
+    } else {
+      caps[to] = caps[from]!;
+      delete caps[from];
+      changed += 1;
+    }
+  }
+
+  // `desktopProfile` is nested and asymmetric: `assignments` is KEYED by route
+  // while `defaults` holds routes as VALUES.
+  const profile = config.claudeCode?.desktopProfile;
+  if (profile) {
+    for (const key of Object.keys(profile.assignments ?? {})) {
+      const next = route(key);
+      if (!next) continue;
+      if (Object.hasOwn(profile.assignments, next)) {
+        changed -= 1; // `route` counted it; the move did not happen.
+        collisions.push(`claudeCode.desktopProfile.assignments.${next}`);
+        continue;
+      }
+      profile.assignments[next] = profile.assignments[key]!;
+      delete profile.assignments[key];
+    }
+    const defaults = profile.defaults as Record<string, string | null> | undefined;
+    if (defaults) {
+      for (const [family, value] of Object.entries(defaults)) {
+        const next = route(value);
+        if (next) defaults[family] = next;
+      }
+    }
+  }
+
+  return { changed, collisions };
+}