config.ts

import type {
  IAgentConfig,
  IAgentStageOverride,
  IMcpServerConfig,
  LogLevel,
  ProviderType,
} from '../index.ts'

const PROVIDERS: readonly ProviderType[] = [
  'openai',
  'anthropic',
  'openai-compatible',
  'google',
  'xai',
  'azure',
  'amazon-bedrock',
  'google-vertex',
  'deepseek',
  'gateway',
  'cloudflare',
]
const REQUIRES_BASE_URL: ReadonlySet<ProviderType> = new Set<ProviderType>([
  'openai-compatible',
  'azure',
])
const LOG_LEVELS: readonly LogLevel[] = ['none', 'error', 'warn', 'info', 'debug']
const TOOL_STRATEGIES = ['all', 'plan-narrowed'] as const
type ToolStrategy = (typeof TOOL_STRATEGIES)[number]

export const loadConfig = (): IAgentConfig => {
  const providerType = (process.env.AGENT_PROVIDER_TYPE ?? 'openai') as ProviderType
  if (!PROVIDERS.includes(providerType)) {
    throw new Error(`AGENT_PROVIDER_TYPE must be ${PROVIDERS.join(' | ')}, got: ${providerType}`)
  }

  const logLevel = (process.env.AGENT_LOG_LEVEL ?? 'info') as LogLevel
  if (!LOG_LEVELS.includes(logLevel)) {
    throw new Error(`AGENT_LOG_LEVEL must be ${LOG_LEVELS.join(' | ')}, got: ${logLevel}`)
  }

  // baseURL is required for providers with no SDK-default endpoint
  // (openai-compatible self-hosts, azure deployments). All others accept
  // an empty/missing value and fall back to the SDK's built-in default.
  const baseURL = REQUIRES_BASE_URL.has(providerType)
    ? required('AGENT_BASE_URL')
    : process.env.AGENT_BASE_URL?.trim() || undefined

  return {
    clientName: process.env.AGENT_CLIENT_NAME ?? 'vercel-mcp-test',
    providerType,
    baseURL,
    apiKey: required('AGENT_API_KEY'),
    model: required('AGENT_MODEL'),
    providerOptions: parseProviderOptions('AGENT_PROVIDER_OPTIONS'),
    // Per-stage overrides: AGENT_PLANNER_* / AGENT_SYNTHESIZER_*. The legacy
    // AGENT_PLANNER_MODEL / AGENT_SYNTHESIZER_MODEL still feed the deprecated
    // top-level model shortcut so existing setups keep working untouched.
    planner: parseStageOverride('AGENT_PLANNER'),
    synthesizer: parseStageOverride('AGENT_SYNTHESIZER'),
    plannerModel: process.env.AGENT_PLANNER_MODEL?.trim() || undefined,
    synthesizerModel: process.env.AGENT_SYNTHESIZER_MODEL?.trim() || undefined,
    mcpServers: parseMcpServers(process.env.MCP_SERVERS),
    availableTools: parseList(process.env.AGENT_AVAILABLE_TOOLS),
    excludedTools: parseList(process.env.AGENT_EXCLUDED_TOOLS),
    maxIterations: parsePositiveInt(process.env.AGENT_MAX_ITERATIONS, 10),
    maxStepsPerTask: parsePositiveInt(process.env.AGENT_MAX_STEPS_PER_TASK, 8),
    maxRevisions: parseOptionalInt(process.env.AGENT_MAX_REVISIONS),
    maxTotalTokens: parseOptionalInt(process.env.AGENT_MAX_TOTAL_TOKENS),
    llmTimeoutMs: parseOptionalInt(process.env.AGENT_LLM_TIMEOUT_MS),
    llmMaxRetries: parseOptionalInt(process.env.AGENT_LLM_MAX_RETRIES),
    toolSelectionStrategy: parseToolStrategy(process.env.AGENT_TOOL_SELECTION_STRATEGY),
    logLevel,
  }
}

// Read AGENT_<prefix>_PROVIDER_TYPE / _BASE_URL / _API_KEY / _MODEL into a
// stage override block. Returns undefined if no field is set so the agent
// inherits everything from the top-level defaults.
const parseStageOverride = (prefix: string): IAgentStageOverride | undefined => {
  const provider = process.env[`${prefix}_PROVIDER_TYPE`]?.trim()
  const baseURL = process.env[`${prefix}_BASE_URL`]?.trim()
  const apiKey = process.env[`${prefix}_API_KEY`]?.trim()
  const providerOptions = parseProviderOptions(`${prefix}_PROVIDER_OPTIONS`)
  // Stage block mirrors planner/synthesizer.model. The deprecated single-
  // string AGENT_PLANNER_MODEL / AGENT_SYNTHESIZER_MODEL still flows through
  // the legacy plannerModel/synthesizerModel slot - we ignore it here so the
  // override block can stay independently undefined.
  if (!provider && !baseURL && !apiKey && !providerOptions) {
    return undefined
  }
  if (provider && !PROVIDERS.includes(provider as ProviderType)) {
    throw new Error(`${prefix}_PROVIDER_TYPE must be ${PROVIDERS.join(' | ')}, got: ${provider}`)
  }
  return {
    providerType: (provider as ProviderType) || undefined,
    baseURL: baseURL || undefined,
    apiKey: apiKey || undefined,
    providerOptions,
  }
}

// Parse a provider-options JSON env block (e.g. AGENT_PROVIDER_OPTIONS,
// AGENT_PLANNER_PROVIDER_OPTIONS). Empty / unset returns undefined so the
// agent's config-level inheritance kicks in.
const parseProviderOptions = (varName: string): Record<string, unknown> | undefined => {
  const raw = process.env[varName]?.trim()
  if (!raw) {
    return undefined
  }
  let parsed: unknown
  try {
    parsed = JSON.parse(raw)
  } catch (err) {
    throw new Error(`${varName} must be valid JSON: ${(err as Error).message}`)
  }
  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
    throw new Error(`${varName} must be a JSON object (got ${typeof parsed})`)
  }
  return parsed as Record<string, unknown>
}

const parseToolStrategy = (raw: string | undefined): ToolStrategy | undefined => {
  const v = raw?.trim()
  if (!v) {
    return undefined
  }
  if (!TOOL_STRATEGIES.includes(v as ToolStrategy)) {
    throw new Error(
      `AGENT_TOOL_SELECTION_STRATEGY must be ${TOOL_STRATEGIES.join(' | ')}, got: ${v}`,
    )
  }
  return v as ToolStrategy
}

const parseOptionalInt = (raw: string | undefined): number | undefined => {
  if (!raw?.trim()) {
    return undefined
  }
  const n = Number(raw)
  if (!Number.isFinite(n) || n < 0) {
    throw new Error(`Expected non-negative number, got: ${raw}`)
  }
  return Math.floor(n)
}

const required = (name: string): string => {
  const v = process.env[name]?.trim()
  if (!v) {
    throw new Error(`Missing required env var: ${name}`)
  }
  return v
}

const parseList = (raw: string | undefined): string[] | undefined => {
  const t = raw?.trim()
  if (!t) {
    return undefined
  }
  return t
    .split(',')
    .map((s) => s.trim())
    .filter(Boolean)
}

const parsePositiveInt = (raw: string | undefined, fallback: number): number => {
  if (!raw?.trim()) {
    return fallback
  }
  const n = Number(raw)
  if (!Number.isFinite(n) || n <= 0) {
    throw new Error(`Expected positive number, got: ${raw}`)
  }
  return Math.floor(n)
}

const parseMcpServers = (raw: string | undefined): Record<string, IMcpServerConfig> => {
  if (!raw?.trim()) {
    return {}
  }
  let parsed: unknown
  try {
    parsed = JSON.parse(raw)
  } catch (err) {
    throw new Error(`MCP_SERVERS must be valid JSON: ${(err as Error).message}`)
  }
  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
    throw new Error(
      'MCP_SERVERS must be a JSON object: Record<name, { url, headers? } | { command, args?, env?, cwd? }>',
    )
  }
  const result: Record<string, IMcpServerConfig> = {}
  for (const [name, value] of Object.entries(parsed as Record<string, unknown>)) {
    if (!value || typeof value !== 'object') {
      throw new Error(`MCP_SERVERS.${name} must be an object`)
    }
    const v = value as {
      url?: unknown
      headers?: unknown
      command?: unknown
      args?: unknown
      env?: unknown
      cwd?: unknown
    }
    const hasUrl = typeof v.url === 'string' && v.url.length > 0
    const hasCommand = typeof v.command === 'string' && v.command.length > 0
    if (hasUrl && hasCommand) {
      throw new Error(
        `MCP_SERVERS.${name}: specify either "url" (HTTP) or "command" (stdio), not both`,
      )
    }
    if (!hasUrl && !hasCommand) {
      throw new Error(`MCP_SERVERS.${name}: must specify "url" (HTTP) or "command" (stdio)`)
    }
    if (hasUrl) {
      const headers =
        v.headers && typeof v.headers === 'object' && !Array.isArray(v.headers)
          ? (v.headers as Record<string, string>)
          : undefined
      result[name] = { url: v.url as string, headers }
      continue
    }
    // stdio path
    if (v.args !== undefined && !Array.isArray(v.args)) {
      throw new Error(`MCP_SERVERS.${name}.args must be a string array`)
    }
    if (v.env !== undefined && (!v.env || typeof v.env !== 'object' || Array.isArray(v.env))) {
      throw new Error(`MCP_SERVERS.${name}.env must be a string-to-string map`)
    }
    if (v.cwd !== undefined && typeof v.cwd !== 'string') {
      throw new Error(`MCP_SERVERS.${name}.cwd must be a string`)
    }
    result[name] = {
      command: v.command as string,
      args: v.args as string[] | undefined,
      env: v.env as Record<string, string> | undefined,
      cwd: v.cwd as string | undefined,
    }
  }
  return result
}