UNPKG

@bitkyc08/opencodex

Version:

Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code

117 lines (110 loc) • 7.45 kB
/** Pure eligibility policy. The caller owns admission, buffering, dispatch and the shared budget. */ export interface CompactionRecoveryConfig { enabled: true; model: string; allowDevinInvalidArgument?: boolean; } /** Evidence must describe the failed attempt, never request text or a guessed error message. */ export interface CompactionRecoveryEvidence { requestKind: "ordinary" | "compaction-v1" | "compaction-v2"; recoveryAttempts: number; cancelled: boolean; nonReplayable: boolean; /** Any semantic output observed, including output retained privately before delivery. */ partialOutput: boolean; toolEffects: boolean; remainingSends: number; /** Canonical serving identities resolved by the caller, including provider/account identity. */ originalModel: string; fallbackModel: string; /** Actual serving adapter/provider, not a prefix inferred from the requested selector. */ provider: string; httpStatus?: number; /** A completed result is never retried. Output validation belongs to the caller. */ responseStatus: "completed" | "failed" | "incomplete" | "unknown"; errorCode?: string; errorType?: string; authenticationDenied: boolean; policyDenied: boolean; budgetDenied: boolean; refusal: boolean; upstreamFailure: boolean; } export type CompactionRecoveryDecision = | { recover: true; model: string; reason: "context-overflow" | "compaction-output" | "upstream-unavailable" | "devin-invalid-argument" } | { recover: false; reason: "disabled" | "invalid-evidence" | "ordinary-request" | "already-attempted" | "cancelled" | "unsafe-replay" | "protected-failure" | "budget-exhausted" | "same-model" | "succeeded" | "unclassified-failure" }; const MODEL_LIMIT = 512; const safeName = (value: unknown, limit: number): value is string => typeof value === "string" && value.length > 0 && value.length <= limit && value === value.trim() && !/[\u0000-\u0020\u007f-\u009f]/.test(value); /** Invalid persisted values disable recovery rather than widening it. No configurable retry count. */ export function readCompactionRecoveryConfig(value: unknown): CompactionRecoveryConfig | null { if (!value || typeof value !== "object" || Array.isArray(value)) return null; const raw = value as Record<string, unknown>; if (Object.keys(raw).some(key => !["enabled", "model", "allowDevinInvalidArgument"].includes(key)) || raw.enabled !== true || !safeName(raw.model, MODEL_LIMIT) || (raw.allowDevinInvalidArgument !== undefined && typeof raw.allowDevinInvalidArgument !== "boolean")) return null; return { enabled: true, model: raw.model, ...(raw.allowDevinInvalidArgument !== undefined ? { allowDevinInvalidArgument: raw.allowDevinInvalidArgument } : {}), }; } // Structured tokens only. The normalizer must also supply the explicit denial flags above. const PROTECTED_CODE = /(?:^|_)(?:auth|authentication|authorization|unauthenticated|unauthorized|permission|forbidden|policy|refusal|refused|budget|quota|billing|safety|content_filter|origin_rejected|admission|scope)(?:_|$)/; const CONTEXT_CODES = new Set(["context_length_exceeded", "context_window_exceeded", "input_too_long"]); const COMPACTION_CODES = new Set(["compaction_failed", "invalid_compaction_output", "empty_compaction_output"]); const SERVER_CODES = new Set(["upstream_error", "upstream_server_error", "server_is_overloaded", "internal", "internal_error", "server_error", "unavailable", "service_unavailable", "gateway_timeout"]); /** Decides eligibility only; returning true neither spends nor grants another send. */ export function decideCompactionRecovery( value: unknown, evidence: CompactionRecoveryEvidence, ): CompactionRecoveryDecision { const config = readCompactionRecoveryConfig(value); if (!config) return { recover: false, reason: "disabled" }; const flags = [evidence.cancelled, evidence.nonReplayable, evidence.partialOutput, evidence.toolEffects, evidence.authenticationDenied, evidence.policyDenied, evidence.budgetDenied, evidence.refusal, evidence.upstreamFailure]; if (flags.some(flag => typeof flag !== "boolean") || !Number.isSafeInteger(evidence.recoveryAttempts) || evidence.recoveryAttempts < 0 || !Number.isSafeInteger(evidence.remainingSends) || evidence.remainingSends < 0 || !safeName(evidence.originalModel, MODEL_LIMIT) || !safeName(evidence.fallbackModel, MODEL_LIMIT) || !safeName(evidence.provider, 128) || !["ordinary", "compaction-v1", "compaction-v2"].includes(evidence.requestKind) || !["completed", "failed", "incomplete", "unknown"].includes(evidence.responseStatus) || (evidence.httpStatus !== undefined && (!Number.isInteger(evidence.httpStatus) || evidence.httpStatus < 100 || evidence.httpStatus > 599)) || [evidence.errorCode, evidence.errorType].some(code => code !== undefined && !safeName(code, 128))) { return { recover: false, reason: "invalid-evidence" }; } if (evidence.requestKind === "ordinary") return { recover: false, reason: "ordinary-request" }; if (evidence.recoveryAttempts !== 0) return { recover: false, reason: "already-attempted" }; const status = evidence.httpStatus; const codes = [evidence.errorCode, evidence.errorType].filter((code): code is string => code !== undefined); if (evidence.cancelled || status === 499 || codes.some(code => code === "cancelled" || code === "canceled" || code === "client_cancelled")) { return { recover: false, reason: "cancelled" }; } if (evidence.nonReplayable || evidence.partialOutput || evidence.toolEffects) return { recover: false, reason: "unsafe-replay" }; if (evidence.authenticationDenied || evidence.policyDenied || evidence.budgetDenied || evidence.refusal || status === 401 || status === 403 || status === 402 || status === 429 || codes.some(code => PROTECTED_CODE.test(code.toLowerCase()) || code === "failed_precondition")) { return { recover: false, reason: "protected-failure" }; } if (evidence.remainingSends === 0) return { recover: false, reason: "budget-exhausted" }; if (evidence.originalModel === evidence.fallbackModel) return { recover: false, reason: "same-model" }; if (evidence.responseStatus === "completed") return { recover: false, reason: "succeeded" }; const failedHttp = status !== undefined && status >= 400; if (!evidence.upstreamFailure || (!failedHttp && evidence.responseStatus !== "failed")) { return { recover: false, reason: "unclassified-failure" }; } const code = evidence.errorCode; const requestFailure = status === undefined || status === 200 || status === 400 || status === 413 || status === 422 || status >= 500; if (requestFailure && code && CONTEXT_CODES.has(code)) return { recover: true, model: config.model, reason: "context-overflow" }; if (requestFailure && code && COMPACTION_CODES.has(code)) return { recover: true, model: config.model, reason: "compaction-output" }; if (config.allowDevinInvalidArgument === true && evidence.provider === "devin" && code === "invalid_argument" && (evidence.responseStatus === "failed" || (status !== undefined && status >= 400 && status < 500))) { return { recover: true, model: config.model, reason: "devin-invalid-argument" }; } if (status !== undefined && status >= 500 && (code === undefined || SERVER_CODES.has(code))) { return { recover: true, model: config.model, reason: "upstream-unavailable" }; } return { recover: false, reason: "unclassified-failure" }; }