@juspay/neurolink 10.1.2 → 10.2.1

package/dist/cli/commands/proxy.js

@@ -41,6 +41,8 @@ const _require = createRequire(import.meta.url);
 const PROXY_VERSION = packageJson.version;
 const PROXY_TELEMETRY_SCRIPT_PATH = fileURLToPath(new URL("../../../scripts/observability/manage-local-openobserve.sh", import.meta.url));
 const PROXY_LIFECYCLE_SHUTDOWN_TIMEOUT_MS = 5_000;
+const LEGACY_STATUS_ACCOUNT_CACHE_TTL_MS = 5_000;
+let legacyStatusAccountCache;
 // Allowed drift between a pid's OS-reported start time and the persisted
 // ProxySupervisorState.startTime before processLooksLikeProxySupervisor
 // treats it as a confident mismatch (recycled pid). Generous on purpose:
@@ -323,6 +325,34 @@ async function resolveStatusPrimaryAccount(proxyConfig) {
         source: "fallback",
     };
 }
+async function resolveLegacyStatusAccountLabel(storedAnthropicAccountCount) {
+    if (storedAnthropicAccountCount !== 0) {
+        return null;
+    }
+    const credentialsPath = join(homedir(), ".neurolink", "anthropic-credentials.json");
+    const now = Date.now();
+    if (legacyStatusAccountCache?.credentialsPath === credentialsPath &&
+        legacyStatusAccountCache.expiresAt > now) {
+        return legacyStatusAccountCache.label;
+    }
+    let label = null;
+    try {
+        const { readFile } = await import("node:fs/promises");
+        const parsed = JSON.parse(await readFile(credentialsPath, "utf8"));
+        if (parsed.oauth?.accessToken) {
+            label = parsed.email?.trim() || "legacy-default";
+        }
+    }
+    catch {
+        label = null;
+    }
+    legacyStatusAccountCache = {
+        credentialsPath,
+        expiresAt: now + LEGACY_STATUS_ACCOUNT_CACHE_TTL_MS,
+        label,
+    };
+    return label;
+}
 /**
  * Check if the launchd service is loaded and actively managing the proxy.
  * Returns true if launchctl reports the service as running.
@@ -1492,23 +1522,32 @@ export async function createProxyStartApp(params) {
         const activeAccountAllowlist = runtimeConfig
             ? runtimeConfig.accountAllowlist
             : params.accountAllowlist;
-        const { getStats } = await import("../../lib/proxy/usageStats.js");
+        const { getReconciledStats, getUsageStatsPersistenceStatus } = await import("../../lib/proxy/usageStats.js");
         const { loadAccountCooldowns } = await import("../../lib/proxy/accountCooldown.js");
-        const stats = getStats();
+        const stats = await getReconciledStats();
         const runtimeState = loadProxyState();
         const supervisorState = loadProxySupervisorState();
         const updateState = loadUpdateState();
         const cooldowns = await loadAccountCooldowns();
         const storedAccountKeys = new Set();
+        const disabledAccountKeys = new Set();
+        let accountInventoryLoaded = false;
         try {
             const { tokenStore } = await import("../../lib/auth/tokenStore.js");
             for (const key of await tokenStore.listByPrefix("anthropic:")) {
                 storedAccountKeys.add(normalizeAnthropicAccountKey(key));
             }
+            for (const key of await tokenStore.listDisabled()) {
+                disabledAccountKeys.add(normalizeAnthropicAccountKey(key));
+            }
+            accountInventoryLoaded = true;
         }
         catch (err) {
             logger.debug(`[proxy] /status: failed to resolve account cooldown labels: ${err instanceof Error ? err.message : String(err)}`);
         }
+        const legacyAccountLabel = accountInventoryLoaded
+            ? await resolveLegacyStatusAccountLabel(storedAccountKeys.size)
+            : null;
         const now = Date.now();
         const health = buildProxyHealthResponse(readiness, {
             strategy: activeStrategy,
@@ -1530,6 +1569,7 @@ export async function createProxyStartApp(params) {
             version: PROXY_VERSION,
             health,
             stats: {
+                startedAt: stats.startedAt,
                 totalAttempts: stats.totalAttempts,
                 totalAttemptErrors: stats.totalAttemptErrors,
                 totalRequests: stats.totalRequests,
@@ -1540,13 +1580,25 @@ export async function createProxyStartApp(params) {
                 totalQuotaRateLimits: stats.totalQuotaRateLimits,
                 accounts: Object.values(stats.accounts).map((account) => {
                     const normalizedKey = normalizeAnthropicAccountKey(account.label);
+                    const isLegacyAccount = account.type === "oauth" && account.label === legacyAccountLabel;
                     const accountKey = storedAccountKeys.has(normalizedKey)
                         ? normalizedKey
-                        : account.label === "env"
-                            ? ENV_ANTHROPIC_ACCOUNT_KEY
-                            : account.type === "oauth"
-                                ? LEGACY_ANTHROPIC_ACCOUNT_KEY
+                        : isLegacyAccount
+                            ? LEGACY_ANTHROPIC_ACCOUNT_KEY
+                            : account.label === "env"
+                                ? ENV_ANTHROPIC_ACCOUNT_KEY
                                 : normalizedKey;
+                    const isStored = storedAccountKeys.has(accountKey) || isLegacyAccount;
+                    const cooling = (cooldowns[accountKey]?.coolingUntil ?? 0) > now;
+                    const accountStatus = disabledAccountKeys.has(accountKey)
+                        ? "disabled"
+                        : !isAccountAllowed(accountKey, activeAccountAllowlist)
+                            ? "excluded"
+                            : accountInventoryLoaded && account.type === "oauth" && !isStored
+                                ? "removed"
+                                : cooling
+                                    ? "cooling"
+                                    : "active";
                     return {
                         label: account.label,
                         type: account.type,
@@ -1558,10 +1610,12 @@ export async function createProxyStartApp(params) {
                         rateLimits: account.rateLimitCount,
                         transientRateLimits: account.transientRateLimitCount,
                         quotaRateLimits: account.quotaRateLimitCount,
-                        cooling: (cooldowns[accountKey]?.coolingUntil ?? 0) > now,
+                        cooling,
+                        status: accountStatus,
                     };
                 }),
                 primaryAccount,
+                persistence: getUsageStatsPersistenceStatus(),
             },
             activity: (() => {
                 const activity = getProxyActivitySnapshot();
@@ -1875,10 +1929,17 @@ function registerProxyShutdownHandlers(params) {
                 logger.error(`[proxy] failed to drain server during shutdown: ${error instanceof Error ? error.message : String(error)}`);
             }
         }
-        try {
-            await withTimeout(flushProxyLifecycleEvents(), PROXY_LIFECYCLE_SHUTDOWN_TIMEOUT_MS, "Timed out flushing proxy lifecycle metadata during shutdown");
+        const usageStatsFlush = import("../../lib/proxy/usageStats.js").then(({ flushUsageStats }) => flushUsageStats());
+        const [usageStatsFlushResult, lifecycleFlushResult] = await Promise.allSettled([
+            withTimeout(usageStatsFlush, PROXY_LIFECYCLE_SHUTDOWN_TIMEOUT_MS, "Timed out flushing proxy usage statistics during shutdown"),
+            withTimeout(flushProxyLifecycleEvents(), PROXY_LIFECYCLE_SHUTDOWN_TIMEOUT_MS, "Timed out flushing proxy lifecycle metadata during shutdown"),
+        ]);
+        if (usageStatsFlushResult.status === "rejected") {
+            const error = usageStatsFlushResult.reason;
+            logger.warn(`[proxy] usage statistics flush failed during shutdown: ${error instanceof Error ? error.message : String(error)}`);
         }
-        catch (error) {
+        if (lifecycleFlushResult.status === "rejected") {
+            const error = lifecycleFlushResult.reason;
             logger.debug(`[proxy] lifecycle metadata flush failed during shutdown: ${error instanceof Error ? error.message : String(error)}`);
         }
         try {
@@ -2284,9 +2345,10 @@ async function startProxyCommandHandler(argv) {
         }
         // In dev mode: redirect writable state to .neurolink-dev/ and skip singleton check
         let devPaths;
+        const { resolveProxyPaths, resolveProxyUsageStatsPath } = await import("../../lib/proxy/proxyPaths.js");
+        const proxyPaths = resolveProxyPaths(isDev);
         if (isDev) {
-            const { resolveProxyPaths } = await import("../../lib/proxy/proxyPaths.js");
-            devPaths = resolveProxyPaths(true);
+            devPaths = proxyPaths;
             setProxyStateDir(devPaths.stateDir);
             const { initAccountQuota } = await import("../../lib/proxy/accountQuota.js");
             initAccountQuota(devPaths.quotaFile);
@@ -2301,6 +2363,15 @@ async function startProxyCommandHandler(argv) {
         if (!isDev && !socketWorker) {
             await ensureProxyStartAllowed(spinner);
         }
+        const { initUsageStats, getUsageStatsPersistenceStatus } = await import("../../lib/proxy/usageStats.js");
+        await initUsageStats(resolveProxyUsageStatsPath(proxyPaths));
+        const usageStatsPersistence = getUsageStatsPersistenceStatus();
+        if (usageStatsPersistence.lastError) {
+            logger.warn(`[proxy] usage statistics persistence unavailable: ${usageStatsPersistence.lastError}`);
+        }
+        else if (usageStatsPersistence.lastRecoveryAt) {
+            logger.warn(`[proxy] recovered corrupt usage statistics state at ${new Date(usageStatsPersistence.lastRecoveryAt).toISOString()}`);
+        }
         const baseEnv = { ...process.env };
         const envResolution = resolveProxyEnvFile({
             explicitEnvFile: argv.envFile,
@@ -2485,7 +2556,7 @@ function printStatusStats(stats) {
             String(account.success ?? 0),
             String(account.errors ?? 0),
             String(account.rateLimits ?? 0),
-            account.cooling ? "cooling" : "active",
+            account.status ?? (account.cooling ? "cooling" : "active"),
         ]);
         const widths = headers.map((header, index) => Math.max(header.length, ...rows.map((row) => row[index].length)));
         const numericColumns = new Set([2, 3, 4, 5]);
@@ -2503,7 +2574,7 @@ function printStatusStats(stats) {
             const statusStart = formatted.length - widths[6];
             const prefix = formatted.slice(0, statusStart);
             const paddedStatus = formatted.slice(statusStart);
-            console.info(`    ${chalk.cyan(prefix.slice(0, widths[0]))}${prefix.slice(widths[0])}${status === "cooling" ? chalk.red(paddedStatus) : chalk.green(paddedStatus)}`);
+            console.info(`    ${chalk.cyan(prefix.slice(0, widths[0]))}${prefix.slice(widths[0])}${status === "active" ? chalk.green(paddedStatus) : status === "cooling" ? chalk.red(paddedStatus) : chalk.yellow(paddedStatus)}`);
         }
     }
 }

package/dist/lib/providers/azureOpenai.d.ts

@@ -22,6 +22,12 @@ export declare class AzureOpenAIProvider extends OpenAIChatCompletionsProvider {
     protected readonly azureDeploymentPathPrefix: string;
     protected readonly useMaxCompletionTokensOverride?: boolean;
     constructor(modelName?: string, sdk?: unknown, _region?: string, credentials?: NeurolinkCredentials["azure"]);
+    /**
+     * Azure OpenAI natively supports `response_format: json_schema` together
+     * with tool calling in one request, so structured output stays
+     * wire-enforced mid-loop instead of deferring to post-hoc coercion.
+     */
+    protected suppressResponseFormatWithTools(): boolean;
     protected getProviderName(): AIProviderName;
     /**
      * The "default model" for Azure is the deployment name — it's the

package/dist/lib/providers/azureOpenai.js

@@ -139,6 +139,14 @@ export class AzureOpenAIProvider extends OpenAIChatCompletionsProvider {
     // ===========================================================================
     // Abstract-hook implementations
     // ===========================================================================
+    /**
+     * Azure OpenAI natively supports `response_format: json_schema` together
+     * with tool calling in one request, so structured output stays
+     * wire-enforced mid-loop instead of deferring to post-hoc coercion.
+     */
+    suppressResponseFormatWithTools() {
+        return false;
+    }
     getProviderName() {
         return "azure";
     }

package/dist/lib/providers/openAI.d.ts

@@ -16,6 +16,12 @@ import { OpenAIChatCompletionsProvider } from "./openaiChatCompletionsBase.js";
  */
 export declare class OpenAIProvider extends OpenAIChatCompletionsProvider {
     constructor(modelName?: string, sdk?: unknown, _region?: string, credentials?: NeurolinkCredentials["openai"]);
+    /**
+     * OpenAI natively supports `response_format: json_schema` together with
+     * tool calling in one request, so structured output stays wire-enforced
+     * mid-loop instead of deferring to post-hoc coercion.
+     */
+    protected suppressResponseFormatWithTools(): boolean;
     protected getProviderName(): AIProviderName;
     protected getDefaultModel(): string;
     formatProviderError(error: unknown): Error;

package/dist/lib/providers/openAI.js

@@ -74,6 +74,14 @@ export class OpenAIProvider extends OpenAIChatCompletionsProvider {
     // ===========================================================================
     // Abstract hook implementations
     // ===========================================================================
+    /**
+     * OpenAI natively supports `response_format: json_schema` together with
+     * tool calling in one request, so structured output stays wire-enforced
+     * mid-loop instead of deferring to post-hoc coercion.
+     */
+    suppressResponseFormatWithTools() {
+        return false;
+    }
     getProviderName() {
         return AIProviderNameEnum.OPENAI;
     }

package/dist/lib/providers/openaiChatCompletionsBase.d.ts

@@ -62,6 +62,21 @@ export declare abstract class OpenAIChatCompletionsProvider extends BaseProvider
      * downgraded `json_schema` to `json_object`. Subclasses replicate that here.
      */
     protected adjustResponseFormat(rf: OpenAICompatResponseFormat | undefined, _modelId: string): OpenAICompatResponseFormat | undefined;
+    /**
+     * When true (default), `response_format` is NOT sent on requests that carry
+     * tools. The AI SDK sets responseFormat on EVERY step of a tool loop, and
+     * generic/proxy backends (LiteLLM→vllm/GLM, openai-compatible, local
+     * servers) may silently honor it over tool calling — answering with
+     * final-shape JSON on step 1 instead of running the agentic loop. No error
+     * is raised, so the runtime tools↔schema conflict detector cannot catch it.
+     * The schema is still enforced post-hoc (GenerationHandler coerces the final
+     * text against it) — the same contract as the Gemini tools↔schema exclusion.
+     * Mirrors the streaming path, which never sends response_format.
+     *
+     * Backends with first-party support for tools + json_schema in one request
+     * (OpenAI, Azure OpenAI) override this to false.
+     */
+    protected suppressResponseFormatWithTools(): boolean;
     /**
      * Hook to adjust the fully-built wire request body before it is sent, on
      * both the streaming and non-streaming paths. Default identity. Override for

package/dist/lib/providers/openaiChatCompletionsBase.js

@@ -76,6 +76,23 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
     adjustResponseFormat(rf, _modelId) {
         return rf;
     }
+    /**
+     * When true (default), `response_format` is NOT sent on requests that carry
+     * tools. The AI SDK sets responseFormat on EVERY step of a tool loop, and
+     * generic/proxy backends (LiteLLM→vllm/GLM, openai-compatible, local
+     * servers) may silently honor it over tool calling — answering with
+     * final-shape JSON on step 1 instead of running the agentic loop. No error
+     * is raised, so the runtime tools↔schema conflict detector cannot catch it.
+     * The schema is still enforced post-hoc (GenerationHandler coerces the final
+     * text against it) — the same contract as the Gemini tools↔schema exclusion.
+     * Mirrors the streaming path, which never sends response_format.
+     *
+     * Backends with first-party support for tools + json_schema in one request
+     * (OpenAI, Azure OpenAI) override this to false.
+     */
+    suppressResponseFormatWithTools() {
+        return true;
+    }
     /**
      * Hook to adjust the fully-built wire request body before it is sent, on
      * both the streaming and non-streaming paths. Default identity. Override for
@@ -221,6 +238,7 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
         const adjustResponseFormat = this.adjustResponseFormat.bind(this);
         const adjustRequestBody = this.adjustRequestBody.bind(this);
         const adjustBodyAfter400 = this.adjustBodyAfter400.bind(this);
+        const suppressResponseFormatWithTools = this.suppressResponseFormatWithTools.bind(this);
         const getTimeoutForOptions = (opts) => this.getTimeout((opts ?? {}));
         return {
             specificationVersion: "v3",
@@ -229,7 +247,9 @@ export class OpenAIChatCompletionsProvider extends BaseProvider {
             supportedUrls: {},
             doGenerate: async (options) => {
                 const baseMessages = messageBuilderToOpenAI(options.prompt);
-                const responseFormat = options.responseFormat
+                const hasTools = Array.isArray(options.tools) && options.tools.length > 0;
+                const responseFormat = options.responseFormat &&
+                    !(hasTools && suppressResponseFormatWithTools())
                     ? adjustResponseFormat(v3ResponseFormatToOpenAI(options.responseFormat), modelId)
                     : undefined;
                 // ensureJsonWordInBody runs LAST — on the body after adjustRequestBody —

package/dist/lib/proxy/proxyPaths.d.ts

@@ -14,3 +14,4 @@
  */
 import type { ProxyPaths } from "../types/index.js";
 export declare function resolveProxyPaths(dev: boolean): ProxyPaths;
+export declare function resolveProxyUsageStatsPath(paths: ProxyPaths): string;

package/dist/lib/proxy/proxyPaths.js

@@ -22,6 +22,7 @@ export function resolveProxyPaths(dev) {
             logsDir: join(base, "logs"),
             quotaFile: join(base, "account-quotas.json"),
             cooldownFile: join(base, "account-cooldowns.json"),
+            statsFile: join(base, "proxy-usage-stats.json"),
             isDev: true,
         };
     }
@@ -31,7 +32,11 @@ export function resolveProxyPaths(dev) {
         logsDir: join(base, "logs"),
         quotaFile: join(base, "account-quotas.json"),
         cooldownFile: join(base, "account-cooldowns.json"),
+        statsFile: join(base, "proxy-usage-stats.json"),
         isDev: false,
     };
 }
+export function resolveProxyUsageStatsPath(paths) {
+    return paths.statsFile ?? join(paths.stateDir, "proxy-usage-stats.json");
+}
 //# sourceMappingURL=proxyPaths.js.map

package/dist/lib/proxy/usageStats.d.ts

@@ -1,13 +1,67 @@
 /**
- * Proxy Usage Statistics
- * Tracks per-account request counts, token usage, and error rates.
- * In-memory only — resets on proxy restart.
+ * Proxy usage statistics with restart- and handoff-safe persistence.
+ *
+ * Request handlers update memory synchronously. Small deltas are merged into a
+ * shared snapshot asynchronously, under a cross-process lock, so overlapping
+ * rolling workers cannot overwrite each other's counters.
  */
-import type { AccountStats, ProxyStats } from "../types/index.js";
+import type { AccountStats, ProxyStats, ProxyStatsPersistenceStatus, ProxyUsageStatsStoreOptions } from "../types/index.js";
+export declare class ProxyUsageStatsStore {
+    private readonly now;
+    private readonly flushIntervalMs;
+    private readonly lockTimeoutMs;
+    private readonly staleLockMs;
+    private filePath?;
+    private stats;
+    private pending;
+    private pendingMutations;
+    private inFlightMutations;
+    private revision;
+    private flushTimer;
+    private readonly flushMutex;
+    private lastFlushedAt?;
+    private lastReconciledAt?;
+    private lastRecoveryAt?;
+    private lastError?;
+    constructor(options?: ProxyUsageStatsStoreOptions);
+    initialize(filePath?: string): Promise<void>;
+    recordAttempt(accountLabel: string, accountType: string): void;
+    recordFinalSuccess(accountLabel?: string, accountType?: string): void;
+    recordAttemptError(accountLabel: string, accountType: string, status: number, rateLimitKind?: "transient" | "quota"): void;
+    recordFinalError(_status: number, accountLabel?: string, accountType?: string): void;
+    getStats(): ProxyStats;
+    getAccountStats(label: string): AccountStats | undefined;
+    getPersistenceStatus(): ProxyStatsPersistenceStatus;
+    flush(): Promise<void>;
+    reconcile(): Promise<ProxyStats>;
+    resetMemory(): void;
+    resetForTests(): Promise<void>;
+    private markMutation;
+    private applyAttempt;
+    private applyFinalSuccess;
+    private applyAttemptError;
+    private applyFinalError;
+    private ensureAccount;
+    private scheduleFlush;
+    private cancelFlushTimer;
+    private readSnapshot;
+    private applySnapshot;
+    private recoverCorruptSnapshot;
+    private quarantineCorruptSnapshot;
+    private pruneCorruptSnapshots;
+    private describeError;
+}
+export declare function initUsageStats(filePath: string): Promise<void>;
 export declare function recordAttempt(accountLabel: string, accountType: string): void;
 export declare function recordFinalSuccess(accountLabel?: string, accountType?: string): void;
 export declare function recordAttemptError(accountLabel: string, accountType: string, status: number, rateLimitKind?: "transient" | "quota"): void;
 export declare function recordFinalError(_status: number, accountLabel?: string, accountType?: string): void;
 export declare function getStats(): ProxyStats;
+export declare function getReconciledStats(): Promise<ProxyStats>;
 export declare function getAccountStats(label: string): AccountStats | undefined;
+export declare function getUsageStatsPersistenceStatus(): ProxyStatsPersistenceStatus;
+export declare function flushUsageStats(): Promise<void>;
+/** Reset process-local counters while intentionally preserving durable state. */
 export declare function resetStats(): void;
+/** Disconnect persistence and clear singleton state between isolated tests. */
+export declare function resetUsageStatsForTests(): Promise<void>;