@jsonstudio/rcc 0.89.168 → 0.89.524

package/node_modules/@jsonstudio/llms/dist/telemetry/stats-center.d.ts

@@ -0,0 +1,73 @@
+export interface VirtualRouterHitEvent {
+    requestId: string;
+    timestamp: number;
+    entryEndpoint: string;
+    routeName: string;
+    pool: string;
+    providerKey: string;
+    runtimeKey?: string;
+    providerType?: string;
+    modelId?: string;
+}
+export interface ProviderUsageEvent {
+    requestId: string;
+    timestamp: number;
+    providerKey: string;
+    runtimeKey?: string;
+    providerType: string;
+    modelId?: string;
+    routeName?: string;
+    entryEndpoint?: string;
+    success: boolean;
+    latencyMs: number;
+    promptTokens?: number;
+    completionTokens?: number;
+    totalTokens?: number;
+}
+export interface RouterStatsBucket {
+    requestCount: number;
+    poolHitCount: Record<string, number>;
+    routeHitCount: Record<string, number>;
+    providerHitCount: Record<string, number>;
+}
+export interface RouterStatsSnapshot {
+    global: RouterStatsBucket;
+    byEntryEndpoint: Record<string, RouterStatsBucket>;
+}
+export interface ProviderStatsBucket {
+    requestCount: number;
+    successCount: number;
+    errorCount: number;
+    latencySumMs: number;
+    minLatencyMs: number;
+    maxLatencyMs: number;
+    usage: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
+}
+export interface ProviderStatsSnapshot {
+    global: ProviderStatsBucket;
+    byProviderKey: Record<string, ProviderStatsBucket>;
+    byRoute: Record<string, ProviderStatsBucket>;
+    byEntryEndpoint: Record<string, ProviderStatsBucket>;
+}
+export interface StatsSnapshot {
+    router: RouterStatsSnapshot;
+    providers: ProviderStatsSnapshot;
+}
+export interface StatsCenterOptions {
+    enable?: boolean;
+    autoPrintOnExit?: boolean;
+    persistPath?: string | null;
+}
+export interface StatsCenter {
+    recordVirtualRouterHit(ev: VirtualRouterHitEvent): void;
+    recordProviderUsage(ev: ProviderUsageEvent): void;
+    getSnapshot(): StatsSnapshot;
+    flushToDisk(): Promise<void>;
+    reset(): void;
+}
+export declare function initStatsCenter(options?: StatsCenterOptions): StatsCenter;
+export declare function getStatsCenter(): StatsCenter;

package/node_modules/@jsonstudio/llms/dist/telemetry/stats-center.js

@@ -0,0 +1,280 @@
+import os from 'node:os';
+import path from 'node:path';
+import fs from 'node:fs/promises';
+function createEmptyRouterBucket() {
+    return {
+        requestCount: 0,
+        poolHitCount: {},
+        routeHitCount: {},
+        providerHitCount: {}
+    };
+}
+function createEmptyProviderBucket() {
+    return {
+        requestCount: 0,
+        successCount: 0,
+        errorCount: 0,
+        latencySumMs: 0,
+        minLatencyMs: Number.POSITIVE_INFINITY,
+        maxLatencyMs: 0,
+        usage: {
+            promptTokens: 0,
+            completionTokens: 0,
+            totalTokens: 0
+        }
+    };
+}
+function createEmptySnapshot() {
+    return {
+        router: {
+            global: createEmptyRouterBucket(),
+            byEntryEndpoint: {}
+        },
+        providers: {
+            global: createEmptyProviderBucket(),
+            byProviderKey: {},
+            byRoute: {},
+            byEntryEndpoint: {}
+        }
+    };
+}
+class NoopStatsCenter {
+    recordVirtualRouterHit() { }
+    recordProviderUsage() { }
+    getSnapshot() { return createEmptySnapshot(); }
+    async flushToDisk() { }
+    reset() { }
+}
+class DefaultStatsCenter {
+    snapshot = createEmptySnapshot();
+    dirty = false;
+    flushInFlight = false;
+    persistPath;
+    constructor(persistPath) {
+        if (persistPath === null) {
+            this.persistPath = null;
+        }
+        else if (typeof persistPath === 'string' && persistPath.trim().length) {
+            this.persistPath = persistPath.trim();
+        }
+        else {
+            const base = path.join(os.homedir(), '.routecodex', 'stats');
+            this.persistPath = path.join(base, 'stats.json');
+        }
+    }
+    recordVirtualRouterHit(ev) {
+        if (!ev || !ev.routeName || !ev.providerKey) {
+            return;
+        }
+        const snap = this.snapshot;
+        this.applyRouterHitToBucket(snap.router.global, ev);
+        const entryKey = ev.entryEndpoint || 'unknown';
+        if (!snap.router.byEntryEndpoint[entryKey]) {
+            snap.router.byEntryEndpoint[entryKey] = createEmptyRouterBucket();
+        }
+        this.applyRouterHitToBucket(snap.router.byEntryEndpoint[entryKey], ev);
+        this.dirty = true;
+    }
+    recordProviderUsage(ev) {
+        if (!ev || !ev.providerKey || !ev.providerType) {
+            return;
+        }
+        const snap = this.snapshot;
+        this.applyProviderUsageToBucket(snap.providers.global, ev);
+        const providerKey = ev.providerKey;
+        if (!snap.providers.byProviderKey[providerKey]) {
+            snap.providers.byProviderKey[providerKey] = createEmptyProviderBucket();
+        }
+        this.applyProviderUsageToBucket(snap.providers.byProviderKey[providerKey], ev);
+        const routeKey = ev.routeName || 'unknown';
+        if (!snap.providers.byRoute[routeKey]) {
+            snap.providers.byRoute[routeKey] = createEmptyProviderBucket();
+        }
+        this.applyProviderUsageToBucket(snap.providers.byRoute[routeKey], ev);
+        const entryKey = ev.entryEndpoint || 'unknown';
+        if (!snap.providers.byEntryEndpoint[entryKey]) {
+            snap.providers.byEntryEndpoint[entryKey] = createEmptyProviderBucket();
+        }
+        this.applyProviderUsageToBucket(snap.providers.byEntryEndpoint[entryKey], ev);
+        this.dirty = true;
+    }
+    getSnapshot() {
+        return this.snapshot;
+    }
+    reset() {
+        this.snapshot = createEmptySnapshot();
+        this.dirty = false;
+    }
+    async flushToDisk() {
+        if (!this.persistPath || !this.dirty || this.flushInFlight) {
+            return;
+        }
+        this.flushInFlight = true;
+        try {
+            const dir = path.dirname(this.persistPath);
+            await fs.mkdir(dir, { recursive: true });
+            const payload = JSON.stringify(this.snapshot, null, 2);
+            await fs.writeFile(this.persistPath, payload, 'utf-8');
+            this.dirty = false;
+        }
+        catch {
+            // ignore persistence errors
+        }
+        finally {
+            this.flushInFlight = false;
+        }
+    }
+    applyRouterHitToBucket(bucket, ev) {
+        bucket.requestCount += 1;
+        if (ev.pool) {
+            bucket.poolHitCount[ev.pool] = (bucket.poolHitCount[ev.pool] || 0) + 1;
+        }
+        if (ev.routeName) {
+            bucket.routeHitCount[ev.routeName] = (bucket.routeHitCount[ev.routeName] || 0) + 1;
+        }
+        if (ev.providerKey) {
+            bucket.providerHitCount[ev.providerKey] = (bucket.providerHitCount[ev.providerKey] || 0) + 1;
+        }
+    }
+    applyProviderUsageToBucket(bucket, ev) {
+        bucket.requestCount += 1;
+        if (ev.success) {
+            bucket.successCount += 1;
+        }
+        else {
+            bucket.errorCount += 1;
+        }
+        if (Number.isFinite(ev.latencyMs) && ev.latencyMs >= 0) {
+            bucket.latencySumMs += ev.latencyMs;
+            if (ev.latencyMs < bucket.minLatencyMs) {
+                bucket.minLatencyMs = ev.latencyMs;
+            }
+            if (ev.latencyMs > bucket.maxLatencyMs) {
+                bucket.maxLatencyMs = ev.latencyMs;
+            }
+        }
+        if (typeof ev.promptTokens === 'number' && Number.isFinite(ev.promptTokens)) {
+            bucket.usage.promptTokens += Math.max(0, ev.promptTokens);
+        }
+        if (typeof ev.completionTokens === 'number' && Number.isFinite(ev.completionTokens)) {
+            bucket.usage.completionTokens += Math.max(0, ev.completionTokens);
+        }
+        if (typeof ev.totalTokens === 'number' && Number.isFinite(ev.totalTokens)) {
+            bucket.usage.totalTokens += Math.max(0, ev.totalTokens);
+        }
+        else {
+            const derivedTotal = (typeof ev.promptTokens === 'number' ? Math.max(0, ev.promptTokens) : 0) +
+                (typeof ev.completionTokens === 'number' ? Math.max(0, ev.completionTokens) : 0);
+            bucket.usage.totalTokens += derivedTotal;
+        }
+    }
+}
+let instance = null;
+function resolveEnableFlag(defaultValue) {
+    const raw = process.env.ROUTECODEX_STATS;
+    if (!raw)
+        return defaultValue;
+    const normalized = raw.trim().toLowerCase();
+    if (['1', 'true', 'yes', 'on'].includes(normalized))
+        return true;
+    if (['0', 'false', 'no', 'off'].includes(normalized))
+        return false;
+    return defaultValue;
+}
+function printStatsToConsole(snapshot) {
+    const router = snapshot.router;
+    const providers = snapshot.providers;
+    const totalRequests = router.global.requestCount;
+    const poolEntries = Object.entries(router.global.poolHitCount);
+    const providerEntries = Object.entries(router.global.providerHitCount);
+    // Router summary
+    // eslint-disable-next-line no-console
+    console.log('[stats] Virtual Router:');
+    // eslint-disable-next-line no-console
+    console.log(`  total requests: ${totalRequests}`);
+    if (poolEntries.length) {
+        // eslint-disable-next-line no-console
+        console.log('  pools:');
+        for (const [pool, count] of poolEntries) {
+            const ratio = totalRequests > 0 ? (count / totalRequests) * 100 : 0;
+            // eslint-disable-next-line no-console
+            console.log(`    ${pool}: ${count} (${ratio.toFixed(2)}%)`);
+        }
+    }
+    if (providerEntries.length) {
+        // eslint-disable-next-line no-console
+        console.log('  top providers:');
+        const sorted = providerEntries.sort((a, b) => b[1] - a[1]).slice(0, 5);
+        for (const [providerKey, count] of sorted) {
+            // eslint-disable-next-line no-console
+            console.log(`    ${providerKey}: ${count}`);
+        }
+    }
+    const globalProvider = providers.global;
+    const totalProviderRequests = globalProvider.requestCount;
+    const avgLatency = globalProvider.successCount > 0 ? globalProvider.latencySumMs / globalProvider.successCount : 0;
+    // Provider summary
+    // eslint-disable-next-line no-console
+    console.log('\n[stats] Providers:');
+    // eslint-disable-next-line no-console
+    console.log(`  total requests : ${totalProviderRequests} (success=${globalProvider.successCount}, error=${globalProvider.errorCount})`);
+    // eslint-disable-next-line no-console
+    console.log(`  avg latency    : ${avgLatency.toFixed(1)} ms`);
+    // eslint-disable-next-line no-console
+    console.log(`  total tokens   : prompt=${globalProvider.usage.promptTokens} completion=${globalProvider.usage.completionTokens} total=${globalProvider.usage.totalTokens}`);
+}
+export function initStatsCenter(options) {
+    if (instance) {
+        return instance;
+    }
+    const enabled = resolveEnableFlag(options?.enable ?? true);
+    if (!enabled) {
+        instance = new NoopStatsCenter();
+        return instance;
+    }
+    const center = new DefaultStatsCenter(options?.persistPath);
+    instance = center;
+    const autoPrint = options?.autoPrintOnExit !== false;
+    if (autoPrint && typeof process !== 'undefined' && typeof process.on === 'function') {
+        const handler = async () => {
+            try {
+                await center.flushToDisk();
+            }
+            catch {
+                // ignore
+            }
+            try {
+                const snapshot = center.getSnapshot();
+                printStatsToConsole(snapshot);
+            }
+            catch {
+                // ignore
+            }
+        };
+        try {
+            process.once('beforeExit', handler);
+        }
+        catch {
+            // ignore
+        }
+        try {
+            process.once('SIGINT', handler);
+        }
+        catch {
+            // ignore
+        }
+        try {
+            process.once('SIGTERM', handler);
+        }
+        catch {
+            // ignore
+        }
+    }
+    return instance;
+}
+export function getStatsCenter() {
+    if (!instance) {
+        return initStatsCenter();
+    }
+    return instance;
+}

package/node_modules/@jsonstudio/llms/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsonstudio/llms",
-  "version": "0.6.104",
+  "version": "0.6.375",
   "type": "module",
   "main": "dist/index.js",
   "module": "dist/index.js",
@@ -25,7 +25,7 @@
     "test:looprt:gemini": "npm run build && node scripts/tests/loop-rt-gemini.mjs",
     "replay:responses:chat-sse": "node scripts/exp3-responses-sse-to-chat-sse.mjs",
     "replay:responses:loop": "node scripts/exp4-responses-sse-loop.mjs",
-    "test:virtual-router": "npm run build:dev && node scripts/tests/virtual-router-dry-run.mjs",
+    "test:virtual-router": "npm run build:dev && node scripts/tests/virtual-router-dry-run.mjs && node scripts/tests/virtual-router-context.mjs",
     "test:virtual-router-health": "npm run build:dev && node scripts/tests/virtual-router-health.mjs"
   },
   "dependencies": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsonstudio/rcc",
-  "version": "0.89.168",
+  "version": "0.89.524",
   "description": "Multi-provider OpenAI proxy server with anthropic/responses/chat support (dev)",
   "type": "module",
   "main": "dist/index.js",
@@ -39,13 +39,14 @@
     "build:watch": "tsc --watch",
     "start": "npm run -s start:bg",
     "dev": "tsx watch src/index.ts",
-    "test": "jest",
-    "test:watch": "jest --watch",
-    "test:coverage": "jest --coverage",
-    "test:integration": "jest --testPathPattern=integration",
-    "test:e2e": "jest --testPathPattern=e2e",
-    "test:performance": "jest --testPathPattern=performance",
-    "test:protocol": "jest --testPathPattern=protocol-tools-e2e.spec.ts --runInBand --detectOpenHandles --forceExit",
+    "jest:run": "node --experimental-vm-modules ./node_modules/jest/bin/jest.js",
+    "test": "npm run jest:run",
+    "test:watch": "npm run jest:run -- --watch",
+    "test:coverage": "npm run jest:run -- --coverage",
+    "test:integration": "npm run jest:run -- --testPathPattern=integration",
+    "test:e2e": "npm run jest:run -- --testPathPattern=e2e",
+    "test:performance": "npm run jest:run -- --testPathPattern=performance",
+    "test:protocol": "npm run jest:run -- --testPathPattern=protocol-tools-e2e.spec.ts --runInBand --detectOpenHandles --forceExit",
     "test:dry-run": "node tests/basic-dry-run.mjs",
     "test:lmstudio-dryrun": "node tests/lmstudio-tools-bidir-dry-run.mjs",
     "lint": "eslint --no-eslintrc -c .eslintrc.json src --ext .ts --no-cache",
@@ -83,7 +84,7 @@
     "start:verify:fg": "node scripts/start-verify.mjs --mode fg --timeout 90",
     "rc-config": "node scripts/rc-config.mjs",
     "config:validate:providers": "node scripts/validate-config-providers.mjs",
-    "verify:e2e-toolcall": "node scripts/verify-e2e-toolcall.mjs",
+    "verify:e2e-toolcall": "node scripts/verify-e2e-toolcall.mjs && node scripts/verify-client-headers.mjs",
     "test:anthropic-roundtrip": "node scripts/tests/anthropic-roundtrip.mjs",
     "replay:codex-sample": "node scripts/replay-codex-sample.mjs",
     "config:update:providers": "node scripts/update-config-providers.mjs",
@@ -125,7 +126,7 @@
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.65.0",
-    "@jsonstudio/llms": "^0.6.104",
+    "@jsonstudio/llms": "^0.6.375",
     "@lmstudio/sdk": "^1.5.0",
     "@radix-ui/react-switch": "^1.2.6",
     "@types/socket.io": "^3.0.1",

package/scripts/README.md

@@ -1,20 +1,34 @@
-# RouteCodex 构建和安装脚本
+# Build & Install Scripts
 
-本目录包含用于自动构建和安装 RouteCodex 的脚本。
+> **AGENTS.md rules apply** – always build shared modules first, never skip verification, never mix dev/release modes.
 
-## 唯一安装脚本
-
-### install-user-global.sh（推荐）
+## Dev CLI (routecodex)
 
 ```bash
-# 一键构建并全局安装（使用 npm 默认全局路径，不修改前缀）
+# 1. build sharedmodule first
+npm --prefix sharedmodule/llmswitch-core run build
+
+# 2. build host
+cd - && npm run build:dev
+
+# 3. install globally
 npm run install:global
 ```
 
-脚本流程：
-- 构建 sharedmodule/llmswitch-core 与根包
-- npm pack 生成 tgz
-- 卸载全局旧版 routecodex
-- npm install -g 安装新版本
+## Release CLI (rcc)
+
+```bash
+# 1. build sharedmodule first
+npm --prefix sharedmodule/llmswitch-core run build
+
+# 2. build release variant
+npm run build:release
+
+# 3. install globally
+npm run install:release
+```
+
+## Verification
 
-> 说明：其余安装脚本已移除，请统一使用上述命令。
+- Never use `ROUTECODEX_VERIFY_SKIP=1`; golden samples are up-to-date.
+- CI runs `npm run build:dev && npm run build:release` with full verification.

package/scripts/auth-antigravity-token.mjs

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+// Antigravity OAuth authentication script
+// Usage:
+//   # 默认使用 ~/.routecodex/auth/antigravity-oauth.json（自动创建/更新）
+//   node scripts/auth-antigravity-token.mjs
+//
+//   # 或通过环境变量显式指定 token 文件（支持 ~ 展开）：
+//   // ANTIGRAVITY_TOKEN_FILE="~/.routecodex/auth/antigravity-oauth-alt.json" node scripts/auth-antigravity-token.mjs
+
+import os from 'os';
+import path from 'path';
+import fs from 'fs/promises';
+
+async function resolveAntigravityTokenPath() {
+  const envFile =
+    (process.env.ANTIGRAVITY_TOKEN_FILE && process.env.ANTIGRAVITY_TOKEN_FILE.trim()) ||
+    (process.env.ROUTECODEX_ANTIGRAVITY_TOKEN_FILE && process.env.ROUTECODEX_ANTIGRAVITY_TOKEN_FILE.trim()) ||
+    '';
+
+  if (envFile) {
+    const normalized = envFile.startsWith('~')
+      ? envFile.replace(/^~(?=$|\/)/, os.homedir())
+      : envFile;
+    return path.resolve(normalized);
+  }
+
+  const home = os.homedir();
+  return path.join(home, '.routecodex', 'auth', 'antigravity-oauth.json');
+}
+
+async function run() {
+  const tokenPath = await resolveAntigravityTokenPath();
+  const dir = path.dirname(tokenPath);
+  await fs.mkdir(dir, { recursive: true });
+  try {
+    await fs.access(tokenPath);
+  } catch {
+    await fs.writeFile(tokenPath, '{}', 'utf-8');
+  }
+
+  const { ensureValidOAuthToken } = await import('../dist/providers/auth/oauth-lifecycle.js');
+
+  console.log(`[antigravity-auth] Authenticating token: ${tokenPath}`);
+
+  await ensureValidOAuthToken(
+    'antigravity',
+    {
+      type: 'antigravity-oauth',
+      tokenFile: tokenPath
+    },
+    {
+      forceReauthorize: true,
+      openBrowser: true
+    }
+  );
+
+  console.log(`[antigravity-auth] Token saved to: ${tokenPath}`);
+}
+
+run().catch((err) => {
+  console.error('[antigravity-auth] Error:', err);
+  process.exit(1);
+});
+

package/scripts/auth-gemini-cli-token.mjs

@@ -0,0 +1,96 @@
+#!/usr/bin/env node
+// Gemini CLI OAuth authentication script
+// Usage:
+//   # 默认使用 ~/.routecodex/auth/gemini-oauth.json（自动创建/更新）
+//   node scripts/auth-gemini-cli-token.mjs
+//
+//   # 或通过环境变量显式指定 token 文件（支持 ~ 展开）：
+//   // GEMINI_CLI_TOKEN_FILE="~/.routecodex/auth/gemini-oauth-1-primary.json" node scripts/auth-gemini-cli-token.mjs
+
+import os from 'os';
+import path from 'path';
+import fs from 'fs/promises';
+
+async function resolveGeminiTokenPath() {
+  const envFile =
+    (process.env.GEMINI_CLI_TOKEN_FILE && process.env.GEMINI_CLI_TOKEN_FILE.trim()) ||
+    (process.env.ROUTECODEX_GEMINI_TOKEN_FILE && process.env.ROUTECODEX_GEMINI_TOKEN_FILE.trim()) ||
+    '';
+
+  if (envFile) {
+    const normalized = envFile.startsWith('~')
+      ? envFile.replace(/^~\//, `${os.homedir()}/`)
+      : envFile;
+    return { tokenPath: normalized, duplicates: [] };
+  }
+
+  const authDir = path.join(os.homedir(), '.routecodex', 'auth');
+  const primaryName = 'gemini-oauth.json';
+
+  let entries = [];
+  try {
+    entries = await fs.readdir(authDir);
+  } catch {
+    // directory may not exist yet
+    entries = [];
+  }
+
+  const matches = entries
+    .filter((entry) => entry.endsWith('.json'))
+    .filter((entry) => entry === primaryName || entry.startsWith('gemini-oauth-'));
+
+  matches.sort();
+  if (matches.length > 0) {
+    const canonical = path.join(authDir, matches[0]);
+    const duplicates = matches.slice(1).map((name) => path.join(authDir, name));
+    return { tokenPath: canonical, duplicates };
+  }
+
+  const canonical = path.join(authDir, primaryName);
+  return { tokenPath: canonical, duplicates: [] };
+}
+
+async function run() {
+  const { tokenPath, duplicates } = await resolveGeminiTokenPath();
+  console.log(`[gemini-cli-auth] Authenticating token: ${tokenPath}`);
+
+  // ensure token file exists so re-auth can recreate after delete
+  await fs.mkdir(path.dirname(tokenPath), { recursive: true });
+  try {
+    await fs.access(tokenPath);
+  } catch {
+    await fs.writeFile(tokenPath, '{}', 'utf-8');
+  }
+
+  const { ensureValidOAuthToken } = await import('../dist/providers/auth/oauth-lifecycle.js');
+
+  await ensureValidOAuthToken(
+    'gemini-cli',
+    {
+      type: 'gemini-cli-oauth',
+      tokenFile: tokenPath
+    },
+    {
+      forceReauthorize: true,
+      openBrowser: true
+    }
+  );
+
+  // clean up duplicate token files for the same family
+  for (const dup of duplicates) {
+    if (dup === tokenPath) continue;
+    try {
+      await fs.unlink(dup);
+      console.log(`[gemini-cli-auth] Removed duplicate token file: ${dup}`);
+    } catch {
+      // ignore
+    }
+  }
+
+  console.log(`[gemini-cli-auth] Token saved to: ${tokenPath}`);
+}
+
+run().catch((err) => {
+  console.error('[gemini-cli-auth] Error:', err);
+  process.exit(1);
+});