@jsonstudio/rcc 0.90.876 → 0.90.1270

package/dist/server/runtime/http-server/provider-traffic-governor.js

@@ -23,9 +23,19 @@ const ACQUIRE_WAIT_BASE_MS = 100;
 const ACQUIRE_WAIT_MAX_MS = 2_000;
 const ACQUIRE_JITTER_MS = 40;
 const LOCK_WAIT_MAX_MS = 250;
+const PROVIDER_TRAFFIC_RUN_NAMESPACE = `run-${process.pid}-${Date.now().toString(36)}-${randomUUID().slice(0, 8)}`;
+const ADAPTIVE_WINDOW_MINUTES = 15;
+const ADAPTIVE_STREAK_THRESHOLD = 5;
+const ADAPTIVE_BLOCK_BACKOFF_BASE_MS = 400;
+const ADAPTIVE_BLOCK_BACKOFF_MAX_MS = 8_000;
+const ADAPTIVE_DEFAULT_HARD_MAX = 64;
+const ADAPTIVE_DEFAULT_HARD_MULTIPLIER = 2;
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
+function toMinuteBucket(ms) {
+    return Math.floor(ms / 60_000);
+}
 function clampPositiveInt(value) {
     if (typeof value === 'number' && Number.isFinite(value)) {
         const normalized = Math.floor(value);
@@ -39,6 +49,76 @@ function clampPositiveInt(value) {
     }
     return undefined;
 }
+function clampNonNegativeInt(value) {
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        const normalized = Math.floor(value);
+        return normalized >= 0 ? normalized : undefined;
+    }
+    if (typeof value === 'string' && value.trim()) {
+        const parsed = Number.parseInt(value.trim(), 10);
+        if (Number.isFinite(parsed) && parsed >= 0) {
+            return parsed;
+        }
+    }
+    return undefined;
+}
+function clampInt(value, min, max) {
+    if (!Number.isFinite(value)) {
+        return min;
+    }
+    return Math.max(min, Math.min(max, Math.floor(value)));
+}
+function normalizeCode(value) {
+    if (typeof value !== 'string') {
+        return '';
+    }
+    return value.trim().toUpperCase();
+}
+function readAdaptiveEnvInt(keys, fallback) {
+    for (const key of keys) {
+        const parsed = clampPositiveInt(process.env[key]);
+        if (parsed) {
+            return parsed;
+        }
+    }
+    return fallback;
+}
+function resolveAdaptiveBlockBackoffBaseMs() {
+    return readAdaptiveEnvInt(['ROUTECODEX_DYNAMIC_CONCURRENCY_BLOCK_BACKOFF_BASE_MS', 'RCC_DYNAMIC_CONCURRENCY_BLOCK_BACKOFF_BASE_MS'], ADAPTIVE_BLOCK_BACKOFF_BASE_MS);
+}
+function resolveAdaptiveBlockBackoffMaxMs() {
+    return readAdaptiveEnvInt(['ROUTECODEX_DYNAMIC_CONCURRENCY_BLOCK_BACKOFF_MAX_MS', 'RCC_DYNAMIC_CONCURRENCY_BLOCK_BACKOFF_MAX_MS'], ADAPTIVE_BLOCK_BACKOFF_MAX_MS);
+}
+function isRecoverable429Like(event) {
+    if (event.statusCode === 429) {
+        return true;
+    }
+    const errorCode = normalizeCode(event.errorCode);
+    const upstreamCode = normalizeCode(event.upstreamCode);
+    if (errorCode.includes('429')
+        || upstreamCode.includes('429')
+        || errorCode.includes('RATE_LIMIT')
+        || upstreamCode.includes('RATE_LIMIT')
+        || errorCode.includes('INSUFFICIENT_QUOTA')
+        || upstreamCode.includes('INSUFFICIENT_QUOTA')) {
+        return true;
+    }
+    const reason = typeof event.reason === 'string' ? event.reason.trim().toLowerCase() : '';
+    if (!reason) {
+        return false;
+    }
+    return (reason.includes('too many requests')
+        || reason.includes('rate limit')
+        || reason.includes('insufficient_quota')
+        || reason.includes('quota'));
+}
+function createAdaptivePersistedConfig() {
+    return {
+        version: 1,
+        updatedAt: Date.now(),
+        runtimes: {}
+    };
+}
 function toStateKey(runtimeKey) {
     return encodeURIComponent(runtimeKey.trim());
 }
@@ -54,28 +134,8 @@ function isProcessAlive(pid) {
         return false;
     }
 }
-function resolveProviderTier(runtime, providerKey) {
-    const candidates = [
-        runtime.providerFamily,
-        runtime.providerId,
-        providerKey,
-        runtime.providerKey,
-        runtime.runtimeKey
-    ]
-        .filter((value) => typeof value === 'string' && value.trim().length > 0)
-        .map((value) => value.trim().toLowerCase());
-    const isMatch = (needle) => candidates.some((item) => item.includes(needle));
-    if (isMatch('deepseek') || isMatch('qwenchat')) {
-        return 'single';
-    }
-    if (isMatch('ali-coding-plan') || isMatch('tabglm') || isMatch('crs')) {
-        return 'quad';
-    }
-    return 'double';
-}
-export function resolveProviderTrafficPolicy(runtime, providerKey) {
-    const tier = resolveProviderTier(runtime, providerKey);
-    const defaultMaxInFlight = tier === 'single' ? 1 : (tier === 'quad' ? 4 : 2);
+export function resolveProviderTrafficPolicy(runtime, _providerKey) {
+    const defaultMaxInFlight = 2;
     const defaultRpm = defaultMaxInFlight * 60;
     const configuredConcurrency = runtime.concurrency;
     const configuredRpm = runtime.rpm;
@@ -171,22 +231,405 @@ async function tryReadLockMeta(lockFile) {
         return {};
     }
 }
+function hasValidLockMeta(meta) {
+    return Number.isFinite(meta.pid) && meta.pid > 0
+        && Number.isFinite(meta.createdAt) && meta.createdAt > 0;
+}
 export class ProviderTrafficGovernor {
     rootDir;
     lockDir;
     stateDir;
+    adaptiveEnabled;
+    adaptiveConfigPath;
+    adaptiveHardMax;
+    adaptiveHardMultiplier;
+    adaptiveStateByRuntime = new Map();
+    waiterStateByRuntime = new Map();
     ensureDirsPromise = null;
+    adaptiveLoadPromise = null;
+    adaptiveWritePromise = null;
+    adaptiveWriteTimer = null;
     constructor(rootDir) {
         const jestWorker = clampPositiveInt(process.env.JEST_WORKER_ID);
         const testScopedRoot = jestWorker
             ? path.join(resolveRccStateDir(), 'provider-traffic-test', `worker-${jestWorker}`, `pid-${process.pid}`)
             : undefined;
+        const sharedNamespaceEnabled = process.env.ROUTECODEX_PROVIDER_TRAFFIC_SHARED === '1'
+            || process.env.RCC_PROVIDER_TRAFFIC_SHARED === '1';
+        const defaultRoot = sharedNamespaceEnabled
+            ? path.join(resolveRccStateDir(), 'provider-traffic')
+            : path.join(resolveRccStateDir(), 'provider-traffic', PROVIDER_TRAFFIC_RUN_NAMESPACE);
         const base = rootDir
             ? path.resolve(rootDir)
-            : (testScopedRoot ?? path.join(resolveRccStateDir(), 'provider-traffic'));
+            : (testScopedRoot ?? defaultRoot);
         this.rootDir = base;
         this.lockDir = path.join(base, 'locks');
         this.stateDir = path.join(base, 'state');
+        this.adaptiveEnabled = (() => {
+            const raw = String(process.env.ROUTECODEX_DYNAMIC_CONCURRENCY_ENABLED
+                ?? process.env.RCC_DYNAMIC_CONCURRENCY_ENABLED
+                ?? '1').trim().toLowerCase();
+            return !(raw === '0' || raw === 'false' || raw === 'off' || raw === 'no');
+        })();
+        this.adaptiveHardMax = readAdaptiveEnvInt(['ROUTECODEX_DYNAMIC_CONCURRENCY_HARD_MAX', 'RCC_DYNAMIC_CONCURRENCY_HARD_MAX'], ADAPTIVE_DEFAULT_HARD_MAX);
+        this.adaptiveHardMultiplier = readAdaptiveEnvInt(['ROUTECODEX_DYNAMIC_CONCURRENCY_HARD_MULTIPLIER', 'RCC_DYNAMIC_CONCURRENCY_HARD_MULTIPLIER'], ADAPTIVE_DEFAULT_HARD_MULTIPLIER);
+        this.adaptiveConfigPath = (() => {
+            const fromEnv = process.env.ROUTECODEX_DYNAMIC_CONCURRENCY_CONFIG_PATH
+                || process.env.RCC_DYNAMIC_CONCURRENCY_CONFIG_PATH;
+            if (typeof fromEnv === 'string' && fromEnv.trim()) {
+                return path.resolve(fromEnv.trim());
+            }
+            return path.join(base, 'dynamic-concurrency-overrides.json');
+        })();
+    }
+    resolveAdaptiveHardMax(baseCap) {
+        const fallbackHardMax = Math.max(baseCap, Math.min(this.adaptiveHardMax, baseCap * this.adaptiveHardMultiplier));
+        return clampInt(fallbackHardMax, 1, this.adaptiveHardMax);
+    }
+    resolveMaxAcquireWaiters() {
+        return readAdaptiveEnvInt(['ROUTECODEX_PROVIDER_TRAFFIC_MAX_WAITERS', 'RCC_PROVIDER_TRAFFIC_MAX_WAITERS'], 64);
+    }
+    acquireWaiterSlot(runtimeKey) {
+        const normalizedKey = runtimeKey.trim();
+        const now = Date.now();
+        for (const [existingKey, state] of this.waiterStateByRuntime.entries()) {
+            if (state.activeWaiters <= 0 || now - state.updatedAtMs >= DEFAULT_CONCURRENCY_STALE_MS) {
+                this.waiterStateByRuntime.delete(existingKey);
+            }
+        }
+        const current = this.waiterStateByRuntime.get(normalizedKey);
+        const nextActiveWaiters = (current?.activeWaiters ?? 0) + 1;
+        const maxWaiters = this.resolveMaxAcquireWaiters();
+        if (nextActiveWaiters > maxWaiters) {
+            throw new ProviderTrafficSaturatedError(`provider traffic waiter queue overloaded for runtime ${normalizedKey}`, {
+                reason: 'acquire_waiter_overload',
+                runtimeKey: normalizedKey,
+                activeWaiters: current?.activeWaiters ?? 0,
+                maxWaiters
+            });
+        }
+        this.waiterStateByRuntime.set(normalizedKey, {
+            activeWaiters: nextActiveWaiters,
+            updatedAtMs: now
+        });
+        return {
+            activeWaiters: nextActiveWaiters
+        };
+    }
+    releaseWaiterSlot(runtimeKey) {
+        const normalizedKey = runtimeKey.trim();
+        const current = this.waiterStateByRuntime.get(normalizedKey);
+        if (!current) {
+            return;
+        }
+        const nextActiveWaiters = Math.max(0, current.activeWaiters - 1);
+        if (nextActiveWaiters === 0) {
+            this.waiterStateByRuntime.delete(normalizedKey);
+            return;
+        }
+        this.waiterStateByRuntime.set(normalizedKey, {
+            activeWaiters: nextActiveWaiters,
+            updatedAtMs: Date.now()
+        });
+    }
+    async ensureAdaptiveLoaded() {
+        if (!this.adaptiveEnabled) {
+            return;
+        }
+        if (!this.adaptiveLoadPromise) {
+            this.adaptiveLoadPromise = (async () => {
+                try {
+                    const raw = await fs.readFile(this.adaptiveConfigPath, 'utf8');
+                    const parsed = raw.trim() ? JSON.parse(raw) : null;
+                    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+                        return;
+                    }
+                    const runtimesRaw = parsed.runtimes;
+                    if (!runtimesRaw || typeof runtimesRaw !== 'object' || Array.isArray(runtimesRaw)) {
+                        return;
+                    }
+                    for (const [runtimeKey, value] of Object.entries(runtimesRaw)) {
+                        if (typeof runtimeKey !== 'string' || !runtimeKey.trim()) {
+                            continue;
+                        }
+                        if (!value || typeof value !== 'object' || Array.isArray(value)) {
+                            continue;
+                        }
+                        const row = value;
+                        const baseCap = clampPositiveInt(row.baseCap) ?? 2;
+                        const minCap = clampPositiveInt(row.minCap) ?? 1;
+                        const hardMaxCap = clampPositiveInt(row.hardMaxCap) ?? this.resolveAdaptiveHardMax(baseCap);
+                        const currentCap = clampPositiveInt(row.currentCap) ?? baseCap;
+                        const tentativeCap = clampPositiveInt(row.tentativeCap) ?? currentCap;
+                        const safeCap = clampPositiveInt(row.safeCap) ?? baseCap;
+                        const cooldownUntilMs = clampPositiveInt(row.cooldownUntilMs) ?? 0;
+                        const saturatedNo429Streak = clampNonNegativeInt(row.saturatedNo429Streak) ?? 0;
+                        const saturated429Streak = clampNonNegativeInt(row.saturated429Streak) ?? 0;
+                        const blockedBackoffLevel = clampNonNegativeInt(row.blockedBackoffLevel) ?? 0;
+                        const blockedBackoffUntilMs = clampNonNegativeInt(row.blockedBackoffUntilMs) ?? 0;
+                        const triedIncreaseCaps = Array.isArray(row.triedIncreaseCaps)
+                            ? row.triedIncreaseCaps
+                                .map((entry) => clampPositiveInt(entry))
+                                .filter((entry) => typeof entry === 'number')
+                            : [];
+                        const normalizedMin = clampInt(minCap, 1, hardMaxCap);
+                        const normalizedState = {
+                            runtimeKey: runtimeKey.trim(),
+                            baseCap: clampInt(baseCap, normalizedMin, hardMaxCap),
+                            minCap: normalizedMin,
+                            hardMaxCap,
+                            currentCap: clampInt(currentCap, normalizedMin, hardMaxCap),
+                            tentativeCap: clampInt(tentativeCap, normalizedMin, hardMaxCap),
+                            safeCap: clampInt(safeCap, normalizedMin, hardMaxCap),
+                            cooldownUntilMs,
+                            saturatedNo429Streak,
+                            saturated429Streak,
+                            blockedBackoffLevel,
+                            blockedBackoffUntilMs,
+                            lastDecisionMinute: -1,
+                            triedIncreaseCaps: new Set(triedIncreaseCaps),
+                            buckets: [],
+                            updatedAtMs: clampPositiveInt(row.updatedAtMs) ?? Date.now()
+                        };
+                        this.adaptiveStateByRuntime.set(normalizedState.runtimeKey, normalizedState);
+                    }
+                }
+                catch (error) {
+                    if (error?.code !== 'ENOENT') {
+                        // eslint-disable-next-line no-console
+                        console.warn(`[adaptive-concurrency] load failed path=${this.adaptiveConfigPath} reason=${error instanceof Error ? error.message : String(error)}`);
+                    }
+                }
+            })();
+        }
+        await this.adaptiveLoadPromise;
+    }
+    toAdaptivePersistedConfig() {
+        const payload = createAdaptivePersistedConfig();
+        for (const [runtimeKey, state] of this.adaptiveStateByRuntime.entries()) {
+            payload.runtimes[runtimeKey] = {
+                baseCap: state.baseCap,
+                minCap: state.minCap,
+                hardMaxCap: state.hardMaxCap,
+                currentCap: state.currentCap,
+                tentativeCap: state.tentativeCap,
+                safeCap: state.safeCap,
+                cooldownUntilMs: state.cooldownUntilMs,
+                saturatedNo429Streak: state.saturatedNo429Streak,
+                saturated429Streak: state.saturated429Streak,
+                blockedBackoffLevel: state.blockedBackoffLevel,
+                blockedBackoffUntilMs: state.blockedBackoffUntilMs,
+                triedIncreaseCaps: Array.from(state.triedIncreaseCaps.values()).sort((a, b) => a - b),
+                updatedAtMs: state.updatedAtMs
+            };
+        }
+        payload.updatedAt = Date.now();
+        return payload;
+    }
+    scheduleAdaptivePersist() {
+        if (!this.adaptiveEnabled) {
+            return;
+        }
+        if (this.adaptiveWriteTimer) {
+            return;
+        }
+        this.adaptiveWriteTimer = setTimeout(() => {
+            this.adaptiveWriteTimer = null;
+            this.adaptiveWritePromise = this.persistAdaptiveConfig().catch((error) => {
+                // eslint-disable-next-line no-console
+                console.warn(`[adaptive-concurrency] persist failed path=${this.adaptiveConfigPath} reason=${error instanceof Error ? error.message : String(error)}`);
+            });
+        }, 400);
+        this.adaptiveWriteTimer.unref?.();
+    }
+    async persistAdaptiveConfig() {
+        const payload = this.toAdaptivePersistedConfig();
+        await fs.mkdir(path.dirname(this.adaptiveConfigPath), { recursive: true });
+        const tempPath = `${this.adaptiveConfigPath}.${process.pid}.${randomUUID()}.tmp`;
+        await fs.writeFile(tempPath, JSON.stringify(payload), 'utf8');
+        await fs.rename(tempPath, this.adaptiveConfigPath);
+    }
+    getOrCreateAdaptiveState(runtimeKey, baseCapRaw) {
+        const runtimeId = runtimeKey.trim();
+        const baseCap = Math.max(1, baseCapRaw);
+        const existing = this.adaptiveStateByRuntime.get(runtimeId);
+        const hardMaxCap = this.resolveAdaptiveHardMax(baseCap);
+        if (existing) {
+            existing.baseCap = clampInt(baseCap, 1, Math.max(existing.hardMaxCap, hardMaxCap));
+            existing.hardMaxCap = Math.max(existing.hardMaxCap, hardMaxCap);
+            existing.minCap = clampInt(existing.minCap || 1, 1, existing.hardMaxCap);
+            existing.currentCap = clampInt(existing.currentCap || existing.baseCap, existing.minCap, existing.hardMaxCap);
+            existing.tentativeCap = clampInt(Math.max(existing.currentCap, existing.tentativeCap || existing.currentCap), existing.currentCap, existing.hardMaxCap);
+            existing.safeCap = clampInt(existing.safeCap || existing.baseCap, existing.minCap, existing.hardMaxCap);
+            existing.saturatedNo429Streak = clampNonNegativeInt(existing.saturatedNo429Streak) ?? 0;
+            existing.saturated429Streak = clampNonNegativeInt(existing.saturated429Streak) ?? 0;
+            existing.blockedBackoffLevel = clampNonNegativeInt(existing.blockedBackoffLevel) ?? 0;
+            existing.blockedBackoffUntilMs = clampNonNegativeInt(existing.blockedBackoffUntilMs) ?? 0;
+            return existing;
+        }
+        const state = {
+            runtimeKey: runtimeId,
+            baseCap,
+            minCap: 1,
+            hardMaxCap,
+            currentCap: clampInt(baseCap, 1, hardMaxCap),
+            tentativeCap: clampInt(baseCap, 1, hardMaxCap),
+            safeCap: clampInt(baseCap, 1, hardMaxCap),
+            cooldownUntilMs: 0,
+            saturatedNo429Streak: 0,
+            saturated429Streak: 0,
+            blockedBackoffLevel: 0,
+            blockedBackoffUntilMs: 0,
+            lastDecisionMinute: -1,
+            triedIncreaseCaps: new Set(),
+            buckets: [],
+            updatedAtMs: Date.now()
+        };
+        this.adaptiveStateByRuntime.set(runtimeId, state);
+        this.scheduleAdaptivePersist();
+        return state;
+    }
+    getOrCreateMinuteBucket(state, minute) {
+        const existing = state.buckets.find((entry) => entry.minute === minute);
+        if (existing) {
+            return existing;
+        }
+        const next = {
+            minute,
+            requests: 0,
+            http429: 0,
+            peakInFlight: 0
+        };
+        state.buckets.push(next);
+        state.buckets.sort((a, b) => a.minute - b.minute);
+        const minMinute = minute - Math.max(ADAPTIVE_WINDOW_MINUTES * 2, 30);
+        state.buckets = state.buckets.filter((entry) => entry.minute >= minMinute);
+        return next;
+    }
+    getWindowBuckets(state, nowMinute) {
+        const out = [];
+        const byMinute = new Map();
+        for (const entry of state.buckets) {
+            byMinute.set(entry.minute, entry);
+        }
+        for (let minute = nowMinute - (ADAPTIVE_WINDOW_MINUTES - 1); minute <= nowMinute; minute += 1) {
+            out.push(byMinute.get(minute) ?? {
+                minute,
+                requests: 0,
+                http429: 0,
+                peakInFlight: 0
+            });
+        }
+        return out;
+    }
+    resolveAdaptiveEffectiveCap(state) {
+        return clampInt(state.tentativeCap || state.currentCap, state.minCap, state.hardMaxCap);
+    }
+    maybeEvaluateAdaptiveState(runtimeKey, state, event, nowMs) {
+        const configuredCap = clampPositiveInt(event.configuredMaxInFlight)
+            ?? this.resolveAdaptiveEffectiveCap(state);
+        const observedInFlight = clampNonNegativeInt(event.activeInFlight) ?? 0;
+        const saturated = observedInFlight >= Math.max(1, configuredCap);
+        const got429 = !event.success && isRecoverable429Like(event);
+        const beforeCurrentCap = state.currentCap;
+        const beforeTentativeCap = state.tentativeCap;
+        let changed = false;
+        let reason = '';
+        if (observedInFlight > 0) {
+            const nextSafeCap = clampInt(Math.max(state.safeCap, observedInFlight), state.minCap, state.hardMaxCap);
+            if (nextSafeCap !== state.safeCap) {
+                state.safeCap = nextSafeCap;
+                changed = true;
+            }
+        }
+        if (!saturated) {
+            if (state.tentativeCap !== state.currentCap) {
+                state.tentativeCap = state.currentCap;
+                changed = true;
+            }
+            if (state.saturatedNo429Streak !== 0) {
+                state.saturatedNo429Streak = 0;
+                changed = true;
+            }
+            if (state.saturated429Streak !== 0) {
+                state.saturated429Streak = 0;
+                changed = true;
+            }
+            if (!got429 && state.blockedBackoffLevel > 0) {
+                state.blockedBackoffLevel = Math.max(0, state.blockedBackoffLevel - 1);
+                changed = true;
+            }
+            if (!got429 && state.blockedBackoffLevel === 0 && state.blockedBackoffUntilMs !== 0) {
+                state.blockedBackoffUntilMs = 0;
+                changed = true;
+            }
+        }
+        else if (got429) {
+            state.saturated429Streak += 1;
+            state.saturatedNo429Streak = 0;
+            const tentativeDown = clampInt(state.currentCap - 1, state.minCap, state.hardMaxCap);
+            if (tentativeDown !== state.tentativeCap) {
+                state.tentativeCap = tentativeDown;
+                changed = true;
+            }
+            state.blockedBackoffLevel = Math.min(16, state.blockedBackoffLevel + 1);
+            const backoffBaseMs = resolveAdaptiveBlockBackoffBaseMs();
+            const backoffMaxMs = Math.max(backoffBaseMs, resolveAdaptiveBlockBackoffMaxMs());
+            const backoffMs = Math.min(backoffMaxMs, backoffBaseMs * Math.pow(2, Math.max(0, state.blockedBackoffLevel - 1)));
+            const nextBackoffUntil = nowMs + backoffMs;
+            if (nextBackoffUntil > state.blockedBackoffUntilMs) {
+                state.blockedBackoffUntilMs = nextBackoffUntil;
+                changed = true;
+            }
+            if (state.saturated429Streak >= ADAPTIVE_STREAK_THRESHOLD && state.currentCap > state.minCap) {
+                state.currentCap = clampInt(state.currentCap - 1, state.minCap, state.hardMaxCap);
+                state.tentativeCap = state.currentCap;
+                state.saturated429Streak = 0;
+                state.saturatedNo429Streak = 0;
+                changed = true;
+                reason = 'saturated_429_commit_down';
+            }
+            else {
+                reason = 'saturated_429_probe_down';
+            }
+        }
+        else {
+            state.saturatedNo429Streak += 1;
+            state.saturated429Streak = 0;
+            if (state.blockedBackoffLevel > 0) {
+                state.blockedBackoffLevel = Math.max(0, state.blockedBackoffLevel - 1);
+                changed = true;
+            }
+            if (state.blockedBackoffLevel === 0 && state.blockedBackoffUntilMs !== 0) {
+                state.blockedBackoffUntilMs = 0;
+                changed = true;
+            }
+            const tentativeUp = clampInt(state.currentCap + 1, state.minCap, state.hardMaxCap);
+            if (tentativeUp > state.tentativeCap) {
+                state.tentativeCap = tentativeUp;
+                changed = true;
+            }
+            if (state.saturatedNo429Streak >= ADAPTIVE_STREAK_THRESHOLD && state.currentCap < state.hardMaxCap) {
+                state.currentCap = clampInt(state.currentCap + 1, state.minCap, state.hardMaxCap);
+                state.tentativeCap = state.currentCap;
+                state.saturatedNo429Streak = 0;
+                state.saturated429Streak = 0;
+                changed = true;
+                reason = 'saturated_no429_commit_up';
+            }
+            else {
+                reason = 'saturated_no429_probe_up';
+            }
+        }
+        state.lastDecisionMinute = toMinuteBucket(nowMs);
+        state.updatedAtMs = nowMs;
+        if (changed) {
+            this.scheduleAdaptivePersist();
+            // eslint-disable-next-line no-console
+            console.log(`[adaptive-concurrency] runtime=${runtimeKey} current=${beforeCurrentCap}->${state.currentCap} ` +
+                `tentative=${beforeTentativeCap}->${state.tentativeCap} streak429=${state.saturated429Streak} ` +
+                `streakNo429=${state.saturatedNo429Streak} backoffLevel=${state.blockedBackoffLevel} reason=${reason || 'state_update'}`);
+        }
     }
     async ensureDirs() {
         if (!this.ensureDirsPromise) {
@@ -204,6 +647,64 @@ export class ProviderTrafficGovernor {
     getStateFile(stateKey) {
         return path.join(this.stateDir, `${stateKey}.json`);
     }
+    async resetCurrentProcessState() {
+        await this.ensureDirs();
+        const result = {
+            stateFilesScanned: 0,
+            stateFilesUpdated: 0,
+            leasesRemoved: 0,
+            rpmEventsRemoved: 0
+        };
+        let files = [];
+        try {
+            files = await fs.readdir(this.stateDir);
+        }
+        catch (error) {
+            if (error?.code === 'ENOENT') {
+                return result;
+            }
+            throw error;
+        }
+        for (const file of files) {
+            if (!file.endsWith('.json')) {
+                continue;
+            }
+            const stateKey = file.slice(0, -'.json'.length);
+            if (!stateKey) {
+                continue;
+            }
+            result.stateFilesScanned += 1;
+            const stateFile = this.getStateFile(stateKey);
+            const lockFile = this.getLockFile(stateKey);
+            const lock = await this.acquireFileLock(lockFile, Date.now() + DEFAULT_CONCURRENCY_TIMEOUT_MS);
+            try {
+                const state = await readTrafficState(stateFile);
+                const removedRequestIds = new Set(state.leases
+                    .filter((lease) => lease.pid === process.pid)
+                    .map((lease) => lease.requestId));
+                const nextLeases = state.leases.filter((lease) => lease.pid !== process.pid);
+                const nextRpmEvents = state.rpmEvents.filter((event) => !removedRequestIds.has(event.requestId));
+                const leaseDelta = Math.max(0, state.leases.length - nextLeases.length);
+                const rpmDelta = Math.max(0, state.rpmEvents.length - nextRpmEvents.length);
+                if (leaseDelta <= 0 && rpmDelta <= 0) {
+                    continue;
+                }
+                result.leasesRemoved += leaseDelta;
+                result.rpmEventsRemoved += rpmDelta;
+                result.stateFilesUpdated += 1;
+                await writeTrafficState(stateFile, {
+                    version: 1,
+                    updatedAt: Date.now(),
+                    leases: nextLeases,
+                    rpmEvents: nextRpmEvents
+                });
+            }
+            finally {
+                await lock.release();
+            }
+        }
+        return result;
+    }
     async acquireFileLock(lockFile, deadlineAt) {
         await this.ensureDirs();
         let waitAttempt = 0;
@@ -233,10 +734,25 @@ export class ProviderTrafficGovernor {
             }
             catch (error) {
                 const errno = error?.code;
+                if (errno === 'ENOENT') {
+                    await this.ensureDirs();
+                    continue;
+                }
                 if (errno !== 'EEXIST') {
                     throw error;
                 }
                 const meta = await tryReadLockMeta(lockFile);
+                if (!hasValidLockMeta(meta)) {
+                    try {
+                        await fs.unlink(lockFile);
+                        continue;
+                    }
+                    catch (unlinkError) {
+                        if (unlinkError?.code !== 'ENOENT') {
+                            // another process may race us; fallback to wait
+                        }
+                    }
+                }
                 const createdAt = meta.createdAt ?? 0;
                 const lockAgeMs = createdAt > 0 ? now - createdAt : 0;
                 const stale = lockAgeMs > LOCK_STALE_MS || !isProcessAlive(meta.pid);
@@ -285,7 +801,20 @@ export class ProviderTrafficGovernor {
         if (!requestId) {
             throw new Error('[provider-traffic] acquire requires requestId');
         }
-        const policy = resolveProviderTrafficPolicy(options.runtime, options.providerKey);
+        await this.ensureAdaptiveLoaded();
+        const policyBase = resolveProviderTrafficPolicy(options.runtime, options.providerKey);
+        const adaptiveState = this.adaptiveEnabled
+            ? this.getOrCreateAdaptiveState(runtimeKey, policyBase.concurrency.maxInFlight)
+            : null;
+        const policy = adaptiveState
+            ? {
+                ...policyBase,
+                concurrency: {
+                    ...policyBase.concurrency,
+                    maxInFlight: clampInt(this.resolveAdaptiveEffectiveCap(adaptiveState), adaptiveState.minCap, adaptiveState.hardMaxCap)
+                }
+            }
+            : policyBase;
         const waitTimeoutMs = Math.min(policy.concurrency.acquireTimeoutMs, policy.rpm.acquireTimeoutMs);
         const startedAt = Date.now();
         const deadlineAt = startedAt + waitTimeoutMs;
@@ -295,99 +824,127 @@ export class ProviderTrafficGovernor {
         const lockFile = this.getLockFile(stateKey);
         let waitAttempt = 0;
         let lastReason = 'mixed';
-        while (true) {
-            let delayAfterReleaseMs = 0;
-            const lock = await this.acquireFileLock(lockFile, deadlineAt);
-            try {
-                const now = Date.now();
-                let state = await readTrafficState(stateFile);
-                state = this.pruneState(state, now, policy);
-                const activeInFlight = state.leases.length;
-                const rpmInWindow = state.rpmEvents.length;
-                const concurrencyBlocked = activeInFlight >= policy.concurrency.maxInFlight;
-                const rpmBlocked = rpmInWindow >= policy.rpm.requestsPerMinute;
-                if (!concurrencyBlocked && !rpmBlocked) {
-                    const leaseId = randomUUID();
-                    state.leases.push({
-                        leaseId,
-                        requestId,
-                        pid: process.pid,
-                        startedAt: now,
-                        expiresAt: now + policy.concurrency.staleLeaseMs
-                    });
-                    state.rpmEvents.push({
-                        requestId,
-                        startedAt: now
-                    });
-                    state.updatedAt = now;
-                    await writeTrafficState(stateFile, state);
-                    const waitedMs = Math.max(0, now - startedAt);
-                    return {
-                        permit: {
+        let waiterSlotHeld = false;
+        try {
+            while (true) {
+                let delayAfterReleaseMs = 0;
+                const lock = await this.acquireFileLock(lockFile, deadlineAt);
+                try {
+                    const now = Date.now();
+                    let state = await readTrafficState(stateFile);
+                    state = this.pruneState(state, now, policy);
+                    const activeInFlight = state.leases.length;
+                    const rpmInWindow = state.rpmEvents.length;
+                    const concurrencyBlocked = activeInFlight >= policy.concurrency.maxInFlight;
+                    const rpmBlocked = rpmInWindow >= policy.rpm.requestsPerMinute;
+                    if (!concurrencyBlocked && !rpmBlocked) {
+                        const leaseId = randomUUID();
+                        state.leases.push({
+                            leaseId,
+                            requestId,
+                            pid: process.pid,
+                            startedAt: now,
+                            expiresAt: now + policy.concurrency.staleLeaseMs
+                        });
+                        state.rpmEvents.push({
+                            requestId,
+                            startedAt: now
+                        });
+                        state.updatedAt = now;
+                        await writeTrafficState(stateFile, state);
+                        if (adaptiveState) {
+                            const minute = toMinuteBucket(now);
+                            const bucket = this.getOrCreateMinuteBucket(adaptiveState, minute);
+                            bucket.requests += 1;
+                            bucket.peakInFlight = Math.max(bucket.peakInFlight, activeInFlight + 1);
+                            adaptiveState.updatedAtMs = now;
+                        }
+                        const waitedMs = Math.max(0, now - startedAt);
+                        return {
+                            permit: {
+                                runtimeKey,
+                                providerKey: options.providerKey,
+                                requestId,
+                                leaseId,
+                                stateKey
+                            },
+                            policy,
+                            waitedMs,
+                            activeInFlight: activeInFlight + 1,
+                            rpmInWindow: rpmInWindow + 1
+                        };
+                    }
+                    if (!waiterSlotHeld) {
+                        this.acquireWaiterSlot(runtimeKey);
+                        waiterSlotHeld = true;
+                    }
+                    if (concurrencyBlocked && rpmBlocked) {
+                        lastReason = 'mixed';
+                    }
+                    else if (concurrencyBlocked) {
+                        lastReason = 'concurrency';
+                    }
+                    else {
+                        lastReason = 'rpm';
+                    }
+                    const nowAfterCheck = Date.now();
+                    const waitedMs = Math.max(0, nowAfterCheck - startedAt);
+                    if (softWaitTimeoutMs > 0 && waitedMs >= softWaitTimeoutMs) {
+                        throw new ProviderTrafficSaturatedError(`provider traffic wait exceeded soft timeout for runtime ${runtimeKey}`, {
+                            reason: `acquire_soft_timeout_${lastReason}`,
                             runtimeKey,
                             providerKey: options.providerKey,
-                            requestId,
-                            leaseId,
-                            stateKey
-                        },
-                        policy,
-                        waitedMs,
-                        activeInFlight: activeInFlight + 1,
-                        rpmInWindow: rpmInWindow + 1
-                    };
-                }
-                if (concurrencyBlocked && rpmBlocked) {
-                    lastReason = 'mixed';
-                }
-                else if (concurrencyBlocked) {
-                    lastReason = 'concurrency';
-                }
-                else {
-                    lastReason = 'rpm';
-                }
-                const nowAfterCheck = Date.now();
-                const waitedMs = Math.max(0, nowAfterCheck - startedAt);
-                if (softWaitTimeoutMs > 0 && waitedMs >= softWaitTimeoutMs) {
-                    throw new ProviderTrafficSaturatedError(`provider traffic wait exceeded soft timeout for runtime ${runtimeKey}`, {
-                        reason: `acquire_soft_timeout_${lastReason}`,
-                        runtimeKey,
-                        providerKey: options.providerKey,
-                        maxInFlight: policy.concurrency.maxInFlight,
-                        requestsPerMinute: policy.rpm.requestsPerMinute,
-                        activeInFlight,
-                        rpmInWindow,
-                        waitedMs,
-                        softWaitTimeoutMs
-                    });
+                            maxInFlight: policy.concurrency.maxInFlight,
+                            requestsPerMinute: policy.rpm.requestsPerMinute,
+                            activeInFlight,
+                            rpmInWindow,
+                            waitedMs,
+                            softWaitTimeoutMs
+                        });
+                    }
+                    if (nowAfterCheck >= deadlineAt) {
+                        throw new ProviderTrafficSaturatedError(`provider traffic saturated for runtime ${runtimeKey}`, {
+                            reason: `acquire_timeout_${lastReason}`,
+                            runtimeKey,
+                            providerKey: options.providerKey,
+                            maxInFlight: policy.concurrency.maxInFlight,
+                            requestsPerMinute: policy.rpm.requestsPerMinute,
+                            activeInFlight,
+                            rpmInWindow,
+                            waitedMs
+                        });
+                    }
+                    waitAttempt += 1;
+                    const backoffMs = Math.min(ACQUIRE_WAIT_MAX_MS, ACQUIRE_WAIT_BASE_MS * Math.pow(2, Math.min(6, waitAttempt - 1)));
+                    let rpmWaitMs = 0;
+                    if (rpmBlocked && state.rpmEvents.length > 0) {
+                        const oldest = state.rpmEvents[0];
+                        rpmWaitMs = Math.max(0, oldest.startedAt + policy.rpm.windowMs - nowAfterCheck);
+                    }
+                    const adaptiveBlockedWaitMs = (() => {
+                        if (!adaptiveState || !concurrencyBlocked) {
+                            return 0;
+                        }
+                        if (adaptiveState.blockedBackoffUntilMs <= nowAfterCheck) {
+                            return 0;
+                        }
+                        return Math.max(0, adaptiveState.blockedBackoffUntilMs - nowAfterCheck);
+                    })();
+                    const combinedWaitMs = Math.min(ACQUIRE_WAIT_MAX_MS, Math.max(backoffMs, rpmWaitMs, adaptiveBlockedWaitMs));
+                    const jitterMs = Math.floor(Math.random() * ACQUIRE_JITTER_MS);
+                    delayAfterReleaseMs = Math.max(40, Math.min(combinedWaitMs + jitterMs, deadlineAt - nowAfterCheck));
                 }
-                if (nowAfterCheck >= deadlineAt) {
-                    throw new ProviderTrafficSaturatedError(`provider traffic saturated for runtime ${runtimeKey}`, {
-                        reason: `acquire_timeout_${lastReason}`,
-                        runtimeKey,
-                        providerKey: options.providerKey,
-                        maxInFlight: policy.concurrency.maxInFlight,
-                        requestsPerMinute: policy.rpm.requestsPerMinute,
-                        activeInFlight,
-                        rpmInWindow,
-                        waitedMs
-                    });
+                finally {
+                    await lock.release();
                 }
-                waitAttempt += 1;
-                const backoffMs = Math.min(ACQUIRE_WAIT_MAX_MS, ACQUIRE_WAIT_BASE_MS * Math.pow(2, Math.min(6, waitAttempt - 1)));
-                let rpmWaitMs = 0;
-                if (rpmBlocked && state.rpmEvents.length > 0) {
-                    const oldest = state.rpmEvents[0];
-                    rpmWaitMs = Math.max(0, oldest.startedAt + policy.rpm.windowMs - nowAfterCheck);
+                if (delayAfterReleaseMs > 0) {
+                    await sleep(delayAfterReleaseMs);
                 }
-                const combinedWaitMs = Math.min(ACQUIRE_WAIT_MAX_MS, Math.max(backoffMs, rpmWaitMs));
-                const jitterMs = Math.floor(Math.random() * ACQUIRE_JITTER_MS);
-                delayAfterReleaseMs = Math.max(40, Math.min(combinedWaitMs + jitterMs, deadlineAt - nowAfterCheck));
-            }
-            finally {
-                await lock.release();
             }
-            if (delayAfterReleaseMs > 0) {
-                await sleep(delayAfterReleaseMs);
+        }
+        finally {
+            if (waiterSlotHeld) {
+                this.releaseWaiterSlot(runtimeKey);
             }
         }
     }
@@ -430,6 +987,32 @@ export class ProviderTrafficGovernor {
             await lock.release();
         }
     }
+    async observeOutcome(event) {
+        if (!this.adaptiveEnabled) {
+            return;
+        }
+        const runtimeKey = typeof event.runtimeKey === 'string' ? event.runtimeKey.trim() : '';
+        if (!runtimeKey) {
+            return;
+        }
+        await this.ensureAdaptiveLoaded();
+        const state = this.getOrCreateAdaptiveState(runtimeKey, clampPositiveInt(event.configuredMaxInFlight) ?? 2);
+        const nowMs = typeof event.observedAtMs === 'number' && Number.isFinite(event.observedAtMs)
+            ? Math.max(0, Math.floor(event.observedAtMs))
+            : Date.now();
+        const minute = toMinuteBucket(nowMs);
+        const bucket = this.getOrCreateMinuteBucket(state, minute);
+        if (bucket.requests <= 0) {
+            bucket.requests = 1;
+        }
+        if (typeof event.activeInFlight === 'number' && Number.isFinite(event.activeInFlight)) {
+            bucket.peakInFlight = Math.max(bucket.peakInFlight, Math.max(0, Math.floor(event.activeInFlight)));
+        }
+        if (!event.success && isRecoverable429Like(event)) {
+            bucket.http429 += 1;
+        }
+        this.maybeEvaluateAdaptiveState(runtimeKey, state, event, nowMs);
+    }
 }
 let sharedGovernor = null;
 export function getSharedProviderTrafficGovernor() {
@@ -461,6 +1044,9 @@ export function createNoopProviderTrafficGovernor() {
                 released: true,
                 activeInFlight: 0
             };
+        },
+        async observeOutcome() {
+            return;
         }
     };
 }