import {  CODEX_REASONING_EFFORT_OPTIONS,  CURSOR_MODEL_FAMILY_OPTIONS,  CURSOR_REASONING_OPTIONS,  DEFAULT_MODEL_BY_PROVIDER,  DEFAULT_REASONING_EFFORT_BY_PROVIDER,  MODEL_OPTIONS_BY_PROVIDER,  MODEL_SLUG_ALIASES_BY_PROVIDER,  REASONING_EFFORT_OPTIONS_BY_PROVIDER,  type CodexReasoningEffort,  type CursorModelFamily,  type CursorModelSlug,  type CursorReasoningOption,  type ModelSlug,  type ProviderKind,} from "../../contracts/src"; type CursorModelCapability = {  readonly supportsReasoning: boolean;  readonly supportsFast: boolean;  readonly supportsThinking: boolean;  readonly defaultReasoning: CursorReasoningOption;  readonly defaultThinking: boolean;}; const CURSOR_MODEL_CAPABILITY_BY_FAMILY: Record<CursorModelFamily, CursorModelCapability> = {  auto: {    supportsReasoning: false,    supportsFast: false,    supportsThinking: false,    defaultReasoning: "normal",    defaultThinking: false,  },  "composer-1.5": {    supportsReasoning: false,    supportsFast: false,    supportsThinking: false,    defaultReasoning: "normal",    defaultThinking: false,  },  "composer-1": {    supportsReasoning: false,    supportsFast: false,    supportsThinking: false,    defaultReasoning: "normal",    defaultThinking: false,  },  "gpt-5.3-codex": {    supportsReasoning: true,    supportsFast: true,    supportsThinking: false,    defaultReasoning: "normal",    defaultThinking: false,  },  "gpt-5.3-codex-spark-preview": {    supportsReasoning: false,    supportsFast: false,    supportsThinking: false,    defaultReasoning: "normal",    defaultThinking: false,  },  "opus-4.6": {    supportsReasoning: false,    supportsFast: false,    supportsThinking: true,    defaultReasoning: "normal",    defaultThinking: true,  },  "opus-4.5": {    supportsReasoning: false,    supportsFast: false,    supportsThinking: true,    defaultReasoning: "normal",    defaultThinking: true,  },  "sonnet-4.6": {    supportsReasoning: false,    supportsFast: false,    supportsThinking: true,    defaultReasoning: "normal",    defaultThinking: true,  },  "gemini-3.1-pro": {    supportsReasoning: false,    supportsFast: false,    supportsThinking: false,    defaultReasoning: "normal",    defaultThinking: false,  },}; const MODEL_SLUG_SET_BY_PROVIDER: Record<ProviderKind, ReadonlySet<ModelSlug>> = {  claudeCode: new Set(MODEL_OPTIONS_BY_PROVIDER.claudeCode.map((option) => option.slug)),  codex: new Set(MODEL_OPTIONS_BY_PROVIDER.codex.map((option) => option.slug)),  cursor: new Set(MODEL_OPTIONS_BY_PROVIDER.cursor.map((option) => option.slug)),}; const CURSOR_MODEL_FAMILY_SET = new Set<CursorModelFamily>(  CURSOR_MODEL_FAMILY_OPTIONS.map((option) => option.slug),); export interface CursorModelSelection {  readonly family: CursorModelFamily;  readonly reasoning: CursorReasoningOption;  readonly fast: boolean;  readonly thinking: boolean;} export function getModelOptions(provider: ProviderKind = "codex") {  return MODEL_OPTIONS_BY_PROVIDER[provider];} export function getCursorModelFamilyOptions() {  return CURSOR_MODEL_FAMILY_OPTIONS;} export function getCursorModelCapabilities(family: CursorModelFamily) {  return CURSOR_MODEL_CAPABILITY_BY_FAMILY[family];} function fallbackCursorModelFamily(): CursorModelFamily {  const fallback = parseCursorModelSelection(DEFAULT_MODEL_BY_PROVIDER.cursor);  return fallback.family;} function resolveCursorModelFamily(model: string | null | undefined): CursorModelFamily {  const normalized = normalizeModelSlug(model, "cursor");  if (!normalized) {    return fallbackCursorModelFamily();  }   if (    normalized === "gpt-5.3-codex" ||    normalized === "gpt-5.3-codex-fast" ||    normalized === "gpt-5.3-codex-low" ||    normalized === "gpt-5.3-codex-low-fast" ||    normalized === "gpt-5.3-codex-high" ||    normalized === "gpt-5.3-codex-high-fast" ||    normalized === "gpt-5.3-codex-xhigh" ||    normalized === "gpt-5.3-codex-xhigh-fast"  ) {    return "gpt-5.3-codex";  }   if (normalized === "sonnet-4.6-thinking") {    return "sonnet-4.6";  }  if (normalized === "opus-4.6-thinking") {    return "opus-4.6";  }  if (normalized === "opus-4.5-thinking") {    return "opus-4.5";  }   return CURSOR_MODEL_FAMILY_SET.has(normalized as CursorModelFamily)    ? (normalized as CursorModelFamily)    : fallbackCursorModelFamily();} function resolveCursorReasoning(model: CursorModelSlug): CursorReasoningOption {  if (model.includes("-xhigh")) return "xhigh";  if (model.includes("-high")) return "high";  if (model.includes("-low")) return "low";  return "normal";} export function parseCursorModelSelection(model: string | null | undefined): CursorModelSelection {  const family = resolveCursorModelFamily(model);  const capability = CURSOR_MODEL_CAPABILITY_BY_FAMILY[family];  const normalized = resolveModelSlugForProvider("cursor", model) as CursorModelSlug;   if (capability.supportsReasoning) {    return {      family,      reasoning: resolveCursorReasoning(normalized),      fast: normalized.endsWith("-fast"),      thinking: false,    };  }   if (capability.supportsThinking) {    return {      family,      reasoning: capability.defaultReasoning,      fast: false,      thinking: normalized.endsWith("-thinking"),    };  }   return {    family,    reasoning: capability.defaultReasoning,    fast: false,    thinking: capability.defaultThinking,  };} export function resolveCursorModelFromSelection(input: {  readonly family: CursorModelFamily;  readonly reasoning?: CursorReasoningOption | null;  readonly fast?: boolean;  readonly thinking?: boolean;}): CursorModelSlug {  const family = resolveCursorModelFamily(input.family);  const capability = CURSOR_MODEL_CAPABILITY_BY_FAMILY[family];   if (capability.supportsReasoning) {    const reasoning = CURSOR_REASONING_OPTIONS.includes(input.reasoning ?? "normal")      ? (input.reasoning ?? "normal")      : capability.defaultReasoning;    const reasoningSuffix = reasoning === "normal" ? "" : `-${reasoning}`;    const fastSuffix = input.fast ? "-fast" : "";    const candidate = `${family}${reasoningSuffix}${fastSuffix}`;    return resolveModelSlugForProvider("cursor", candidate) as CursorModelSlug;  }   if (capability.supportsThinking) {    const candidate = input.thinking ? `${family}-thinking` : family;    return resolveModelSlugForProvider("cursor", candidate) as CursorModelSlug;  }   return resolveModelSlugForProvider("cursor", family) as CursorModelSlug;} export function getDefaultModel(provider: ProviderKind = "codex"): ModelSlug {  return DEFAULT_MODEL_BY_PROVIDER[provider];} export function normalizeModelSlug(  model: string | null | undefined,  provider: ProviderKind = "codex",): ModelSlug | null {  if (typeof model !== "string") {    return null;  }   const trimmed = model.trim();  if (!trimmed) {    return null;  }   return MODEL_SLUG_ALIASES_BY_PROVIDER[provider][trimmed] ?? (trimmed as ModelSlug);} export function resolveModelSlug(  model: string | null | undefined,  provider: ProviderKind = "codex",): ModelSlug {  const normalized = normalizeModelSlug(model, provider);  if (!normalized) {    return DEFAULT_MODEL_BY_PROVIDER[provider];  }   return MODEL_SLUG_SET_BY_PROVIDER[provider].has(normalized)    ? normalized    : DEFAULT_MODEL_BY_PROVIDER[provider];} export function resolveModelSlugForProvider(  provider: ProviderKind,  model: string | null | undefined,): ModelSlug {  return resolveModelSlug(model, provider);} export function getReasoningEffortOptions(  provider: ProviderKind = "codex",): ReadonlyArray<CodexReasoningEffort> {  return REASONING_EFFORT_OPTIONS_BY_PROVIDER[provider];} export function getDefaultReasoningEffort(provider: "codex"): CodexReasoningEffort;export function getDefaultReasoningEffort(provider: ProviderKind): CodexReasoningEffort | null;export function getDefaultReasoningEffort(  provider: ProviderKind = "codex",): CodexReasoningEffort | null {  return DEFAULT_REASONING_EFFORT_BY_PROVIDER[provider];} export { CODEX_REASONING_EFFORT_OPTIONS };