Skip to content

Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.

15.9 KB
Raw Blame
import * as Option from "effect/Option";
import { storedField } from "../lib/persistedSchema";
import * as Predicate from "effect/Predicate";
import {
  DEFAULT_MODEL,
  DEFAULT_MODEL_BY_PROVIDER,
  defaultInstanceIdForDriver,
  ModelSelection,
  ProviderInstanceId,
  ProviderDriverKind,
  ProviderOptionSelection,
  type ServerProvider,
} from "@akeru/contracts";
import * as Schema from "effect/Schema";
import { DeepMutable } from "effect/Types";
import { createModelSelection, normalizeModelSlug } from "@akeru/shared/model";
import { resolveAppModelSelection, resolveAppModelSelectionForInstance } from "../modelSelection";
import { getDefaultServerModel } from "../providerModels";
import { UnifiedSettings } from "@akeru/contracts/settings";
import {
  type ProviderOptionSelectionsByProvider,
  type LegacyCodexFields,
} from "./draftPersistenceSchemas";
import { type ComposerThreadDraftState, type EffectiveComposerModelState } from "./draftTypes";

const isProviderDriverKind = Schema.is(ProviderDriverKind);

function providerSelectionsFromModelSelection(
  modelSelection: ModelSelection | null | undefined,
): ProviderOptionSelectionsByProvider | null {
  if (!modelSelection) {
    return null;
  }

  const options = modelSelection.options;

  if (!options || options.length === 0) {
    return null;
  }

  return { [modelSelection.instanceId]: options };
}

function modelSelectionByProviderToOptions(
  map: Partial<Record<string, ModelSelection>> | null | undefined,
): ProviderOptionSelectionsByProvider | null {
  if (!map) return null;
  const result: ProviderOptionSelectionsByProvider = {};

  for (const [provider, selection] of Object.entries(map)) {
    if (selection?.options && selection.options.length > 0) {
      result[provider] = selection.options;
    }
  }

  return Object.keys(result).length > 0 ? result : null;
}

function cloneModelSelection(selection: ModelSelection): DeepMutable<ModelSelection> {
  const { options, ...rest } = selection;

  return { ...rest, ...(options ? { options: options.map((option) => ({ ...option })) } : {}) };
}

export function compactModelSelectionByProvider(
  selections: Partial<Record<ProviderInstanceId, ModelSelection>>,
): DeepMutable<Record<ProviderInstanceId, ModelSelection>> {
  const result: DeepMutable<Record<ProviderInstanceId, ModelSelection>> = {};

  for (const [provider, selection] of Object.entries(selections)) {
    if (selection !== undefined)
      result[ProviderInstanceId.make(provider)] = cloneModelSelection(selection);
  }

  return result;
}

/** A field read from persisted composer state, before its schema guard runs. */
type StoredFieldValue = Schema.Json | undefined;

export function normalizeProviderDriverKind(value: StoredFieldValue): ProviderDriverKind | null {
  return isProviderDriverKind(value) ? value : null;
}

const isProviderInstanceId = Schema.is(ProviderInstanceId);

export function normalizeProviderInstanceId(value: StoredFieldValue): ProviderInstanceId | null {
  return isProviderInstanceId(value) ? value : null;
}

function isStoredRecord(value: Schema.Json | undefined): value is Schema.JsonObject {
  return Predicate.isObject(value);
}

/**
 * Coerce an unknown value into a `ReadonlyArray<ProviderOptionSelection>`.
 * Accepts either:
 *   - the v3 representation: an array of `{ id, value }` entries
 *   - the legacy v2 representation: a record of `{ id: string | boolean }`
 *
 * Validation is intentionally permissive: descriptors are the source of truth
 * for which option ids are meaningful for a given provider/model. Anything
 * outside the descriptor list is harmless trailing data and will simply be
 * ignored downstream.
 */
function coerceProviderOptionSelections(
  value: Schema.Json | undefined,
): ReadonlyArray<ProviderOptionSelection> | undefined {
  if (Array.isArray(value)) {
    const out: ProviderOptionSelection[] = [];

    for (const entry of value) {
      if (!isStoredRecord(entry)) continue;
      const record = entry;
      const id = record.id;
      const optionValue = record.value;

      if (!Predicate.isString(id) || id.length === 0) continue;

      if (Predicate.isString(optionValue) || Predicate.isBoolean(optionValue)) {
        out.push({ id, value: optionValue });
      }
    }

    return out.length > 0 ? out : undefined;
  }

  if (isStoredRecord(value)) {
    const record = value;
    const out: ProviderOptionSelection[] = [];

    for (const [id, raw] of Object.entries(record)) {
      if (Predicate.isString(raw) || Predicate.isBoolean(raw)) {
        out.push({ id, value: raw });
      }
    }

    return out.length > 0 ? out : undefined;
  }

  return undefined;
}

/**
 * Normalize a per-provider options bag from either the v3 or legacy v2 shape.
 *
 * `provider` and `legacy` parameters are migration-only inputs used to
 * recover legacy codex fields (effort/codexFastMode/serviceTier) that lived
 * directly on the draft instead of inside `modelOptions.codex`.
 */
const StoredProviderOptions = Schema.Struct({
  codex: storedField(Schema.NullOr(Schema.Json), null),
  claudeAgent: storedField(Schema.NullOr(Schema.Json), null),
  opencode: storedField(Schema.NullOr(Schema.Json), null),
});

const decodeStoredProviderOptions = Schema.decodeUnknownOption(StoredProviderOptions);

export function normalizeProviderModelOptions(
  value: StoredFieldValue | ProviderOptionSelectionsByProvider | null,
  provider?: ProviderDriverKind | null,
  legacy?: LegacyCodexFields,
): ProviderOptionSelectionsByProvider | null {
  const decoded = decodeStoredProviderOptions(value);
  const candidate = Option.isSome(decoded) ? decoded.value : null;

  const result: ProviderOptionSelectionsByProvider = {};

  for (const providerKey of ["codex", "claudeAgent", "opencode"] as const) {
    const selections = coerceProviderOptionSelections(candidate?.[providerKey]);

    if (selections) {
      result[providerKey] = selections;
    }
  }

  // Recover legacy codex fields that lived outside modelOptions.
  if (provider === "codex" && legacy) {
    const codexExtras: ProviderOptionSelection[] = [];

    if (Predicate.isString(legacy.effort) && legacy.effort.length > 0) {
      codexExtras.push({ id: "reasoningEffort", value: legacy.effort });
    }

    const fastMode =
      legacy.codexFastMode === true ||
      (Predicate.isString(legacy.serviceTier) && legacy.serviceTier === "fast");

    if (fastMode) {
      codexExtras.push({ id: "fastMode", value: true });
    }

    if (codexExtras.length > 0) {
      const existing = result.codex ?? [];
      const existingIds = new Set(existing.map((entry) => entry.id));
      const merged = [...existing];

      for (const extra of codexExtras) {
        if (!existingIds.has(extra.id)) merged.push(extra);
      }

      result.codex = merged;
    }
  }

  return Object.keys(result).length > 0 ? result : null;
}

// Returns a model selection whose `instanceId` is a valid
// `ProviderInstanceId` slug. Legacy `provider` fields are promoted verbatim
// because default instance ids used the same slug as the driver kind.
//
// Selections whose instance id doesn't match the slug pattern collapse to
// `null` — caller is responsible for deciding whether that's a dropped
// write or a routed error.
const StoredModelSelection = Schema.Struct({
  instanceId: storedField(Schema.NullOr(Schema.Json), null),
  provider: storedField(Schema.NullOr(Schema.Json), null),
  model: storedField(Schema.NullOr(Schema.Json), null),
  options: storedField(Schema.NullOr(Schema.Json), null),
});

const decodeStoredModelSelection = Schema.decodeUnknownOption(StoredModelSelection);

export function normalizeModelSelection(
  value: StoredFieldValue | ModelSelection | null,
  legacy?: {
    provider?: StoredFieldValue;
    model?: StoredFieldValue;
    modelOptions?: StoredFieldValue | ProviderOptionSelectionsByProvider;
    legacyCodex?: LegacyCodexFields;
  },
): NormalizedModelSelection | null {
  const decoded = decodeStoredModelSelection(value);
  const candidate = Option.isSome(decoded) ? decoded.value : null;

  // Post-migration ModelSelection carries `instanceId`; pre-migration (v2
  // storage, legacy wire shapes) carries `provider`. Accept either so both
  // normalized stores and legacy drafts round-trip through this helper.
  const instanceId = normalizeProviderInstanceId(
    candidate?.instanceId ?? candidate?.provider ?? legacy?.provider,
  );

  if (instanceId === null) {
    return null;
  }

  const rawModel = candidate?.model ?? legacy?.model;

  if (!Predicate.isString(rawModel)) {
    return null;
  }

  // Slug normalization can use provider-kind-specific rules when a legacy
  // driver key is present. Instance-only selections are not reverse-inferred
  // into a driver kind here; they get generic default normalization.
  const driverKindHint =
    normalizeProviderDriverKind(candidate?.provider ?? legacy?.provider) ??
    ProviderDriverKind.make("codex");

  const model = normalizeModelSlug(rawModel, driverKindHint);

  if (!model) {
    return null;
  }

  if (Array.isArray(candidate?.options)) {
    const selections = coerceProviderOptionSelections(candidate.options);

    return createModelSelection(instanceId, model, selections);
  }

  // Per-kind options were a pre-migration concern; only recover them for a
  // built-in-kind instance. Custom instances don't have a legacy options
  // store to thread through here.
  const kindForLegacyOptions = normalizeProviderDriverKind(instanceId);

  const modelOptions = kindForLegacyOptions
    ? normalizeProviderModelOptions(
        candidate?.options ? { [kindForLegacyOptions]: candidate.options } : legacy?.modelOptions,
        kindForLegacyOptions,
        kindForLegacyOptions === "codex" ? legacy?.legacyCodex : undefined,
      )
    : null;

  const options = kindForLegacyOptions ? modelOptions?.[kindForLegacyOptions] : undefined;

  return createModelSelection(instanceId, model, options);
}

type NormalizedModelSelection = Omit<ModelSelection, "instanceId"> & {
  readonly instanceId: ProviderInstanceId;
};

// ── Legacy sync helpers (used only during migration from v2 storage) ──
//
// These operate against the legacy kind-keyed `modelOptions` map. The
// normalized selection now carries an open `ProviderInstanceId`; legacy
// migration only recovers options for keys that existed before custom
// provider instances.

export function legacySyncModelSelectionOptions(
  modelSelection: NormalizedModelSelection | null,
  modelOptions: ProviderOptionSelectionsByProvider | null | undefined,
): NormalizedModelSelection | null {
  if (modelSelection === null) {
    return null;
  }

  const kind = normalizeProviderDriverKind(modelSelection.instanceId);
  const options = kind ? modelOptions?.[kind] : undefined;

  return createModelSelection(modelSelection.instanceId, modelSelection.model, options);
}

export function legacyMergeModelSelectionIntoProviderModelOptions(
  modelSelection: NormalizedModelSelection | null,
  currentModelOptions: ProviderOptionSelectionsByProvider | null | undefined,
): ProviderOptionSelectionsByProvider | null {
  if (!modelSelection?.options || modelSelection.options.length === 0) {
    return normalizeProviderModelOptions(currentModelOptions);
  }

  const kind = normalizeProviderDriverKind(modelSelection.instanceId);

  if (!kind) {
    return normalizeProviderModelOptions(currentModelOptions);
  }

  return legacyReplaceProviderModelOptions(
    normalizeProviderModelOptions(currentModelOptions),
    kind,
    modelSelection.options,
  );
}

function legacyReplaceProviderModelOptions(
  currentModelOptions: ProviderOptionSelectionsByProvider | null | undefined,
  provider: ProviderDriverKind,
  nextProviderOptions: ReadonlyArray<ProviderOptionSelection> | null | undefined,
): ProviderOptionSelectionsByProvider | null {
  const { [provider]: _discardedProviderModelOptions, ...otherProviderModelOptions } =
    currentModelOptions ?? {};

  const merged: ProviderOptionSelectionsByProvider = { ...otherProviderModelOptions };

  if (nextProviderOptions && nextProviderOptions.length > 0) {
    merged[provider] = nextProviderOptions;
  }

  return Object.keys(merged).length > 0 ? merged : null;
}

// ── New helpers for the consolidated representation ────────────────────

export function legacyToModelSelectionByProvider(
  modelSelection: NormalizedModelSelection | null,
  modelOptions: ProviderOptionSelectionsByProvider | null | undefined,
): Partial<Record<ProviderInstanceId, ModelSelection>> {
  const result: Partial<Record<ProviderInstanceId, ModelSelection>> = {};

  if (modelOptions) {
    for (const provider of ["codex", "claudeAgent", "opencode"] as const) {
      const options = modelOptions[provider];

      if (options && options.length > 0) {
        const driverKind = ProviderDriverKind.make(provider);
        const instanceKey = defaultInstanceIdForDriver(driverKind);
        result[instanceKey] = createModelSelection(
          instanceKey,
          modelSelection?.instanceId === instanceKey
            ? modelSelection.model
            : (DEFAULT_MODEL_BY_PROVIDER[driverKind] ?? DEFAULT_MODEL),
          options,
        );
      }
    }
  }

  if (modelSelection) {
    result[modelSelection.instanceId] = modelSelection;
  }

  return result;
}

export function deriveEffectiveComposerModelState(input: {
  draft:
    | Pick<ComposerThreadDraftState, "modelSelectionByProvider" | "activeProvider">
    | null
    | undefined;
  providers: ReadonlyArray<ServerProvider>;
  selectedProvider: ProviderDriverKind;
  /**
   * Optional routing key of the instance whose selection should override
   * the driver-level lookup. When present, the draft is queried by
   * `modelSelectionByProvider[selectedInstanceId]` so a custom Codex
   * instance (e.g. `codex_personal`) reads its own saved model instead of
   * collapsing to the default Codex bucket.
   */
  selectedInstanceId?: ProviderInstanceId | null | undefined;
  threadModelSelection: ModelSelection | null | undefined;
  projectModelSelection: ModelSelection | null | undefined;
  settings: UnifiedSettings;
}): EffectiveComposerModelState {
  const baseModelCandidate =
    input.threadModelSelection?.model ?? input.projectModelSelection?.model ?? null;

  const baseModel =
    (input.selectedInstanceId
      ? resolveAppModelSelectionForInstance(
          input.selectedInstanceId,
          input.settings,
          input.providers,
          baseModelCandidate,
        )
      : null) ??
    resolveAppModelSelection(
      input.selectedProvider,
      input.settings,
      input.providers,
      baseModelCandidate,
    ) ??
    normalizeModelSlug(baseModelCandidate, input.selectedProvider) ??
    getDefaultServerModel(input.providers, input.selectedProvider);

  // Look up the instance's saved selection first; fall back to the
  // driver-kind bucket so legacy kind-keyed drafts still resolve. Every
  // `ProviderDriverKind` literal is a valid `ProviderInstanceId` slug, so the
  // cast to the branded type is safe.
  const instanceSelection = input.selectedInstanceId
    ? input.draft?.modelSelectionByProvider?.[input.selectedInstanceId]
    : undefined;

  const legacySelection =
    input.draft?.modelSelectionByProvider?.[ProviderInstanceId.make(input.selectedProvider)];

  const activeSelection = instanceSelection ?? legacySelection;

  const activeSelectionInstanceId = instanceSelection
    ? (input.selectedInstanceId ?? ProviderInstanceId.make(input.selectedProvider))
    : ProviderInstanceId.make(input.selectedProvider);

  const selectedModel = activeSelection?.model
    ? (resolveAppModelSelectionForInstance(
        activeSelectionInstanceId,
        input.settings,
        input.providers,
        activeSelection.model,
      ) ??
      resolveAppModelSelection(
        input.selectedProvider,
        input.settings,
        input.providers,
        activeSelection.model,
      ))
    : baseModel;

  const modelOptions =
    modelSelectionByProviderToOptions(input.draft?.modelSelectionByProvider) ??
    providerSelectionsFromModelSelection(input.threadModelSelection) ??
    providerSelectionsFromModelSelection(input.projectModelSelection) ??
    null;

  return {
    selectedModel,
    modelOptions,
  };
}