llm-cli-gateway 2.12.1 → 2.13.0

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"];

package/dist/config.js

@@ -6,6 +6,7 @@ import { z } from "zod/v3";
 import { logWarn, noopLogger } from "./logger.js";
 import { hashSecret, isSecretHash } from "./oauth.js";
 import { isHttpsOrLoopbackUrl, isLoopbackUrl } from "./api-http.js";
+import { CLI_TYPES } from "./provider-types.js";
 const DatabaseUrlSchema = z
     .string()
     .url()
@@ -185,6 +186,93 @@ export function loadPersistenceConfig(logger = noopLogger) {
         sources,
     };
 }
+export const DEFAULT_HTTP_MAX_SESSIONS = 100;
+export const DEFAULT_HTTP_SESSION_IDLE_TTL_MS = 30 * 60 * 1000;
+export const DEFAULT_HTTP_SESSION_REAPER_INTERVAL_MS = 60 * 1000;
+export const DEFAULT_MAX_RUNNING_JOBS = 32;
+export const DEFAULT_MAX_RUNNING_JOBS_PER_PROVIDER = 16;
+export const DEFAULT_MAX_QUEUED_JOBS = 128;
+export const DEFAULT_QUEUE_TIMEOUT_MS = 120000;
+export const DEFAULT_COMPLETED_JOB_MEMORY_TTL_MS = 60 * 60 * 1000;
+export const DEFAULT_MAX_JOB_OUTPUT_BYTES = 50 * 1024 * 1024;
+const HttpSessionLimitsSchema = z
+    .object({
+    max_sessions: z.number().int().positive().default(DEFAULT_HTTP_MAX_SESSIONS),
+    session_idle_ttl_ms: z.number().int().positive().default(DEFAULT_HTTP_SESSION_IDLE_TTL_MS),
+    session_reaper_interval_ms: z
+        .number()
+        .int()
+        .positive()
+        .default(DEFAULT_HTTP_SESSION_REAPER_INTERVAL_MS),
+})
+    .passthrough();
+const JobLimitsSchema = z
+    .object({
+    max_running_jobs: z.number().int().positive().default(DEFAULT_MAX_RUNNING_JOBS),
+    max_running_jobs_per_provider: z
+        .number()
+        .int()
+        .positive()
+        .default(DEFAULT_MAX_RUNNING_JOBS_PER_PROVIDER),
+    max_queued_jobs: z.number().int().positive().default(DEFAULT_MAX_QUEUED_JOBS),
+    queue_timeout_ms: z.number().int().positive().default(DEFAULT_QUEUE_TIMEOUT_MS),
+    completed_job_memory_ttl_ms: z
+        .number()
+        .int()
+        .positive()
+        .default(DEFAULT_COMPLETED_JOB_MEMORY_TTL_MS),
+    max_job_output_bytes: z.number().int().positive().default(DEFAULT_MAX_JOB_OUTPUT_BYTES),
+})
+    .strict();
+export const DEFAULT_HTTP_SESSION_LIMITS = {
+    maxSessions: DEFAULT_HTTP_MAX_SESSIONS,
+    sessionIdleTtlMs: DEFAULT_HTTP_SESSION_IDLE_TTL_MS,
+    sessionReaperIntervalMs: DEFAULT_HTTP_SESSION_REAPER_INTERVAL_MS,
+};
+export const DEFAULT_JOB_LIMITS = {
+    maxRunningJobs: DEFAULT_MAX_RUNNING_JOBS,
+    maxRunningJobsPerProvider: DEFAULT_MAX_RUNNING_JOBS_PER_PROVIDER,
+    maxQueuedJobs: DEFAULT_MAX_QUEUED_JOBS,
+    queueTimeoutMs: DEFAULT_QUEUE_TIMEOUT_MS,
+    completedJobMemoryTtlMs: DEFAULT_COMPLETED_JOB_MEMORY_TTL_MS,
+    maxJobOutputBytes: DEFAULT_MAX_JOB_OUTPUT_BYTES,
+};
+export function loadLimitsConfig(logger = noopLogger) {
+    const configPath = defaultGatewayConfigPath();
+    const { parsed, sourcePath } = readGatewayTomlFile(configPath, logger, "limits");
+    const rawHttp = parsed?.http ?? {};
+    const rawLimits = parsed?.limits ?? {};
+    let httpParsed;
+    try {
+        httpParsed = HttpSessionLimitsSchema.parse(rawHttp);
+    }
+    catch (err) {
+        throw new Error(`Invalid [http] session-limit config: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    let limitsParsed;
+    try {
+        limitsParsed = JobLimitsSchema.parse(rawLimits);
+    }
+    catch (err) {
+        throw new Error(`Invalid [limits] config: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    return {
+        http: {
+            maxSessions: httpParsed.max_sessions,
+            sessionIdleTtlMs: httpParsed.session_idle_ttl_ms,
+            sessionReaperIntervalMs: httpParsed.session_reaper_interval_ms,
+        },
+        jobs: {
+            maxRunningJobs: limitsParsed.max_running_jobs,
+            maxRunningJobsPerProvider: limitsParsed.max_running_jobs_per_provider,
+            maxQueuedJobs: limitsParsed.max_queued_jobs,
+            queueTimeoutMs: limitsParsed.queue_timeout_ms,
+            completedJobMemoryTtlMs: limitsParsed.completed_job_memory_ttl_ms,
+            maxJobOutputBytes: limitsParsed.max_job_output_bytes,
+        },
+        sources: { configFile: sourcePath },
+    };
+}
 export const ANTHROPIC_TTL_SECONDS_VALUES = [300, 3600];
 export const DEFAULT_MIN_STABLE_TOKENS_FOR_CACHE_CONTROL = {
     sonnet: 1024,
@@ -268,14 +356,7 @@ export function minStableTokensForModel(config, modelName) {
         return table.haiku;
     return table.default;
 }
-const RESERVED_CLI_PROVIDER_NAMES = [
-    "claude",
-    "codex",
-    "gemini",
-    "grok",
-    "mistral",
-    "devin",
-];
+const RESERVED_CLI_PROVIDER_NAMES = CLI_TYPES;
 export const DEFAULT_XAI_API_KEY_ENV = "XAI_API_KEY";
 export const DEFAULT_XAI_BASE_URL = "https://api.x.ai/v1";
 export const DEFAULT_XAI_MODEL = "grok-build-0.1";
@@ -386,6 +467,9 @@ export function isApiProviderEnabled(provider, env = process.env) {
         return true;
     return provider.kind === "openai-compatible" && isLoopbackUrl(provider.baseUrl);
 }
+export function apiProviderKeyPresent(provider, env = process.env) {
+    return resolveProviderKey(provider.apiKeyEnv, env) !== null;
+}
 export function enabledApiProviders(config, env = process.env) {
     const runtimes = [];
     for (const provider of Object.values(config.providers ?? {})) {
@@ -394,6 +478,7 @@ export function enabledApiProviders(config, env = process.env) {
         runtimes.push({
             name: provider.name,
             kind: provider.kind,
+            apiKeyEnv: provider.apiKeyEnv,
             baseUrl: provider.baseUrl,
             defaultModel: provider.defaultModel,
             models: provider.models,

package/dist/doctor.d.ts

@@ -1,9 +1,10 @@
 import { type EndpointExposureReport } from "./endpoint-exposure.js";
 import { type ProviderLoginStatus } from "./provider-status.js";
+import { type ApiProviderLoginGuidance } from "./provider-login-guidance.js";
 import type { FlightRecorderQuery } from "./flight-recorder.js";
-import { type CacheAwarenessConfig } from "./config.js";
+import { type CacheAwarenessConfig, type ProvidersConfig } from "./config.js";
 import { type ProviderCapabilityId, type ProviderKind } from "./provider-tool-capabilities.js";
-export type CliType = "claude" | "codex" | "gemini" | "grok" | "mistral" | "devin";
+import { type CliType } from "./session-manager.js";
 export interface CacheAwarenessReport {
     enabled_features: Array<"anthropic_cache_control" | "ttl_warnings">;
     last_24h: {
@@ -38,6 +39,22 @@ export interface ProviderCapabilitySummaryReport {
         warnings: string[];
     }>;
 }
+export interface ApiProviderHealthEntry {
+    name: string;
+    kind: "openai-compatible" | "anthropic" | "xai-responses";
+    base_url: string;
+    default_model: string;
+    models: string[] | null;
+    api_key_env: string | null;
+    api_key_present: boolean;
+    reachable: boolean | null;
+    reachability_error?: string;
+    login_guidance: ApiProviderLoginGuidance;
+}
+export interface ApiProviderHealthReport {
+    enabled_count: number;
+    providers: Record<string, ApiProviderHealthEntry>;
+}
 export interface VibeSessionLoggingStatus {
     config_path: string;
     config_present: boolean;
@@ -106,7 +123,7 @@ export interface DoctorReport {
         allowed_root_count: number;
         gateway_app_dir_is_workspace: boolean;
     };
-    providers: Record<"claude" | "codex" | "gemini" | "grok" | "mistral", {
+    providers: Record<CliType, {
         cli_available: boolean;
         version: string | null;
         login_status: ProviderLoginStatus;
@@ -138,6 +155,7 @@ export interface DoctorReport {
     };
     cache_awareness: CacheAwarenessReport;
     provider_capabilities: ProviderCapabilitySummaryReport;
+    api_providers?: ApiProviderHealthReport;
     upstream: {
         note: string;
         recommendation: string;
@@ -154,8 +172,18 @@ export interface CreateDoctorReportOptions {
     flightRecorder?: FlightRecorderQuery;
     cacheAwareness?: CacheAwarenessConfig;
     probeUpstream?: boolean;
+    providersConfig?: ProvidersConfig;
+    apiReachability?: Record<string, {
+        reachable: boolean;
+        error?: string;
+    }>;
 }
 export declare function createDoctorReport(envOrOptions?: NodeJS.ProcessEnv | CreateDoctorReportOptions): DoctorReport;
 export declare function printDoctorJson(opts?: {
     probeUpstream?: boolean;
-}): void;
+    probeApiProviders?: boolean;
+}): Promise<void>;
+export declare function probeApiProviderReachability(baseUrl: string, timeoutMs?: number): Promise<{
+    reachable: boolean;
+    error?: string;
+}>;

package/dist/doctor.js

@@ -4,14 +4,16 @@ import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { loadAuthConfig } from "./auth.js";
 import { createEndpointExposureReport, redactDiagnosticUrl, } from "./endpoint-exposure.js";
-import { listProviderRuntimeStatuses, } from "./provider-status.js";
+import { getApiProviderStatus, listProviderRuntimeStatuses, } from "./provider-status.js";
+import { getApiProviderLoginGuidance, } from "./provider-login-guidance.js";
 import { CLAUDE_MCP_SERVER_NAMES } from "./claude-mcp-config.js";
-import { loadCacheAwarenessConfig, loadRemoteOAuthConfig, } from "./config.js";
+import { enabledApiProviders, loadCacheAwarenessConfig, loadProvidersConfig, loadRemoteOAuthConfig, } from "./config.js";
 import { loadWorkspaceRegistry } from "./workspace-registry.js";
 import { computeGlobalCacheStats } from "./cache-stats.js";
 import { FlightRecorder, resolveFlightRecorderDbPath } from "./flight-recorder.js";
 import { buildUpstreamContractReport } from "./upstream-contracts.js";
-import { getProviderToolCapabilities, providerCapabilityIds, } from "./provider-tool-capabilities.js";
+import { getProviderToolCapabilities, knownProviderCapabilityIds, } from "./provider-tool-capabilities.js";
+import { CLI_TYPES } from "./session-manager.js";
 export function checkVibeSessionLogging(home = homedir()) {
     const configPath = join(home, ".vibe", "config.toml");
     if (!existsSync(configPath)) {
@@ -172,6 +174,34 @@ function chatGPTConnectorUrl(env, rawPublicUrl) {
         return null;
     return "<redacted>";
 }
+function buildApiProviderHealthReport(opts, env) {
+    const config = opts.providersConfig;
+    if (!config)
+        return undefined;
+    const providers = {};
+    for (const providerConfig of Object.values(config.providers)) {
+        const status = getApiProviderStatus(providerConfig, env);
+        if (!status.enabled)
+            continue;
+        const probe = opts.apiReachability?.[status.provider];
+        providers[status.provider] = {
+            name: status.provider,
+            kind: status.kind,
+            base_url: status.baseUrl,
+            default_model: status.defaultModel,
+            models: status.models,
+            api_key_env: status.apiKeyEnv,
+            api_key_present: status.apiKeyPresent,
+            reachable: probe ? probe.reachable : null,
+            ...(probe?.error ? { reachability_error: probe.error } : {}),
+            login_guidance: getApiProviderLoginGuidance(providerConfig),
+        };
+    }
+    const names = Object.keys(providers);
+    if (names.length === 0)
+        return undefined;
+    return { enabled_count: names.length, providers };
+}
 function buildCacheAwarenessReport(opts) {
     const enabled = [];
     if (opts.cacheAwareness?.emitAnthropicCacheControl) {
@@ -234,7 +264,7 @@ function buildProviderCapabilitySummary(providerStatuses) {
         includeUnsupported: true,
         includePaths: false,
     });
-    const providers = Object.fromEntries(providerCapabilityIds().map(provider => {
+    const providers = Object.fromEntries(knownProviderCapabilityIds().map(provider => {
         const capability = capabilities[provider];
         if (!capability) {
             throw new Error(`Missing provider capability record for ${provider}`);
@@ -264,7 +294,7 @@ function buildProviderCapabilitySummary(providerStatuses) {
         tool: "provider_tool_capabilities",
         resources: {
             catalog: "provider-tools://catalog",
-            providers: Object.fromEntries(providerCapabilityIds().map(provider => [provider, `provider-tools://${provider}`])),
+            providers: Object.fromEntries(knownProviderCapabilityIds().map(provider => [provider, `provider-tools://${provider}`])),
         },
         cache_ttl_ms: 60_000,
         providers,
@@ -350,13 +380,7 @@ export function createDoctorReport(envOrOptions = process.env) {
             allowed_root_count: workspaceRegistry.allowedRoots.length,
             gateway_app_dir_is_workspace: workspaceRegistry.repos.some(repo => repo.path === join(homedir(), ".llm-cli-gateway")),
         },
-        providers: {
-            claude: doctorProviderStatus(providerStatuses.claude),
-            codex: doctorProviderStatus(providerStatuses.codex),
-            gemini: doctorProviderStatus(providerStatuses.gemini),
-            grok: doctorProviderStatus(providerStatuses.grok),
-            mistral: doctorProviderStatus(providerStatuses.mistral),
-        },
+        providers: Object.fromEntries(CLI_TYPES.map(provider => [provider, doctorProviderStatus(providerStatuses[provider])])),
         endpoint_exposure: endpointExposure,
         client_config: clientConfigStatus(),
         cache_awareness: buildCacheAwarenessReport(opts),
@@ -364,6 +388,10 @@ export function createDoctorReport(envOrOptions = process.env) {
         upstream,
         next_actions: [],
     };
+    const apiProviders = buildApiProviderHealthReport(opts, env);
+    if (apiProviders) {
+        report.api_providers = apiProviders;
+    }
     if (transport === "http" && auth.required && !auth.tokenConfigured) {
         report.ok = false;
         report.next_actions.push("Set LLM_GATEWAY_AUTH_TOKEN before starting HTTP transport.");
@@ -402,9 +430,10 @@ export function createDoctorReport(envOrOptions = process.env) {
     }
     return report;
 }
-export function printDoctorJson(opts = {}) {
+export async function printDoctorJson(opts = {}) {
     let cacheAwareness;
     let flightRecorder;
+    let providersConfig;
     try {
         cacheAwareness = loadCacheAwarenessConfig();
     }
@@ -417,11 +446,25 @@ export function printDoctorJson(opts = {}) {
     }
     catch {
     }
+    try {
+        providersConfig = loadProvidersConfig();
+    }
+    catch {
+    }
+    let apiReachability;
+    if (opts.probeApiProviders && providersConfig) {
+        apiReachability = {};
+        for (const runtime of enabledApiProviders(providersConfig)) {
+            apiReachability[runtime.name] = await probeApiProviderReachability(runtime.baseUrl);
+        }
+    }
     const report = createDoctorReport({
         env: process.env,
         cacheAwareness,
         flightRecorder,
         probeUpstream: opts.probeUpstream,
+        providersConfig,
+        apiReachability,
     });
     process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
     if (flightRecorder) {
@@ -432,6 +475,30 @@ export function printDoctorJson(opts = {}) {
         }
     }
 }
+export async function probeApiProviderReachability(baseUrl, timeoutMs = 5_000) {
+    let url;
+    try {
+        url = new URL(baseUrl);
+    }
+    catch {
+        return { reachable: false, error: "invalid base_url" };
+    }
+    const transport = url.protocol === "http:" ? await import("node:http") : await import("node:https");
+    return new Promise(resolve => {
+        const request = transport.request(url, { method: "GET", timeout: timeoutMs }, response => {
+            response.resume();
+            resolve({ reachable: true });
+        });
+        request.on("timeout", () => {
+            request.destroy();
+            resolve({ reachable: false, error: `timed out after ${timeoutMs}ms` });
+        });
+        request.on("error", err => {
+            resolve({ reachable: false, error: err instanceof Error ? err.message : String(err) });
+        });
+        request.end();
+    });
+}
 function isCreateDoctorReportOptions(value) {
     if (value === null || typeof value !== "object")
         return false;

package/dist/endpoint-exposure.js

@@ -68,16 +68,28 @@ export function redactDiagnosticUrl(rawUrl) {
     const redactSensitivePairs = (value) => value.replace(new RegExp(`((${sensitiveKeyPattern.source})=)[^&\\s#]+`, "gi"), "$1<redacted>");
     try {
         const url = new URL(rawUrl);
-        if (url.username)
+        let redacted = false;
+        if (url.username) {
             url.username = "<redacted>";
-        if (url.password)
+            redacted = true;
+        }
+        if (url.password) {
             url.password = "<redacted>";
+            redacted = true;
+        }
         for (const key of Array.from(url.searchParams.keys())) {
             if (sensitiveKeyPattern.test(key)) {
                 url.searchParams.set(key, "<redacted>");
+                redacted = true;
             }
         }
-        url.hash = redactSensitivePairs(url.hash);
+        const redactedHash = redactSensitivePairs(url.hash);
+        if (redactedHash !== url.hash) {
+            url.hash = redactedHash;
+            redacted = true;
+        }
+        if (!redacted)
+            return rawUrl;
         return url.toString().replace(/%3Credacted%3E/gi, "<redacted>");
     }
     catch {

package/dist/executor.js

@@ -8,6 +8,8 @@ export function providerCommandName(command) {
         return "agy";
     if (command === "mistral")
         return "vibe";
+    if (command === "cursor")
+        return "cursor-agent";
     return command;
 }
 const MAX_OUTPUT_SIZE = 50 * 1024 * 1024;

package/dist/http-transport.d.ts

@@ -1,12 +1,14 @@
 import { type Server } from "node:http";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import type { GatewayServerDeps } from "./index.js";
+import { type HttpSessionLimitsConfig } from "./config.js";
 export interface HttpTransportOptions {
     host?: string;
     port?: number;
     path?: string;
     deps?: GatewayServerDeps;
     createGatewayServer: (deps?: GatewayServerDeps) => McpServer;
+    httpLimits?: HttpSessionLimitsConfig;
     logger?: {
         info: (...args: any[]) => void;
         error: (...args: any[]) => void;
@@ -18,5 +20,6 @@ export interface HttpGatewayHandle {
     url: string;
     close: () => Promise<void>;
     sessionCount: () => number;
+    sessionHealth: () => Record<string, unknown>;
 }
 export declare function startHttpGateway(options: HttpTransportOptions): Promise<HttpGatewayHandle>;