llm-cli-gateway 2.12.0 → 2.12.2

package/dist/async-job-manager.js

@@ -5,7 +5,7 @@ import { ProcessMonitor } from "./process-monitor.js";
 import { computeRequestKey, isValidationRunStore } from "./job-store.js";
 import { NoopFlightRecorder, } from "./flight-recorder.js";
 import { codexFrResponse } from "./codex-json-parser.js";
-import { getRequestContext, resolveOwnerPrincipal } from "./request-context.js";
+import { getRequestContext, resolveOwnerPrincipal, principalCanAccess } from "./request-context.js";
 import { runApiRequest, ApiHttpError, } from "./api-provider.js";
 export function extractApiHttpStatus(error) {
     for (const candidate of [error, error?.cause]) {
@@ -26,10 +26,160 @@ export function extractApiErrorBody(error) {
     }
     return undefined;
 }
+export function isAsyncJobInProgress(status) {
+    return status === "queued" || status === "running";
+}
 const MAX_OUTPUT_SIZE = 50 * 1024 * 1024;
 const JOB_TTL_MS = 60 * 60 * 1000;
 const EVICTION_INTERVAL_MS = 5 * 60 * 1000;
 const OUTPUT_FLUSH_INTERVAL_MS = 1000;
+const DEFAULT_MANAGER_JOB_LIMITS = {
+    maxRunningJobs: 1_000_000,
+    maxRunningJobsPerProvider: 1_000_000,
+    maxQueuedJobs: 1_000_000,
+    queueTimeoutMs: 10 * 60 * 1000,
+    completedJobMemoryTtlMs: JOB_TTL_MS,
+    maxJobOutputBytes: MAX_OUTPUT_SIZE,
+};
+function formatByteCap(bytes) {
+    if (bytes > 0 && bytes % (1024 * 1024) === 0)
+        return `${bytes / (1024 * 1024)}MB`;
+    if (bytes > 0 && bytes % 1024 === 0)
+        return `${bytes / 1024}KB`;
+    return `${bytes} bytes`;
+}
+export class JobSaturationError extends Error {
+    provider;
+    detail;
+    retryable = true;
+    constructor(provider, detail) {
+        super(`Gateway is at capacity for ${provider}: ${detail}`);
+        this.provider = provider;
+        this.detail = detail;
+        this.name = "JobSaturationError";
+    }
+}
+class JobLimiter {
+    cfg;
+    logger;
+    runningGlobal = 0;
+    runningByProvider = new Map();
+    queue = [];
+    queuedByProvider = new Map();
+    rejectedCount = 0;
+    timedOutCount = 0;
+    constructor(cfg, logger) {
+        this.cfg = cfg;
+        this.logger = logger;
+    }
+    canRunNow(provider) {
+        if (this.runningGlobal >= this.cfg.maxRunningJobs)
+            return false;
+        if ((this.runningByProvider.get(provider) ?? 0) >= this.cfg.maxRunningJobsPerProvider) {
+            return false;
+        }
+        return true;
+    }
+    grant(provider) {
+        this.runningGlobal++;
+        this.runningByProvider.set(provider, (this.runningByProvider.get(provider) ?? 0) + 1);
+        let released = false;
+        return {
+            release: () => {
+                if (released)
+                    return;
+                released = true;
+                this.runningGlobal = Math.max(0, this.runningGlobal - 1);
+                const n = (this.runningByProvider.get(provider) ?? 1) - 1;
+                if (n <= 0)
+                    this.runningByProvider.delete(provider);
+                else
+                    this.runningByProvider.set(provider, n);
+                this.pump();
+            },
+        };
+    }
+    acquire(provider, onGrant, onTimeout) {
+        if (this.canRunNow(provider)) {
+            return { state: "granted", permit: this.grant(provider) };
+        }
+        if (this.queue.length >= this.cfg.maxQueuedJobs) {
+            this.rejectedCount++;
+            return { state: "rejected" };
+        }
+        const entry = {
+            provider,
+            onGrant,
+            timer: setTimeout(() => {
+                if (this.removeEntry(entry)) {
+                    this.timedOutCount++;
+                    onTimeout();
+                }
+            }, this.cfg.queueTimeoutMs),
+        };
+        if (entry.timer.unref)
+            entry.timer.unref();
+        this.queue.push(entry);
+        this.queuedByProvider.set(provider, (this.queuedByProvider.get(provider) ?? 0) + 1);
+        return {
+            state: "queued",
+            cancel: () => this.removeEntry(entry),
+        };
+    }
+    removeEntry(entry) {
+        const idx = this.queue.indexOf(entry);
+        if (idx < 0)
+            return false;
+        this.queue.splice(idx, 1);
+        clearTimeout(entry.timer);
+        const n = (this.queuedByProvider.get(entry.provider) ?? 1) - 1;
+        if (n <= 0)
+            this.queuedByProvider.delete(entry.provider);
+        else
+            this.queuedByProvider.set(entry.provider, n);
+        return true;
+    }
+    pump() {
+        let progressed = true;
+        while (progressed) {
+            progressed = false;
+            for (let i = 0; i < this.queue.length; i++) {
+                const entry = this.queue[i];
+                if (!this.canRunNow(entry.provider))
+                    continue;
+                this.removeEntry(entry);
+                const permit = this.grant(entry.provider);
+                try {
+                    entry.onGrant(permit);
+                }
+                catch (err) {
+                    this.logger.error("JobLimiter onGrant callback threw; releasing permit", err);
+                    permit.release();
+                }
+                progressed = true;
+                break;
+            }
+        }
+    }
+    snapshot() {
+        const hasProviderBackpressure = [...this.queuedByProvider.keys()].some(provider => (this.runningByProvider.get(provider) ?? 0) >= this.cfg.maxRunningJobsPerProvider);
+        const queueFullUnderPressure = this.queue.length > 0 && this.queue.length >= this.cfg.maxQueuedJobs;
+        return {
+            maxRunning: this.cfg.maxRunningJobs,
+            maxRunningPerProvider: this.cfg.maxRunningJobsPerProvider,
+            maxQueued: this.cfg.maxQueuedJobs,
+            running: this.runningGlobal,
+            queued: this.queue.length,
+            runningByProvider: Object.fromEntries(this.runningByProvider),
+            queuedByProvider: Object.fromEntries(this.queuedByProvider),
+            rejected: this.rejectedCount,
+            timedOut: this.timedOutCount,
+            saturated: this.runningGlobal >= this.cfg.maxRunningJobs ||
+                hasProviderBackpressure ||
+                queueFullUnderPressure,
+        };
+    }
+}
 const STALL_CHECK_INTERVAL_MS = 60 * 1000;
 const STALL_WARNING_MARKS_MS = [5, 10, 15].map(min => min * 60 * 1000);
 function describeProcessLaunchError(cli, error) {
@@ -83,12 +233,25 @@ export class AsyncJobManager {
     processMonitor;
     store;
     flightRecorder;
-    constructor(logger = noopLogger, onJobComplete, store = null, flightRecorder = new NoopFlightRecorder()) {
+    limits;
+    limiter;
+    completedJobMemoryTtlMs;
+    maxJobOutputBytes;
+    constructor(logger = noopLogger, onJobComplete, store = null, flightRecorder = new NoopFlightRecorder(), limits = DEFAULT_MANAGER_JOB_LIMITS) {
         this.logger = logger;
         this.onJobComplete = onJobComplete;
         this.processMonitor = new ProcessMonitor(logger);
         this.store = store;
         this.flightRecorder = flightRecorder;
+        this.limits = limits;
+        this.completedJobMemoryTtlMs = limits.completedJobMemoryTtlMs;
+        this.maxJobOutputBytes = limits.maxJobOutputBytes;
+        this.limiter = new JobLimiter({
+            maxRunningJobs: limits.maxRunningJobs,
+            maxRunningJobsPerProvider: limits.maxRunningJobsPerProvider,
+            maxQueuedJobs: limits.maxQueuedJobs,
+            queueTimeoutMs: limits.queueTimeoutMs,
+        }, logger);
         if (this.store) {
             try {
                 const { count, orphaned } = this.store.markOrphanedOnStartup();
@@ -238,9 +401,9 @@ export class AsyncJobManager {
             }
         }
         for (const [id, job] of this.jobs) {
-            if (job.status !== "running" && job.finishedAt) {
+            if (job.status !== "running" && job.status !== "queued" && job.finishedAt) {
                 const finishedMs = new Date(job.finishedAt).getTime();
-                if (now - finishedMs > JOB_TTL_MS) {
+                if (now - finishedMs > this.completedJobMemoryTtlMs) {
                     this.jobs.delete(id);
                     evicted++;
                 }
@@ -266,9 +429,12 @@ export class AsyncJobManager {
         const withStdin = stdin === undefined ? extraEnv : `${extraEnv}|stdin:${stdin}`;
         const withCwd = cwd === undefined ? withStdin : `${withStdin}|cwd:${cwd}`;
         const extra = cli === "codex" ? `${withCwd}|fmt:${outputFormat ?? "text"}` : withCwd;
-        return computeRequestKey(cli, args, extra);
+        const principal = resolveOwnerPrincipal(getRequestContext());
+        const scoped = principal === "local" ? extra : `${extra}|principal:${principal}`;
+        return computeRequestKey(cli, args, scoped);
     }
     buildHttpRequestKey(providerName, req) {
+        const principal = resolveOwnerPrincipal(getRequestContext());
         const canonical = {
             transport: "http",
             provider: providerName,
@@ -280,6 +446,7 @@ export class AsyncJobManager {
             reasoningEffort: req.reasoningEffort ?? null,
             maxOutputTokens: req.maxOutputTokens ?? null,
             previousResponseId: req.previousResponseId ?? null,
+            ...(principal === "local" ? {} : { principal }),
         };
         return computeRequestKey(`http:${providerName}`, [], JSON.stringify(canonical));
     }
@@ -295,6 +462,11 @@ export class AsyncJobManager {
                 record = this.hydrateFromStore(existing.id) ?? undefined;
             if (!record)
                 return null;
+            const caller = resolveOwnerPrincipal(getRequestContext());
+            if (!principalCanAccess(record.ownerPrincipal, caller)) {
+                this.logger.debug(`Dedup reuse refused for ${label}: caller cannot access job ${existing.id}`, { correlationId });
+                return null;
+            }
             this.logger.info(`Job ${existing.id} reused via dedup for ${label}`, {
                 correlationId,
                 originalCorrelationId: record.correlationId,
@@ -347,7 +519,7 @@ export class AsyncJobManager {
             args: [],
             requestKey,
             correlationId,
-            status: "running",
+            status: "queued",
             startedAt,
             finishedAt: null,
             exitCode: null,
@@ -374,6 +546,23 @@ export class AsyncJobManager {
             flightCompleteArmed: writeFlightStart === true,
         };
         this.jobs.set(id, job);
+        const launch = (permit) => {
+            job.limiterPermit = permit;
+            job.queueCancel = undefined;
+            if (job.status !== "queued") {
+                this.releaseJobPermit(job);
+                return;
+            }
+            job.status = "running";
+            runApiRequest(provider, apiRequest, this.logger, { signal: abort.signal })
+                .then(result => this.finalizeHttpJob(job, result, null))
+                .catch(error => this.finalizeHttpJob(job, null, error));
+        };
+        const acq = this.limiter.acquire(provider.name, permit => launch(permit), () => this.failQueuedJob(job, "queue wait timed out before a run slot was free"));
+        if (acq.state === "rejected") {
+            this.jobs.delete(id);
+            throw new JobSaturationError(provider.name, `running limit (${this.limits.maxRunningJobs} global / ${this.limits.maxRunningJobsPerProvider} per provider) reached and the queue is full (max ${this.limits.maxQueuedJobs}); retry shortly`);
+        }
         this.safeStoreCall("recordStart", () => this.store.recordStart({
             id,
             correlationId,
@@ -401,10 +590,16 @@ export class AsyncJobManager {
                 this.logger.error("Async-path flight recorder logStart failed", err);
             }
         }
-        this.logger.info(`Job ${id} started for ${provider.name} (http)`, { correlationId });
-        runApiRequest(provider, apiRequest, this.logger, { signal: abort.signal })
-            .then(result => this.finalizeHttpJob(job, result, null))
-            .catch(error => this.finalizeHttpJob(job, null, error));
+        if (acq.state === "granted") {
+            this.logger.info(`Job ${id} started for ${provider.name} (http)`, { correlationId });
+            launch(acq.permit);
+        }
+        else {
+            job.queueCancel = acq.cancel;
+            this.logger.info(`Job ${id} queued for ${provider.name} (http, limiter saturated)`, {
+                correlationId,
+            });
+        }
         return { snapshot: this.snapshot(job), deduped: false };
     }
     finalizeHttpJob(job, result, error) {
@@ -438,6 +633,7 @@ export class AsyncJobManager {
         this.fireOnComplete(job);
     }
     fireOnComplete(job) {
+        this.releaseJobPermit(job);
         if (job.onCompleteFired)
             return;
         if (!job.onComplete)
@@ -450,6 +646,13 @@ export class AsyncJobManager {
             this.logger.error(`Job ${job.id} onComplete hook threw`, err);
         }
     }
+    releaseJobPermit(job) {
+        const permit = job.limiterPermit;
+        if (!permit)
+            return;
+        job.limiterPermit = undefined;
+        permit.release();
+    }
     writeFlightComplete(job, finalStatus, overrideErrorMessage) {
         if (!job.flightRecorderEntry)
             return;
@@ -530,7 +733,7 @@ export class AsyncJobManager {
         if (job.flightCompleteArmed)
             return;
         job.flightCompleteArmed = true;
-        if (job.status === "running")
+        if (isAsyncJobInProgress(job.status))
             return;
         const finalStatus = job.status === "completed" ? "completed" : "failed";
         const override = job.canceled ? "canceled by caller" : undefined;
@@ -561,14 +764,14 @@ export class AsyncJobManager {
     persistComplete(job) {
         if (!this.store)
             return;
-        if (job.status === "running")
+        if (job.status === "running" || job.status === "queued")
             return;
         if (!job.finishedAt)
             return;
         job.outputDirty = false;
         this.safeStoreCall("recordComplete", () => this.store.recordComplete({
             id: job.id,
-            status: job.status === "running" ? "failed" : job.status,
+            status: job.status === "running" || job.status === "queued" ? "failed" : job.status,
             exitCode: job.exitCode,
             stdout: job.stdout,
             stderr: job.stderr,
@@ -660,30 +863,6 @@ export class AsyncJobManager {
         }
         const id = randomUUID();
         const startedAt = new Date().toISOString();
-        const command = providerCommandName(cli);
-        const baseEnv = envWithExtendedPath(process.env, getExtendedPath());
-        const child = spawnCliProcess(command, args, {
-            cwd,
-            stdio: stdin === undefined ? ["ignore", "pipe", "pipe"] : ["pipe", "pipe", "pipe"],
-            env: { ...baseEnv, ...(extraEnv ?? {}) },
-        });
-        if (stdin !== undefined && child.stdin) {
-            try {
-                child.stdin.write(stdin);
-            }
-            catch (err) {
-                this.logger.error(`Job ${id} failed to write stdin payload`, err);
-            }
-            child.stdin.end();
-        }
-        let groupCleaned = false;
-        const cleanupGroup = () => {
-            if (groupCleaned)
-                return;
-            groupCleaned = true;
-            if (child.pid)
-                unregisterProcessGroup(child.pid);
-        };
         const ownerPrincipal = resolveOwnerPrincipal(getRequestContext());
         const job = {
             id,
@@ -692,7 +871,7 @@ export class AsyncJobManager {
             args: [...args],
             requestKey,
             correlationId,
-            status: "running",
+            status: "queued",
             startedAt,
             finishedAt: null,
             exitCode: null,
@@ -701,14 +880,13 @@ export class AsyncJobManager {
             outputTruncated: false,
             canceled: false,
             error: null,
-            process: child,
+            process: null,
             transport: "process",
             abort: null,
             httpStatus: null,
             exited: false,
             metricsRecorded: false,
             outputFormat,
-            cleanupGroup,
             onComplete,
             onCompleteFired: false,
             outputDirty: false,
@@ -719,6 +897,37 @@ export class AsyncJobManager {
             flightCompleteArmed: writeFlightStart === true,
         };
         this.jobs.set(id, job);
+        const launch = (permit) => {
+            job.limiterPermit = permit;
+            job.queueCancel = undefined;
+            if (job.status !== "queued") {
+                this.releaseJobPermit(job);
+                return;
+            }
+            job.status = "running";
+            try {
+                this.launchProcessJob(job, { cli, args, cwd, stdin, extraEnv, idleTimeoutMs });
+            }
+            catch (err) {
+                const launchError = describeProcessLaunchError(cli, err);
+                job.status = "failed";
+                job.exitCode = launchError.exitCode;
+                job.error = launchError.message;
+                job.stderr = launchError.message;
+                job.finishedAt = new Date().toISOString();
+                job.exited = true;
+                this.logger.error(`Job ${id} failed to spawn: ${launchError.message}`, { correlationId });
+                this.emitMetrics(job);
+                this.persistComplete(job);
+                this.writeFlightComplete(job, "failed");
+                this.fireOnComplete(job);
+            }
+        };
+        const acq = this.limiter.acquire(cli, permit => launch(permit), () => this.failQueuedJob(job, "queue wait timed out before a run slot was free"));
+        if (acq.state === "rejected") {
+            this.jobs.delete(id);
+            throw new JobSaturationError(cli, `running limit (${this.limits.maxRunningJobs} global / ${this.limits.maxRunningJobsPerProvider} per provider) reached and the queue is full (max ${this.limits.maxQueuedJobs}); retry shortly`);
+        }
         this.safeStoreCall("recordStart", () => this.store.recordStart({
             id,
             correlationId,
@@ -727,7 +936,7 @@ export class AsyncJobManager {
             args: [...args],
             outputFormat,
             startedAt,
-            pid: child.pid ?? null,
+            pid: null,
             ownerPrincipal,
         }));
         if (writeFlightStart && flightRecorderEntry) {
@@ -749,7 +958,46 @@ export class AsyncJobManager {
                 this.logger.error("Async-path flight recorder logStart failed", err);
             }
         }
-        this.logger.info(`Job ${id} started for ${cli}`, { correlationId });
+        if (acq.state === "granted") {
+            this.logger.info(`Job ${id} started for ${cli}`, { correlationId });
+            launch(acq.permit);
+        }
+        else {
+            job.queueCancel = acq.cancel;
+            this.logger.info(`Job ${id} queued for ${cli} (limiter saturated)`, { correlationId });
+        }
+        return { snapshot: this.snapshot(job), deduped: false };
+    }
+    launchProcessJob(job, spawn) {
+        const { cli, args, cwd, stdin, extraEnv, idleTimeoutMs } = spawn;
+        const id = job.id;
+        const correlationId = job.correlationId;
+        const command = providerCommandName(cli);
+        const baseEnv = envWithExtendedPath(process.env, getExtendedPath());
+        const child = spawnCliProcess(command, args, {
+            cwd,
+            stdio: stdin === undefined ? ["ignore", "pipe", "pipe"] : ["pipe", "pipe", "pipe"],
+            env: { ...baseEnv, ...(extraEnv ?? {}) },
+        });
+        job.process = child;
+        if (stdin !== undefined && child.stdin) {
+            try {
+                child.stdin.write(stdin);
+            }
+            catch (err) {
+                this.logger.error(`Job ${id} failed to write stdin payload`, err);
+            }
+            child.stdin.end();
+        }
+        let groupCleaned = false;
+        const cleanupGroup = () => {
+            if (groupCleaned)
+                return;
+            groupCleaned = true;
+            if (child.pid)
+                unregisterProcessGroup(child.pid);
+        };
+        job.cleanupGroup = cleanupGroup;
         let idleTimerId;
         const resetIdleTimer = () => {
             if (!idleTimeoutMs || idleTimeoutMs <= 0)
@@ -849,7 +1097,23 @@ export class AsyncJobManager {
             this.writeFlightComplete(job, job.status === "completed" ? "completed" : "failed", job.status === "canceled" ? "canceled by caller" : undefined);
             this.fireOnComplete(job);
         });
-        return { snapshot: this.snapshot(job), deduped: false };
+    }
+    failQueuedJob(job, reason) {
+        if (job.status !== "queued")
+            return;
+        job.queueCancel = undefined;
+        job.status = "failed";
+        job.exitCode = 75;
+        job.error = `Gateway is at capacity for ${job.cli}: ${reason}`;
+        job.finishedAt = new Date().toISOString();
+        job.exited = true;
+        this.logger.info(`Job ${job.id} failed while queued: ${reason}`, {
+            correlationId: job.correlationId,
+        });
+        this.emitMetrics(job);
+        this.persistComplete(job);
+        this.writeFlightComplete(job, "failed", job.error);
+        this.fireOnComplete(job);
     }
     getJobSnapshot(jobId) {
         let job = this.jobs.get(jobId);
@@ -894,6 +1158,22 @@ export class AsyncJobManager {
         if (!job) {
             return { canceled: false, reason: "Job not found" };
         }
+        if (job.status === "queued") {
+            job.queueCancel?.();
+            job.queueCancel = undefined;
+            job.canceled = true;
+            job.status = "canceled";
+            job.finishedAt = new Date().toISOString();
+            job.exited = true;
+            this.logger.info(`Job ${jobId} canceled while queued`, {
+                correlationId: job.correlationId,
+            });
+            this.emitMetrics(job);
+            this.persistComplete(job);
+            this.writeFlightComplete(job, "failed", "canceled by caller");
+            this.fireOnComplete(job);
+            return { canceled: true };
+        }
         if (job.status !== "running") {
             return { canceled: false, reason: `Job is already ${job.status}` };
         }
@@ -964,6 +1244,23 @@ export class AsyncJobManager {
             jobs: health,
         };
     }
+    acquireProcessSlot(provider) {
+        return new Promise((resolve, reject) => {
+            const acq = this.limiter.acquire(provider, permit => resolve(permit), () => reject(new JobSaturationError(provider, "queue wait timed out before a run slot was free; retry shortly")));
+            if (acq.state === "granted") {
+                resolve(acq.permit);
+            }
+            else if (acq.state === "rejected") {
+                reject(new JobSaturationError(provider, `running limit (${this.limits.maxRunningJobs} global / ${this.limits.maxRunningJobsPerProvider} per provider) reached and the queue is full (max ${this.limits.maxQueuedJobs}); retry shortly`));
+            }
+        });
+    }
+    getLimiterSnapshot() {
+        return this.limiter.snapshot();
+    }
+    getConfiguredLimits() {
+        return { ...this.limits };
+    }
     getJobOutputFormat(jobId) {
         return this.jobs.get(jobId)?.outputFormat;
     }
@@ -988,12 +1285,13 @@ export class AsyncJobManager {
     }
     appendOutput(job, stream, chunk) {
         const totalBytes = Buffer.byteLength(job.stdout) + Buffer.byteLength(job.stderr) + chunk.length;
-        if (totalBytes > MAX_OUTPUT_SIZE) {
+        if (totalBytes > this.maxJobOutputBytes) {
             job.outputTruncated = true;
             if (job.status === "running") {
+                const overflowMsg = `Output exceeded maximum size (${formatByteCap(this.maxJobOutputBytes)})`;
                 job.status = "failed";
                 job.exitCode = 126;
-                job.error = "Output exceeded maximum size (50MB)";
+                job.error = overflowMsg;
                 job.finishedAt = new Date().toISOString();
                 job.clearIdleTimer?.();
                 if (job.process) {
@@ -1004,7 +1302,7 @@ export class AsyncJobManager {
                 });
                 this.emitMetrics(job);
                 this.persistComplete(job);
-                this.writeFlightComplete(job, "failed", "Output exceeded maximum size (50MB)");
+                this.writeFlightComplete(job, "failed", overflowMsg);
                 this.fireOnComplete(job);
                 if (job.process) {
                     setTimeout(() => {

package/dist/config.d.ts

@@ -36,6 +36,38 @@ export interface PersistenceConfigSources {
 }
 export declare function defaultGatewayConfigPath(): string;
 export declare function loadPersistenceConfig(logger?: Logger): PersistenceConfig;
+export declare const DEFAULT_HTTP_MAX_SESSIONS = 100;
+export declare const DEFAULT_HTTP_SESSION_IDLE_TTL_MS: number;
+export declare const DEFAULT_HTTP_SESSION_REAPER_INTERVAL_MS: number;
+export declare const DEFAULT_MAX_RUNNING_JOBS = 32;
+export declare const DEFAULT_MAX_RUNNING_JOBS_PER_PROVIDER = 16;
+export declare const DEFAULT_MAX_QUEUED_JOBS = 128;
+export declare const DEFAULT_QUEUE_TIMEOUT_MS = 120000;
+export declare const DEFAULT_COMPLETED_JOB_MEMORY_TTL_MS: number;
+export declare const DEFAULT_MAX_JOB_OUTPUT_BYTES: number;
+export interface HttpSessionLimitsConfig {
+    maxSessions: number;
+    sessionIdleTtlMs: number;
+    sessionReaperIntervalMs: number;
+}
+export interface JobLimitsConfig {
+    maxRunningJobs: number;
+    maxRunningJobsPerProvider: number;
+    maxQueuedJobs: number;
+    queueTimeoutMs: number;
+    completedJobMemoryTtlMs: number;
+    maxJobOutputBytes: number;
+}
+export interface GatewayLimitsConfig {
+    http: HttpSessionLimitsConfig;
+    jobs: JobLimitsConfig;
+    sources: {
+        configFile: string | null;
+    };
+}
+export declare const DEFAULT_HTTP_SESSION_LIMITS: HttpSessionLimitsConfig;
+export declare const DEFAULT_JOB_LIMITS: JobLimitsConfig;
+export declare function loadLimitsConfig(logger?: Logger): GatewayLimitsConfig;
 export declare const ANTHROPIC_TTL_SECONDS_VALUES: readonly [300, 3600];
 export type AnthropicTtlSeconds = (typeof ANTHROPIC_TTL_SECONDS_VALUES)[number];
 export declare const DEFAULT_MIN_STABLE_TOKENS_FOR_CACHE_CONTROL: {
@@ -81,6 +113,7 @@ export interface ApiProviderConfig {
 export interface ApiProviderRuntime {
     name: string;
     kind: ApiProviderKind;
+    apiKeyEnv: string | null;
     baseUrl: string;
     defaultModel: string;
     models?: string[];
@@ -96,6 +129,7 @@ export interface ProvidersConfig {
 }
 export declare function loadProvidersConfig(logger?: Logger): ProvidersConfig;
 export declare function isApiProviderEnabled(provider: ApiProviderConfig, env?: NodeJS.ProcessEnv): boolean;
+export declare function apiProviderKeyPresent(provider: ApiProviderConfig, env?: NodeJS.ProcessEnv): boolean;
 export declare function enabledApiProviders(config: ProvidersConfig, env?: NodeJS.ProcessEnv): ApiProviderRuntime[];
 export declare function isXaiProviderEnabled(config: ProvidersConfig, env?: NodeJS.ProcessEnv): boolean;
 export declare const ACP_TRANSPORTS: readonly ["cli", "acp"];