mumucc 0.4.2 → 0.4.3

package/src/utils/model/platformProfiles.ts

@@ -0,0 +1,524 @@
+import { existsSync, readFileSync } from 'fs'
+import { join } from 'path'
+import { DEFAULT_CODEX_BASE_URL, DEFAULT_OPENAI_BASE_URL, resolveCodexAuthPath } from 'src/services/api/openaiProviderConfig.js'
+import { getClaudeConfigHomeDir } from '../envUtils.js'
+import { logForDebugging } from '../debug.js'
+import {
+  getSettings_DEPRECATED,
+  updateSettingsForSource,
+} from '../settings/settings.js'
+
+export type ProviderTransport =
+  | 'anthropic_messages'
+  | 'openai_chat_completions'
+  | 'codex_responses'
+
+export type AuthAccountType =
+  | 'anthropic_oauth'
+  | 'openai_api_key'
+  | 'codex_oauth'
+  | 'env'
+
+export type PlatformModelConfig = {
+  id: string
+  displayName?: string
+}
+
+export type PlatformProviderConfig = {
+  id: string
+  name: string
+  transport: ProviderTransport
+  baseUrl?: string
+  headers?: Record<string, string>
+  models?: PlatformModelConfig[]
+}
+
+export type PlatformAuthAccountConfig = {
+  id: string
+  name: string
+  type: AuthAccountType
+  providerId?: string
+  apiKey?: string
+  apiKeyEnv?: string
+  accountId?: string
+  authJsonPath?: string
+}
+
+export type PlatformProfileConfig = {
+  id: string
+  name: string
+  providerId: string
+  authAccountId?: string
+  defaultModel?: string
+  baseUrl?: string
+  headers?: Record<string, string>
+}
+
+export type ResolvedPlatformAuthAccount = PlatformAuthAccountConfig & {
+  resolvedApiKey?: string
+}
+
+export type ResolvedPlatformProfile = {
+  profile: PlatformProfileConfig
+  provider: PlatformProviderConfig
+  authAccount?: ResolvedPlatformAuthAccount
+}
+
+type LegacyProviderRecord = {
+  id: string
+  name: string
+  baseUrl: string
+  apiFormat?: 'anthropic' | 'openai'
+  apiKey?: string
+  apiKeyEnv?: string
+  accountId?: string
+  models?: PlatformModelConfig[]
+}
+
+const PROVIDERS_FILENAME = 'providers.json'
+export const PROFILE_MODEL_SEPARATOR = ':'
+const LOCAL_HOSTNAMES = new Set(['localhost', '127.0.0.1', '::1'])
+
+const BUILTIN_PLATFORM_PROVIDERS: PlatformProviderConfig[] = [
+  {
+    id: 'anthropic',
+    name: 'Anthropic',
+    transport: 'anthropic_messages',
+  },
+  {
+    id: 'openai',
+    name: 'OpenAI',
+    transport: 'openai_chat_completions',
+    baseUrl: DEFAULT_OPENAI_BASE_URL,
+    models: [
+      { id: 'gpt-4o', displayName: 'GPT-4o' },
+      { id: 'gpt-4o-mini', displayName: 'GPT-4o Mini' },
+      { id: 'o3', displayName: 'o3' },
+      { id: 'o4-mini', displayName: 'o4-mini' },
+    ],
+  },
+  {
+    id: 'codex',
+    name: 'Codex',
+    transport: 'codex_responses',
+    baseUrl: DEFAULT_CODEX_BASE_URL,
+    models: [
+      { id: 'codexplan', displayName: 'Codex Plan (GPT-5.4)' },
+      { id: 'codexspark', displayName: 'Codex Spark' },
+      { id: 'gpt-5.4', displayName: 'GPT-5.4' },
+      { id: 'gpt-5.3-codex', displayName: 'GPT-5.3 Codex' },
+    ],
+  },
+]
+
+const BUILTIN_PLATFORM_AUTH_ACCOUNTS: PlatformAuthAccountConfig[] = [
+  {
+    id: 'anthropic-oauth',
+    name: 'Anthropic OAuth',
+    type: 'anthropic_oauth',
+    providerId: 'anthropic',
+  },
+  {
+    id: 'openai-env',
+    name: 'OpenAI API Key',
+    type: 'openai_api_key',
+    providerId: 'openai',
+    apiKeyEnv: 'OPENAI_API_KEY',
+  },
+  {
+    id: 'codex-auth',
+    name: 'Codex OAuth',
+    type: 'codex_oauth',
+    providerId: 'codex',
+    authJsonPath: resolveCodexAuthPath(),
+  },
+]
+
+const BUILTIN_PLATFORM_PROFILES: PlatformProfileConfig[] = [
+  {
+    id: 'anthropic',
+    name: 'Anthropic',
+    providerId: 'anthropic',
+    authAccountId: 'anthropic-oauth',
+  },
+  {
+    id: 'openai',
+    name: 'OpenAI',
+    providerId: 'openai',
+    authAccountId: 'openai-env',
+    defaultModel: 'gpt-4o',
+  },
+  {
+    id: 'codex',
+    name: 'Codex',
+    providerId: 'codex',
+    authAccountId: 'codex-auth',
+    defaultModel: 'codexplan',
+  },
+]
+
+function getLegacyProvidersFilePath(): string {
+  return join(getClaudeConfigHomeDir(), PROVIDERS_FILENAME)
+}
+
+function readLegacyProvidersFile(): LegacyProviderRecord[] {
+  const filePath = getLegacyProvidersFilePath()
+  try {
+    if (!existsSync(filePath)) return []
+    const content = readFileSync(filePath, 'utf-8')
+    const parsed = JSON.parse(content)
+    if (Array.isArray(parsed)) return parsed as LegacyProviderRecord[]
+    if (parsed && Array.isArray(parsed.providers)) {
+      return parsed.providers as LegacyProviderRecord[]
+    }
+  } catch (error) {
+    logForDebugging(`[PlatformProfiles] Failed to read legacy providers: ${error}`)
+  }
+  return []
+}
+
+function resolveAuthApiKey(
+  account: PlatformAuthAccountConfig | undefined,
+): string | undefined {
+  if (!account) return undefined
+
+  if (account.apiKeyEnv && process.env[account.apiKeyEnv]) {
+    return process.env[account.apiKeyEnv]
+  }
+
+  if (account.apiKey?.startsWith('env:')) {
+    const envName = account.apiKey.slice(4)
+    return process.env[envName] || undefined
+  }
+
+  if (account.apiKey) return account.apiKey
+  return undefined
+}
+
+function mergeById<T extends { id: string }>(items: T[]): T[] {
+  const merged = new Map<string, T>()
+  for (const item of items) merged.set(item.id, item)
+  return [...merged.values()]
+}
+
+function transportFromLegacyProvider(
+  provider: LegacyProviderRecord,
+): ProviderTransport {
+  if (provider.baseUrl.replace(/\/+$/, '') === DEFAULT_CODEX_BASE_URL) {
+    return 'codex_responses'
+  }
+  if (provider.apiFormat === 'openai') return 'openai_chat_completions'
+  return 'anthropic_messages'
+}
+
+function profileNameFromProvider(provider: LegacyProviderRecord): string {
+  return provider.name || provider.id
+}
+
+export function getPlatformProviders(): PlatformProviderConfig[] {
+  const settings = getSettings_DEPRECATED() || {}
+  const configured = settings.providers ?? []
+  const legacyProviders = readLegacyProvidersFile().map(provider => ({
+    id: provider.id,
+    name: provider.name,
+    transport: transportFromLegacyProvider(provider),
+    baseUrl: provider.baseUrl,
+    models: provider.models,
+  }))
+
+  return mergeById([
+    ...BUILTIN_PLATFORM_PROVIDERS,
+    ...legacyProviders,
+    ...configured,
+  ])
+}
+
+export function getPlatformAuthAccounts(): PlatformAuthAccountConfig[] {
+  const settings = getSettings_DEPRECATED() || {}
+  const configured = settings.authAccounts ?? []
+  const legacyAccounts = readLegacyProvidersFile().map(provider => ({
+    id: `${provider.id}-legacy-auth`,
+    name: `${profileNameFromProvider(provider)} Auth`,
+    type:
+      transportFromLegacyProvider(provider) === 'codex_responses'
+        ? ('codex_oauth' as const)
+        : provider.apiFormat === 'openai'
+          ? ('openai_api_key' as const)
+          : ('env' as const),
+    providerId: provider.id,
+    apiKey: provider.apiKey,
+    apiKeyEnv: provider.apiKeyEnv,
+    accountId: provider.accountId,
+    authJsonPath:
+      transportFromLegacyProvider(provider) === 'codex_responses'
+        ? resolveCodexAuthPath()
+        : undefined,
+  }))
+
+  return mergeById([
+    ...BUILTIN_PLATFORM_AUTH_ACCOUNTS,
+    ...legacyAccounts,
+    ...configured,
+  ])
+}
+
+export function getPlatformProfiles(): PlatformProfileConfig[] {
+  const settings = getSettings_DEPRECATED() || {}
+  const configured = settings.profiles ?? []
+  const legacyProfiles = readLegacyProvidersFile().map(provider => ({
+    id: provider.id,
+    name: profileNameFromProvider(provider),
+    providerId: provider.id,
+    authAccountId: `${provider.id}-legacy-auth`,
+    defaultModel: provider.models?.[0]?.id,
+    baseUrl: provider.baseUrl,
+  }))
+
+  return mergeById([
+    ...BUILTIN_PLATFORM_PROFILES,
+    ...legacyProfiles,
+    ...configured,
+  ])
+}
+
+export function getPlatformProfile(profileId: string): ResolvedPlatformProfile | null {
+  const profile = getPlatformProfiles().find(item => item.id === profileId)
+  if (!profile) return null
+  const provider = getPlatformProviders().find(item => item.id === profile.providerId)
+  if (!provider) return null
+  const authAccount = profile.authAccountId
+    ? getPlatformAuthAccounts().find(item => item.id === profile.authAccountId)
+    : undefined
+
+  return {
+    profile,
+    provider,
+    authAccount: authAccount
+      ? {
+          ...authAccount,
+          resolvedApiKey: resolveAuthApiKey(authAccount),
+        }
+      : undefined,
+  }
+}
+
+export function getDefaultProfileId(): string | undefined {
+  const settings = getSettings_DEPRECATED() || {}
+  return settings.defaultProfile
+}
+
+export function getDefaultSubagentProfileId(): string | undefined {
+  const settings = getSettings_DEPRECATED() || {}
+  return settings.defaultSubagentProfile ?? settings.defaultProfile
+}
+
+export function parseProfileQualifiedModel(
+  model: string,
+): { profileId: string; modelId: string } | null {
+  const separator = model.indexOf(PROFILE_MODEL_SEPARATOR)
+  if (separator === -1) return null
+
+  const profileId = model.slice(0, separator).trim()
+  const modelId = model.slice(separator + 1).trim()
+  if (!profileId || !modelId) return null
+
+  if (!getPlatformProfiles().some(profile => profile.id === profileId)) {
+    return null
+  }
+
+  return { profileId, modelId }
+}
+
+export function isProfileQualifiedModel(model: string): boolean {
+  return parseProfileQualifiedModel(model) !== null
+}
+
+export function getPlatformDefaultModelForProfile(profileId: string): string | undefined {
+  const resolved = getPlatformProfile(profileId)
+  if (!resolved) return undefined
+  return (
+    resolved.profile.defaultModel ??
+    resolved.provider.models?.[0]?.id
+  )
+}
+
+export function getAllPlatformModels(): Array<{
+  qualifiedId: string
+  displayName: string
+  profileId: string
+  profileName: string
+  providerId: string
+  providerName: string
+  modelId: string
+}> {
+  const profiles = getPlatformProfiles()
+  const results: Array<{
+    qualifiedId: string
+    displayName: string
+    profileId: string
+    profileName: string
+    providerId: string
+    providerName: string
+    modelId: string
+  }> = []
+
+  for (const profile of profiles) {
+    const resolved = getPlatformProfile(profile.id)
+    if (!resolved) continue
+
+    const apiKey = resolved.authAccount?.resolvedApiKey
+    const allowsAnonymous =
+      resolved.provider.transport !== 'anthropic_messages' &&
+      (() => {
+        try {
+          return LOCAL_HOSTNAMES.has(
+            new URL(resolved.profile.baseUrl ?? resolved.provider.baseUrl ?? '')
+              .hostname,
+          )
+        } catch {
+          return false
+        }
+      })()
+
+    if (
+      resolved.provider.id !== 'anthropic' &&
+      !apiKey &&
+      !allowsAnonymous &&
+      resolved.authAccount?.type !== 'anthropic_oauth'
+    ) {
+      continue
+    }
+
+    for (const model of resolved.provider.models ?? []) {
+      results.push({
+        qualifiedId: `${profile.id}:${model.id}`,
+        displayName:
+          model.displayName ??
+          `${model.id} (${profile.name})`,
+        profileId: profile.id,
+        profileName: profile.name,
+        providerId: resolved.provider.id,
+        providerName: resolved.provider.name,
+        modelId: model.id,
+      })
+    }
+  }
+
+  return results
+}
+
+export function getPlatformModelDisplayName(model: string): string | null {
+  const parsed = parseProfileQualifiedModel(model)
+  if (!parsed) return null
+  const resolved = getPlatformProfile(parsed.profileId)
+  if (!resolved) return null
+  const modelConfig = resolved.provider.models?.find(
+    item => item.id === parsed.modelId,
+  )
+
+  return (
+    modelConfig?.displayName ??
+    `${parsed.modelId} (${resolved.profile.name})`
+  )
+}
+
+export function resolvePlatformModelTarget(params: {
+  model?: string
+  profileId?: string
+  useDefaultProfile?: boolean
+  defaultProfileId?: string
+}): {
+  profileId: string
+  modelId: string
+  profile: PlatformProfileConfig
+  provider: PlatformProviderConfig
+  authAccount?: ResolvedPlatformAuthAccount
+} | null {
+  const parsed = params.model ? parseProfileQualifiedModel(params.model) : null
+  const profileId =
+    params.profileId ??
+    parsed?.profileId ??
+    params.defaultProfileId ??
+    (params.useDefaultProfile ? getDefaultProfileId() : undefined)
+
+  if (!profileId) return null
+
+  const resolved = getPlatformProfile(profileId)
+  if (!resolved) return null
+  const modelId =
+    parsed?.modelId ??
+    params.model ??
+    getPlatformDefaultModelForProfile(profileId)
+
+  if (!modelId) return null
+
+  return {
+    profileId,
+    modelId,
+    profile: resolved.profile,
+    provider: resolved.provider,
+    authAccount: resolved.authAccount,
+  }
+}
+
+function upsertById<T extends { id: string }>(items: T[], item: T): T[] {
+  const next = items.filter(existing => existing.id !== item.id)
+  next.push(item)
+  return next
+}
+
+export function syncLegacyProviderToPlatformSettings(provider: {
+  id: string
+  name: string
+  baseUrl: string
+  apiFormat?: 'anthropic' | 'openai'
+  apiKey?: string
+  apiKeyEnv?: string
+  accountId?: string
+  models: PlatformModelConfig[]
+}): { error: Error | null } {
+  const settings = getSettings_DEPRECATED() || {}
+  const providerConfig: PlatformProviderConfig = {
+    id: provider.id,
+    name: provider.name,
+    transport: transportFromLegacyProvider(provider),
+    baseUrl: provider.baseUrl,
+    models: provider.models,
+  }
+  const authAccountId = `${provider.id}-legacy-auth`
+  const authAccountConfig: PlatformAuthAccountConfig = {
+    id: authAccountId,
+    name: `${provider.name} Auth`,
+    type:
+      providerConfig.transport === 'codex_responses'
+        ? 'codex_oauth'
+        : provider.apiFormat === 'openai'
+          ? 'openai_api_key'
+          : 'env',
+    providerId: provider.id,
+    apiKey: provider.apiKey,
+    apiKeyEnv: provider.apiKeyEnv,
+    accountId: provider.accountId,
+    authJsonPath:
+      providerConfig.transport === 'codex_responses'
+        ? resolveCodexAuthPath()
+        : undefined,
+  }
+  const profileConfig: PlatformProfileConfig = {
+    id: provider.id,
+    name: provider.name,
+    providerId: provider.id,
+    authAccountId,
+    defaultModel: provider.models[0]?.id,
+    baseUrl: provider.baseUrl,
+  }
+
+  return updateSettingsForSource('userSettings', {
+    providers: upsertById(settings.providers ?? [], providerConfig),
+    authAccounts: upsertById(settings.authAccounts ?? [], authAccountConfig),
+    profiles: upsertById(settings.profiles ?? [], profileConfig),
+    defaultProfile: settings.defaultProfile ?? profileConfig.id,
+    defaultSubagentProfile:
+      settings.defaultSubagentProfile ?? settings.defaultProfile ?? profileConfig.id,
+  })
+}