@juspay/neurolink 12.15.0 → 12.16.0

package/dist/cli/commands/auth.js

@@ -248,8 +248,12 @@ function formatQuotaColumns(quota) {
         return chalk.green(text);
     };
     return {
-        sessionText: colorize(sessionRemaining, `${sessionRemaining}% left`),
-        weeklyText: colorize(weeklyRemaining, `${weeklyRemaining}% left`),
+        sessionText: quota.sessionStatus === "unknown"
+            ? chalk.gray("unknown")
+            : colorize(sessionRemaining, `${sessionRemaining}% left`),
+        weeklyText: quota.weeklyStatus === "unknown"
+            ? chalk.gray("unknown")
+            : colorize(weeklyRemaining, `${weeklyRemaining}% left`),
         sessionReset: quota.sessionResetAt > 0
             ? chalk.gray(`resets ${formatTimeUntil(quota.sessionResetAt)}`)
             : "",

package/dist/cli/commands/proxy.d.ts

@@ -82,6 +82,10 @@ export declare function createProxyStartApp(params: {
     app: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
     readiness: ProxyReadinessState;
 }>;
+/** Reload only the ready serving worker. A candidate still starting must not
+ * receive SIGHUP before it has installed its handlers. It loads fresh config
+ * during startup; draining workers already hold their request snapshots. */
+export declare function registerProxySupervisorReload(activeWorkerPid: () => number | undefined): () => void;
 export declare const proxyStartCommand: CommandModule<object, ProxyStartArgs>;
 export declare function sanitizeProxyStatusTerminalErrorMessage(message: string): string;
 export declare const proxyStatusCommand: CommandModule<object, ProxyStatusArgs>;

package/dist/cli/commands/proxy.js

@@ -1,4 +1,5 @@
 import { initializeProxyOtelLogs, routeProxyConsoleToOtel, flushProxyOtelLogs, shutdownProxyOtelLogs, isProxyOtelOnly, withProxyOtelLogShutdown, } from "../../proxy/otelLogSink.js";
+import { registerCliShutdownOwner } from "../lifecycle.js";
 import { writeFileAtomic } from "../proxy-clients/snapshot.js";
 import { spawn } from "node:child_process";
 import { homedir } from "node:os";
@@ -60,6 +61,9 @@ const PROXY_TELEMETRY_SCRIPT_PATH = fileURLToPath(new URL("../../../scripts/obse
  */
 const gatedShareRequests = new WeakSet();
 const PROXY_LIFECYCLE_SHUTDOWN_TIMEOUT_MS = 5_000;
+// Allow the normal 30-second worker drain plus startup settlement, leaving
+// telemetry and scheduling headroom inside launchd's 45-second stop budget.
+const PROXY_SUPERVISOR_DRAIN_TIMEOUT_MS = 35_000;
 /** How long shutdown waits on the share listener before moving on. */
 const SHARE_LISTENER_CLOSE_TIMEOUT_MS = 10_000;
 const PROXY_STATUS_RECONCILE_TIMEOUT_MS = 750;
@@ -2504,10 +2508,12 @@ function registerProxyShutdownHandlers(params) {
         }
         try {
             const { flushOpenTelemetry, shutdownOpenTelemetry } = await import("../../services/server/ai/observability/instrumentation.js");
-            await flushProxyOtelLogs();
-            await shutdownProxyOtelLogs();
-            await flushOpenTelemetry();
-            await shutdownOpenTelemetry();
+            await withShutdownDeadline((async () => {
+                await flushProxyOtelLogs();
+                await shutdownProxyOtelLogs();
+                await flushOpenTelemetry();
+                await shutdownOpenTelemetry();
+            })(), PROXY_LIFECYCLE_SHUTDOWN_TIMEOUT_MS, "telemetry shutdown");
         }
         catch {
             // non-fatal — proxy shutdown must not block on OTel
@@ -2535,12 +2541,7 @@ function registerProxyShutdownHandlers(params) {
         process.exit(1);
     };
     if (params.registerSignals ?? true) {
-        process.on("SIGTERM", () => {
-            void shutdown("SIGTERM").catch(forceExitAfterShutdownFailure);
-        });
-        process.on("SIGINT", () => {
-            void shutdown("SIGINT").catch(forceExitAfterShutdownFailure);
-        });
+        registerCliShutdownOwner((signal) => shutdown(signal).catch(forceExitAfterShutdownFailure));
     }
     return shutdown;
 }
@@ -2866,10 +2867,81 @@ async function startProxyRuntime(params) {
  * serving-process exits.
  */
 async function runLaunchdProxySupervisor(argv, spinner) {
+    let stopping = false;
+    let activeWorkerPid;
+    let rollingServerTask;
+    let restartControlTask;
+    let updaterSupervisor;
+    let activatePendingUpdate;
+    let otelInitialized = false;
+    /** Own startup as well as serving: await resources already being created,
+     * then drain each independently so one cleanup failure cannot skip the rest. */
+    const shutdown = async (signal) => {
+        if (stopping) {
+            return;
+        }
+        stopping = true;
+        logger.always(`[proxy-supervisor] shutting down (${signal})`);
+        if (activatePendingUpdate) {
+            process.off("SIGUSR2", activatePendingUpdate);
+        }
+        let exitCode = process.exitCode ?? 0;
+        const reportCleanupFailure = (error) => {
+            exitCode = 1;
+            logger.warn(`[proxy-supervisor] cleanup failed: ${String(error)}`);
+        };
+        const cleanup = async (operation, timeoutMs = PROXY_LIFECYCLE_SHUTDOWN_TIMEOUT_MS, timeoutMessage = "supervisor resource shutdown deadline exceeded") => {
+            try {
+                await withTimeout(Promise.resolve().then(operation), timeoutMs, timeoutMessage);
+            }
+            catch (error) {
+                reportCleanupFailure(error);
+            }
+        };
+        // Close independently: a stalled control must not delay the worker drain.
+        // The operations retain their continuations after a deadline, so a resource
+        // returned during telemetry cleanup is still closed without extending exit.
+        await Promise.all([
+            cleanup(async () => {
+                // Setup errors are already reported by the control-plane startup path.
+                const control = await restartControlTask?.catch(() => undefined);
+                await control?.close();
+            }),
+            cleanup(() => updaterSupervisor?.stop()),
+            cleanup(async () => {
+                const server = await rollingServerTask;
+                await server?.close();
+            }, PROXY_SUPERVISOR_DRAIN_TIMEOUT_MS),
+        ]);
+        if (otelInitialized) {
+            await cleanup(async () => {
+                await flushProxyLifecycleEvents().catch(reportCleanupFailure);
+                await flushProxyOtelLogs().catch(reportCleanupFailure);
+                await shutdownProxyOtelLogs();
+            }, PROXY_LIFECYCLE_SHUTDOWN_TIMEOUT_MS, "supervisor telemetry shutdown deadline exceeded");
+        }
+        await cleanup(() => {
+            const supervisorState = loadProxySupervisorState();
+            if (supervisorState?.pid === process.pid) {
+                clearProxySupervisorState();
+            }
+        });
+        process.exit(exitCode);
+    };
+    registerCliShutdownOwner(shutdown);
+    // Protect every startup await; a worker loads fresh config before readiness.
+    registerProxySupervisorReload(() => stopping ? undefined : activeWorkerPid?.());
     await loadProxyStartEnv(argv, spinner);
+    if (stopping) {
+        return;
+    }
     initializeProxyOtelLogs("supervisor");
+    otelInitialized = true;
     routeProxyConsoleToOtel();
     await ensureProxyStartAllowed(spinner);
+    if (stopping) {
+        return;
+    }
     const entryScript = process.argv[1];
     if (!entryScript) {
         throw new Error("proxy supervisor cannot resolve the CLI entry script");
@@ -2885,7 +2957,7 @@ async function runLaunchdProxySupervisor(argv, spinner) {
     });
     let currentUpdaterPid;
     let restartControl;
-    const rollingServer = await startRollingProxyServer({
+    rollingServerTask = startRollingProxyServer({
         onEvent: (event) => logProxyLifecycleEvent({
             event: "supervisor_event",
             requestId: "-",
@@ -2920,9 +2992,20 @@ async function runLaunchdProxySupervisor(argv, spinner) {
         },
         log: (message) => logger.always(message),
     });
+    // Retain the creation promise before awaiting it so shutdown owns late results.
+    const rollingServer = await rollingServerTask.catch((error) => {
+        if (!stopping) {
+            throw error;
+        }
+        return undefined;
+    });
+    if (stopping || !rollingServer) {
+        return;
+    }
+    activeWorkerPid = () => rollingServer.snapshot().active?.pid;
     let rollingReplacement = null;
-    const activatePendingUpdate = () => {
-        if (rollingReplacement) {
+    activatePendingUpdate = () => {
+        if (stopping || rollingReplacement) {
             return;
         }
         let pendingVersion;
@@ -2953,7 +3036,7 @@ async function runLaunchdProxySupervisor(argv, spinner) {
     process.on("SIGUSR2", activatePendingUpdate);
     const readinessHost = host === "0.0.0.0" ? "127.0.0.1" : host;
     try {
-        restartControl = await startProxyRestartControl({
+        restartControlTask = startProxyRestartControl({
             stateDir: join(homedir(), ".neurolink"),
             server: rollingServer,
             getTelemetry: getProxyProcessTelemetry,
@@ -2977,11 +3060,15 @@ async function runLaunchdProxySupervisor(argv, spinner) {
                 return response.json();
             },
         });
+        restartControl = await restartControlTask;
     }
     catch (error) {
         // A control-plane setup failure must not stop an otherwise serving proxy.
         logger.warn(`[proxy-supervisor] safe restart control unavailable: ${error instanceof Error ? error.message : String(error)}`);
     }
+    if (stopping) {
+        return;
+    }
     const updatePersistedUpdaterPid = (updaterPid) => {
         currentUpdaterPid = updaterPid;
         const state = loadProxySupervisorState();
@@ -2994,7 +3081,7 @@ async function runLaunchdProxySupervisor(argv, spinner) {
             restartControl: restartControl?.identity,
         });
     };
-    const updaterSupervisor = startUpdaterWorkerSupervisor({
+    updaterSupervisor = startUpdaterWorkerSupervisor({
         spawnWorker: () => spawnProxyUpdater(readinessHost, rollingServer.address.port, process.pid, true),
         isProcessRunning,
         stopWorker: (pid) => process.kill(pid, "SIGTERM"),
@@ -3006,34 +3093,27 @@ async function runLaunchdProxySupervisor(argv, spinner) {
         spinner.succeed(chalk.green("Claude proxy supervisor started successfully"));
     }
     logger.always(`[proxy-supervisor] listening on ${host}:${rollingServer.address.port} workerPid=${rollingServer.snapshot().active?.pid ?? "unknown"} version=${PROXY_VERSION}`);
-    let stopping = false;
-    /** Drain the rolling workers and flush the supervisor journal before clearing ownership. */
-    const shutdown = async (signal) => {
-        if (stopping) {
+    await new Promise(() => undefined);
+}
+/** Reload only the ready serving worker. A candidate still starting must not
+ * receive SIGHUP before it has installed its handlers. It loads fresh config
+ * during startup; draining workers already hold their request snapshots. */
+export function registerProxySupervisorReload(activeWorkerPid) {
+    const reload = () => {
+        const pid = activeWorkerPid();
+        if (!pid) {
             return;
         }
-        stopping = true;
-        logger.always(`[proxy-supervisor] shutting down (${signal})`);
-        process.off("SIGUSR2", activatePendingUpdate);
-        await restartControl?.close();
-        updaterSupervisor.stop();
-        await rollingServer.close();
-        await flushProxyLifecycleEvents().catch((error) => logger.warn(String(error)));
-        await flushProxyOtelLogs().catch(() => undefined);
-        await shutdownProxyOtelLogs().catch(() => undefined);
-        const supervisorState = loadProxySupervisorState();
-        if (supervisorState?.pid === process.pid) {
-            clearProxySupervisorState();
+        try {
+            process.kill(pid, "SIGHUP");
+            logger.always(`[proxy-supervisor] forwarded configuration reload to worker pid=${pid}`);
+        }
+        catch (error) {
+            logger.warn(`[proxy-supervisor] configuration reload failed: ${error instanceof Error ? error.message : String(error)}`);
         }
-        process.exit(0);
     };
-    process.once("SIGTERM", () => {
-        void shutdown("SIGTERM");
-    });
-    process.once("SIGINT", () => {
-        void shutdown("SIGINT");
-    });
-    await new Promise(() => undefined);
+    process.on("SIGHUP", reload);
+    return () => process.off("SIGHUP", reload);
 }
 async function startProxyCommandHandler(argv) {
     const spinner = argv.quiet ? null : ora("Starting Claude proxy...").start();

package/dist/cli/index.js

@@ -9,6 +9,7 @@ process.env.DOTENV_CONFIG_QUIET = "true";
  */
 import { initializeCliParser } from "./parser.js";
 import chalk from "chalk";
+import { initializeCliLifecycle, cleanupCliLifecycle } from "./lifecycle.js";
 // Clean up pnpm-specific environment variables that cause npm warnings
 // These variables are set by pnpm but cause "Unknown env config" warnings in npm
 if (process.env.npm_config_verify_deps_before_run) {
@@ -30,34 +31,23 @@ catch {
 }
 // Enhanced CLI with Professional UX
 const cli = initializeCliParser();
+initializeCliLifecycle(async () => {
+    const { flushOpenTelemetry } = await import("../services/server/ai/observability/instrumentation.js");
+    await flushOpenTelemetry();
+});
 // Execute CLI
 (async () => {
     try {
         // Parse and execute commands
         await cli.parse();
-        await cleanup();
+        await cleanupCliLifecycle();
     }
     catch (error) {
         // Global error handler - should not reach here due to fail() handler
         process.stderr.write(chalk.red(`Unexpected CLI _error: ${error.message}\n`));
-        await cleanup();
+        process.exitCode = 1;
+        await cleanupCliLifecycle();
         process.exit(1);
     }
 })();
-// Cleanup on exit
-process.on("SIGINT", async () => {
-    await cleanup();
-    process.exit(0);
-});
-process.on("SIGTERM", async () => {
-    await cleanup();
-    process.exit(0);
-});
-process.on("beforeExit", async () => {
-    await cleanup();
-});
-async function cleanup() {
-    const { flushOpenTelemetry } = await import("../services/server/ai/observability/instrumentation.js");
-    await flushOpenTelemetry();
-}
 //# sourceMappingURL=index.js.map

package/dist/cli/lifecycle.d.ts

@@ -0,0 +1,8 @@
+/** Install ordinary-command cleanup and its maximum flush duration. */
+export declare function initializeCliLifecycle(cleanup: () => Promise<void>, timeoutMs?: number): void;
+/** Delegate signals to a long-lived command that owns draining and exit. */
+export declare function registerCliShutdownOwner(handler: (signal: NodeJS.Signals) => Promise<void>): void;
+/** Flush ordinary commands once; an active shutdown owner manages its own cleanup. */
+export declare function cleanupCliLifecycle(): Promise<void>;
+/** Bound best-effort cleanup without allowing rejection to escape a signal handler. */
+export declare function runBoundedCliCleanup(cleanup: () => Promise<unknown>, timeoutMs?: number, onTimeout?: () => void): Promise<void>;

package/dist/cli/lifecycle.js

@@ -0,0 +1,90 @@
+/** One signal owner per CLI process. Proxy lifecycles own their drain and exit;
+ * ordinary commands only need a bounded, best-effort telemetry flush. */
+let owner;
+let cleanupTask;
+let cleanupPromise;
+let shutdownPromise;
+let installed = false;
+let cleanupTimeoutMs = 5_000;
+/** Install ordinary-command cleanup and its maximum flush duration. */
+export function initializeCliLifecycle(cleanup, timeoutMs = 5_000) {
+    cleanupTask = cleanup;
+    cleanupTimeoutMs = timeoutMs;
+    installSignals();
+}
+/** Delegate signals to a long-lived command that owns draining and exit. */
+export function registerCliShutdownOwner(handler) {
+    owner = handler;
+    installSignals();
+}
+/** Flush ordinary commands once; an active shutdown owner manages its own cleanup. */
+export function cleanupCliLifecycle() {
+    if (owner) {
+        return Promise.resolve();
+    }
+    cleanupPromise ??= runBoundedCliCleanup(() => cleanupTask?.() ?? Promise.resolve(), cleanupTimeoutMs, () => {
+        // A stalled exporter may retain handles after Promise.race settles.
+        // A newly registered owner still retains control of draining and exit.
+        if (!owner) {
+            process.exit(process.exitCode ?? 0);
+        }
+    });
+    return cleanupPromise;
+}
+/** Bound best-effort cleanup without allowing rejection to escape a signal handler. */
+export async function runBoundedCliCleanup(cleanup, timeoutMs = 5_000, onTimeout) {
+    let timer;
+    let timedOut = false;
+    try {
+        await Promise.race([
+            Promise.resolve().then(cleanup),
+            new Promise((_, reject) => {
+                timer = setTimeout(() => {
+                    timedOut = true;
+                    reject(new Error("telemetry flush deadline exceeded"));
+                }, timeoutMs);
+            }),
+        ]);
+    }
+    catch (error) {
+        process.stderr.write(`[cli] cleanup failed: ${error instanceof Error ? error.message : String(error)}\n`);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+    if (timedOut) {
+        onTimeout?.();
+    }
+}
+/** Install one process-wide signal dispatcher and reuse the first shutdown promise. */
+function installSignals() {
+    if (installed) {
+        return;
+    }
+    installed = true;
+    for (const signal of ["SIGINT", "SIGTERM"]) {
+        process.on(signal, () => {
+            shutdownPromise ??= Promise.resolve()
+                .then(async () => {
+                if (!owner) {
+                    await cleanupCliLifecycle();
+                }
+                // Startup may register the proxy owner while the flush is pending.
+                if (owner) {
+                    await owner(signal);
+                }
+                else {
+                    process.exit(process.exitCode ?? 0);
+                }
+            })
+                .catch((error) => {
+                process.stderr.write(`[cli] shutdown failed: ${error instanceof Error ? error.message : String(error)}\n`);
+                process.exit(1);
+            });
+        });
+    }
+    process.once("beforeExit", () => {
+        void cleanupCliLifecycle();
+    });
+}
+//# sourceMappingURL=lifecycle.js.map

package/dist/constants/enums.d.ts

@@ -18,6 +18,7 @@ export declare enum AIProviderName {
     NVIDIA_NIM = "nvidia-nim",
     LM_STUDIO = "lm-studio",
     LLAMACPP = "llamacpp",
+    API_ROUTE = "api-route",
     BASETEN = "baseten",
     CEREBRAS = "cerebras",
     CLOUDFLARE = "cloudflare",
@@ -816,6 +817,16 @@ export declare enum ReplicateModels {
  * authentication failures during ongoing operations
  */
 export declare const TOKEN_EXPIRY_BUFFER_MS: number;
+export declare enum ApiRouteModels {
+    CLAUDE_SONNET_4_6 = "claude-sonnet-4-6",
+    CLAUDE_HAIKU_4_5 = "claude-haiku-4-5",
+    DEEPSEEK_V4_FLASH = "deepseek-v4-flash",
+    DEEPSEEK_V4_PRO = "deepseek-v4-pro",
+    GEMINI_3_8_FLASH = "gemini-3.8-flash",
+    QWEN3_8_FLASH = "qwen3.8-flash",
+    KIMI_K2_7_CODE = "kimi-k2.7-code",
+    GLM_5_3_FLASH = "glm-5.3-flash"
+}
 export declare enum BasetenModels {
     OPENAI_GPT_OSS_120B = "openai/gpt-oss-120b",
     ZAI_ORG_GLM_4_7 = "zai-org/GLM-4.7",

package/dist/constants/enums.js

@@ -23,6 +23,7 @@ export var AIProviderName;
     AIProviderName["LM_STUDIO"] = "lm-studio";
     AIProviderName["LLAMACPP"] = "llamacpp";
     // ── BEGIN GENERATED(provider-members): provider catalog (pnpm run codegen:catalog) ──
+    AIProviderName["API_ROUTE"] = "api-route";
     AIProviderName["BASETEN"] = "baseten";
     AIProviderName["CEREBRAS"] = "cerebras";
     AIProviderName["CLOUDFLARE"] = "cloudflare";
@@ -1070,6 +1071,17 @@ export var ReplicateModels;
  */
 export const TOKEN_EXPIRY_BUFFER_MS = 5 * 60 * 1000; // 5 minutes
 // ── BEGIN GENERATED(models-enums): provider catalog (pnpm run codegen:catalog) ──
+export var ApiRouteModels;
+(function (ApiRouteModels) {
+    ApiRouteModels["CLAUDE_SONNET_4_6"] = "claude-sonnet-4-6";
+    ApiRouteModels["CLAUDE_HAIKU_4_5"] = "claude-haiku-4-5";
+    ApiRouteModels["DEEPSEEK_V4_FLASH"] = "deepseek-v4-flash";
+    ApiRouteModels["DEEPSEEK_V4_PRO"] = "deepseek-v4-pro";
+    ApiRouteModels["GEMINI_3_8_FLASH"] = "gemini-3.8-flash";
+    ApiRouteModels["QWEN3_8_FLASH"] = "qwen3.8-flash";
+    ApiRouteModels["KIMI_K2_7_CODE"] = "kimi-k2.7-code";
+    ApiRouteModels["GLM_5_3_FLASH"] = "glm-5.3-flash";
+})(ApiRouteModels || (ApiRouteModels = {}));
 export var BasetenModels;
 (function (BasetenModels) {
     BasetenModels["OPENAI_GPT_OSS_120B"] = "openai/gpt-oss-120b";

package/dist/providers/catalog/api-route.json

@@ -0,0 +1,130 @@
+{
+    "$schema": "./provider-catalog.schema.json",
+    "id": "api-route",
+    "displayName": "API Route",
+    "aliases": ["apiroute"],
+    "tier": 2,
+    "wire": {
+        "baseURL": "https://global.api-route.com/v1"
+    },
+    "models": {
+        "default": "claude-sonnet-4-6",
+        "fallbacks": ["claude-haiku-4-5", "deepseek-v4-flash", "gemini-3.8-flash"],
+        "defaultContextWindow": 1000000,
+        "defaultMaxOutputTokens": 64000,
+        "catalog": {
+            "claude-sonnet-4-6": {
+                "contextWindow": 1000000,
+                "maxOutputTokens": 64000,
+                "vision": true,
+                "status": "production",
+                "description": "Claude Sonnet 4.6 — flagship model with 1M context, tool calling, and multimodal vision"
+            },
+            "claude-haiku-4-5": {
+                "contextWindow": 200000,
+                "maxOutputTokens": 32768,
+                "vision": true,
+                "status": "production",
+                "description": "Claude Haiku 4.5 — fast, high-efficiency model with 200K context, tool calling, and vision"
+            },
+            "deepseek-v4-flash": {
+                "contextWindow": 1000000,
+                "maxOutputTokens": 64000,
+                "vision": false,
+                "status": "production",
+                "description": "DeepSeek V4 Flash — fast, cost-effective reasoning model with 1M context"
+            },
+            "deepseek-v4-pro": {
+                "contextWindow": 1000000,
+                "maxOutputTokens": 64000,
+                "vision": false,
+                "status": "production",
+                "description": "DeepSeek V4 Pro — powerful reasoning model with 1M context"
+            },
+            "gemini-3.8-flash": {
+                "contextWindow": 1000000,
+                "maxOutputTokens": 64000,
+                "vision": true,
+                "status": "production",
+                "description": "Gemini 3.8 Flash — high-speed multimodal model supporting image input and streaming"
+            },
+            "qwen3.8-flash": {
+                "contextWindow": 128000,
+                "maxOutputTokens": 16384,
+                "vision": false,
+                "status": "production",
+                "description": "Qwen 3.8 Flash — versatile, fast model for general instruction and coding tasks"
+            },
+            "kimi-k2.7-code": {
+                "contextWindow": 256000,
+                "maxOutputTokens": 32768,
+                "vision": false,
+                "status": "production",
+                "description": "Kimi K2.7 Code — specialized for coding and multi-step reasoning"
+            },
+            "glm-5.3-flash": {
+                "contextWindow": 128000,
+                "maxOutputTokens": 16384,
+                "vision": false,
+                "status": "production",
+                "description": "GLM 5.3 Flash — lightweight, fast conversational and instruction-following model"
+            }
+        },
+        "visionModel": "claude-sonnet-4-6",
+        "topModels": [
+            "claude-sonnet-4-6",
+            "claude-haiku-4-5",
+            "deepseek-v4-flash",
+            "gemini-3.8-flash",
+            "qwen3.8-flash"
+        ]
+    },
+    "capabilities": {
+        "text": true,
+        "streaming": true,
+        "tools": true,
+        "toolsWithStreaming": true,
+        "structuredOutput": true,
+        "structuredOutputWithTools": true,
+        "embeddings": false,
+        "thinking": false
+    },
+    "errorRules": [
+        {
+            "pattern": "该分组下模型无可用渠道|model_not_found",
+            "class": "invalid-model",
+            "message": "Model '{model}' not found or has no available channels on API Route."
+        },
+        {
+            "pattern": "无效的令牌",
+            "class": "authentication",
+            "message": "Invalid API Route API key. Check {apiKeyEnvVar}."
+        }
+    ],
+    "setup": {
+        "url": "https://api-route.com",
+        "apiKeyFormat": null,
+        "billingPolicy": "free-tier",
+        "instructions": [
+            "1. Visit: https://api-route.com and create an account",
+            "2. Generate an API key in your console / dashboard",
+            "3. Set {apiKeyEnvVar} in your .env file"
+        ]
+    },
+    "evidence": {
+        "rosterVerified": {
+            "date": "2026-09-17",
+            "method": "authenticated GET /v1/models",
+            "status": 200
+        },
+        "authProbe": {
+            "date": "2026-09-17",
+            "status": 401
+        },
+        "liveMatrix": {
+            "date": "2026-09-17",
+            "result": "Verified live against https://global.api-route.com/v1: GET /v1/models returned 70 models. Chat completions, streaming, function calling, streamed function calling, and structured JSON output (json_object and json_schema) verified. Multimodal vision verified on claude-sonnet-4-6, claude-haiku-4-5, and gemini-3.8-flash. Invalid API key returns 401 (无效的令牌) and invalid model returns 503 (model_not_found)."
+        },
+        "addedInPR": "pending"
+    }
+}

package/dist/providers/catalog/index.generated.d.ts

@@ -1,3 +1,3 @@
 import type { ProviderCatalogJson } from "../../types/index.js";
 export declare const CATALOG_JSON_ENTRIES: ProviderCatalogJson[];
-export declare const CATALOG_PROVIDER_IDS: readonly ["baseten", "cerebras", "cloudflare", "fireworks", "gmicloud", "groq", "inception-labs", "io-intelligence", "mancer", "mistral", "perplexity", "sambanova", "together-ai", "upstage", "xai"];
+export declare const CATALOG_PROVIDER_IDS: readonly ["api-route", "baseten", "cerebras", "cloudflare", "fireworks", "gmicloud", "groq", "inception-labs", "io-intelligence", "mancer", "mistral", "perplexity", "sambanova", "together-ai", "upstage", "xai"];

package/dist/providers/catalog/index.generated.js

@@ -1,5 +1,6 @@
 // GENERATED FILE — do not edit. Regenerate with `pnpm run codegen:catalog`.
 // Source of truth: the per-provider JSON files in this directory.
+import apiRouteJson from "./api-route.json" with { type: "json" };
 import basetenJson from "./baseten.json" with { type: "json" };
 import cerebrasJson from "./cerebras.json" with { type: "json" };
 import cloudflareJson from "./cloudflare.json" with { type: "json" };
@@ -16,6 +17,7 @@ import togetherAiJson from "./together-ai.json" with { type: "json" };
 import upstageJson from "./upstage.json" with { type: "json" };
 import xaiJson from "./xai.json" with { type: "json" };
 export const CATALOG_JSON_ENTRIES = [
+    apiRouteJson,
     basetenJson,
     cerebrasJson,
     cloudflareJson,
@@ -33,6 +35,7 @@ export const CATALOG_JSON_ENTRIES = [
     xaiJson,
 ];
 export const CATALOG_PROVIDER_IDS = [
+    "api-route",
     "baseten",
     "cerebras",
     "cloudflare",

package/dist/providers/catalog/schema.d.ts

@@ -73,8 +73,8 @@ export declare const providerCatalogJsonSchema: z.ZodObject<{
         class: z.ZodEnum<{
             network: "network";
             provider: "provider";
-            authentication: "authentication";
             "invalid-model": "invalid-model";
+            authentication: "authentication";
             "rate-limit": "rate-limit";
         }>;
         message: z.ZodString;