error-classifier.ts

import { DEFAULT_CONFIG, RETRYABLE_ERROR_PATTERNS } from "./constants"

function getObjectRecord(value: unknown): Record<string, unknown> | undefined {
	return value && typeof value === "object" ? (value as Record<string, unknown>) : undefined
}

function normalizeMessage(value: string): string {
	return value.trim().length === 0 ? "" : value.toLowerCase()
}

function getStringField(value: unknown, key: string): string | undefined {
	const record = getObjectRecord(value)
	const field = record?.[key]
	if (typeof field !== "string") return undefined

	const normalized = normalizeMessage(field)
	return normalized.length > 0 ? normalized : undefined
}

export function getErrorMessage(error: unknown): string {
	if (!error) return ""
	if (typeof error === "string") return normalizeMessage(error)

	const errorObj = error as Record<string, unknown>
	const paths = [
		(errorObj.data as Record<string, unknown>)?.error,
		errorObj.data,
		errorObj.error,
		errorObj,
	]

	for (const obj of paths) {
		const record = getObjectRecord(obj)
		if (!record || !("message" in record)) continue

		const rawMessage = record.message
		if (typeof rawMessage === "string") {
			return normalizeMessage(rawMessage)
		}
	}

	try {
		return normalizeMessage(JSON.stringify(error))
	} catch {
		return ""
	}
}

export function extractStatusCode(error: unknown, retryOnErrors?: number[]): number | undefined {
	if (!error) return undefined

	const errorObj = error as Record<string, unknown>

	const statusCode =
		errorObj.statusCode ??
		errorObj.status ??
		(errorObj.data as Record<string, unknown>)?.statusCode
	if (typeof statusCode === "number") {
		return statusCode
	}

	if (typeof statusCode === "string") {
		const parsed = Number.parseInt(statusCode, 10)
		if (!Number.isNaN(parsed)) {
			return parsed
		}
	}

	const codes = retryOnErrors ?? DEFAULT_CONFIG.retry_on_errors
	const message = getErrorMessage(error)
	const contextualPattern = new RegExp(
		`(?:status(?:\\s+code)?|code|http)\D*(${codes.join("|")})\\b|\\b(${codes.join("|")})\\b(?=\|[^0-9])`,
		"i"
	)
	const statusMatch = message.match(contextualPattern)
	const extracted = statusMatch?.[1] ?? statusMatch?.[2]
	if (extracted) {
		return parseInt(extracted, 10)
	}

	return undefined
}

export function extractErrorName(error: unknown): string | undefined {
	if (!error || typeof error !== "object") return undefined

	const errorObj = error as Record<string, unknown>
	const directName = errorObj.name
	if (typeof directName === "string" && directName.length > 0) {
		return directName
	}

	const nestedError = errorObj.error as Record<string, unknown> | undefined
	const nestedName = nestedError?.name
	if (typeof nestedName === "string" && nestedName.length > 0) {
		return nestedName
	}

	const dataError = (errorObj.data as Record<string, unknown> | undefined)?.error as
		| Record<string, unknown>
		| undefined
	const dataErrorName = dataError?.name
	if (typeof dataErrorName === "string" && dataErrorName.length > 0) {
		return dataErrorName
	}

	return undefined
}

export function classifyErrorType(error: unknown): string | undefined {
	const message = getErrorMessage(error)
	const errorName = extractErrorName(error)?.toLowerCase()

	if (
		errorName?.includes("loadapi") ||
		(/api.?key.?is.?missing/i.test(message) && /environment variable/i.test(message)) ||
		/(?:x-api-key|api key).*(?:is required|missing|required)/i.test(message) ||
		/(?:missing|required).*(?:x-api-key|api key)/i.test(message)
	) {
		return "missing_api_key"
	}

	if (
		(/api.?key/i.test(message) && /must be a string/i.test(message)) ||
		/incorrect api key provided/i.test(message) ||
		/api key not valid/i.test(message) ||
		/invalid api key/i.test(message)
	) {
		return "invalid_api_key"
	}

	if (errorName?.includes("unknownerror") && /model\s+not\s+found/i.test(message)) {
		return "model_not_found"
	}

	if (
		/model\s+(?:is\s+)?not\s+(?:found|supported|available)/i.test(message) ||
		/the model .+ does not exist/i.test(message)
	) {
		return "model_not_found"
	}

	return undefined
}

export interface AutoRetrySignal {
	signal: string
}

export const AUTO_RETRY_PATTERNS: Array<(combined: string) => boolean> = [
	(combined) => /retrying\s+in/i.test(combined),
	(combined) =>
		/(?:too\s+many\s+requests|quota\s*exceeded|usage\s+limit|rate\s+limit|limit\s+reached)/i.test(
			combined
		),
]

export function extractAutoRetrySignal(
	info: Record<string, unknown> | undefined
): AutoRetrySignal | undefined {
	if (!info) return undefined

	const candidates: string[] = []

	const directStatus = info.status
	if (typeof directStatus === "string") candidates.push(directStatus)

	const summary = info.summary
	if (typeof summary === "string") candidates.push(summary)

	const message = info.message
	if (typeof message === "string") candidates.push(message)

	const details = info.details
	if (typeof details === "string") candidates.push(details)

	const combined = candidates.join("\n")
	if (!combined) return undefined

	const isAutoRetry = AUTO_RETRY_PATTERNS.every((test) => test(combined))
	if (isAutoRetry) {
		return { signal: combined }
	}

	return undefined
}

export function containsErrorContent(
	parts: Array<{ type?: string; text?: string }> | undefined
): { hasError: boolean; errorMessage?: string } {
	if (!parts || parts.length === 0) return { hasError: false }

	const errorParts = parts.filter((p) => p.type === "error")
	if (errorParts.length > 0) {
		const errorMessages = errorParts
			.map((p) => p.text)
			.filter((text): text is string => typeof text === "string")
		const errorMessage = errorMessages.length > 0 ? errorMessages.join("\n") : undefined
		return { hasError: true, errorMessage }
	}

	return { hasError: false }
}

export function detectErrorInTextParts(
	parts: Array<{ type?: string; text?: string }> | undefined
): { hasError: boolean; errorType?: string; errorMessage?: string } {
	if (!parts || parts.length === 0) return { hasError: false }

	const textContent = parts
		.filter((p) => p.type === "text" && typeof p.text === "string" && p.text.length > 0)
		.map((p) => p.text!)
		.join("\n")

	if (!textContent) return { hasError: false }

	const errorType = classifyErrorType({ message: textContent, name: "TextContent" })
	if (errorType) {
		return { hasError: true, errorType, errorMessage: textContent }
	}

	return { hasError: false }
}

export function extractErrorContentFromParts(
	parts: Array<{ type?: string; text?: string }> | undefined
): { hasError: boolean; errorMessage?: string } {
	if (!parts || parts.length === 0) return { hasError: false }

	const errorParts = parts.filter(
		(p) => p.type === "error" && typeof p.text === "string" && p.text.length > 0
	)

	if (errorParts.length > 0) {
		const errorMessage = errorParts.map((p) => p.text).join("\n")
		return { hasError: true, errorMessage }
	}

	return { hasError: false }
}

export function isRetryableError(
	error: unknown,
	retryOnErrors: number[],
	userPatterns?: string[]
): boolean {
	const statusCode = extractStatusCode(error, retryOnErrors)
	const message = getErrorMessage(error)
	const errorType = classifyErrorType(error)

	if (errorType === "missing_api_key") {
		return true
	}

	if (errorType === "model_not_found") {
		return true
	}

	if (statusCode && retryOnErrors.includes(statusCode)) {
		return true
	}

	if (RETRYABLE_ERROR_PATTERNS.some((pattern) => pattern.test(message))) {
		return true
	}

	// Check user-provided retryable_error_patterns from config
	if (userPatterns && userPatterns.length > 0) {
		for (const patternStr of userPatterns) {
			try {
				const re = new RegExp(patternStr, "i")
				if (re.test(message)) return true
			} catch {
				// Invalid regex — skip silently
			}
		}
	}

	return false
}