@juspay/neurolink 9.42.1 → 9.43.0

package/dist/lib/tasks/store/redisTaskStore.js

@@ -183,22 +183,40 @@ export class RedisTaskStore {
         const ttlSeconds = Math.ceil(ttlMs / 1000);
         // Set TTL on associated keys best-effort. A successful task write should not
         // be surfaced as a failure just because the retention metadata could not be updated.
-        client.expire(taskRunsKey(task.id), ttlSeconds).catch((err) => {
-            logger.warn("[TaskStore:Redis] Failed to set TTL on task runs key — task data may outlive retention window", {
-                taskId: task.id,
-                key: taskRunsKey(task.id),
-                ttlSeconds,
-                error: String(err),
-            });
-        });
-        client.expire(taskHistoryKey(task.id), ttlSeconds).catch((err) => {
-            logger.warn("[TaskStore:Redis] Failed to set TTL on task history key — task data may outlive retention window", {
-                taskId: task.id,
-                key: taskHistoryKey(task.id),
-                ttlSeconds,
-                error: String(err),
-            });
-        });
+        void (async () => {
+            const runsKey = taskRunsKey(task.id);
+            for (let attempt = 1; attempt <= 3; attempt++) {
+                try {
+                    await client.expire(runsKey, ttlSeconds);
+                    break;
+                }
+                catch (err) {
+                    if (attempt === 3) {
+                        logger.warn("[TaskStore:Redis] expire failed after 3 attempts on task runs key — task data may outlive retention window", { taskId: task.id, key: runsKey, ttlSeconds, err: String(err) });
+                    }
+                    else {
+                        await new Promise((r) => setTimeout(r, 100 * attempt));
+                    }
+                }
+            }
+        })();
+        void (async () => {
+            const histKey = taskHistoryKey(task.id);
+            for (let attempt = 1; attempt <= 3; attempt++) {
+                try {
+                    await client.expire(histKey, ttlSeconds);
+                    break;
+                }
+                catch (err) {
+                    if (attempt === 3) {
+                        logger.warn("[TaskStore:Redis] expire failed after 3 attempts on task history key — task data may outlive retention window", { taskId: task.id, key: histKey, ttlSeconds, err: String(err) });
+                    }
+                    else {
+                        await new Promise((r) => setTimeout(r, 100 * attempt));
+                    }
+                }
+            }
+        })();
     }
 }
 //# sourceMappingURL=redisTaskStore.js.map

package/dist/lib/types/cli.d.ts

@@ -798,6 +798,10 @@ export type ProxyState = {
     host: string;
     strategy: string;
     startTime: string;
+    ready?: boolean;
+    readyAt?: string;
+    healthPath?: string;
+    statusPath?: string;
     envFile?: string;
     /** Fallback chain from proxy config (persisted at start time) */
     fallbackChain?: FallbackInfo[];

package/dist/lib/types/proxyTypes.d.ts

@@ -548,6 +548,7 @@ export type AnthropicAuthRetryResult = {
 export type AnthropicNonOkResult = {
     response?: Response | unknown;
     continueLoop: boolean;
+    retrySameAccount?: boolean;
     lastError: unknown;
     authFailureMessage: string | null;
     sawTransientFailure: boolean;
@@ -570,6 +571,7 @@ export type PreparedAnthropicAccountAttempt = {
 };
 export type AnthropicUpstreamFetchResult = {
     continueLoop: boolean;
+    retrySameAccount?: boolean;
     response?: Response;
     lastError: unknown;
     sawRateLimit: boolean;
@@ -639,6 +641,10 @@ export type RuntimeAccountState = {
     backoffLevel: number;
     consecutiveRefreshFailures: number;
     permanentlyDisabled: boolean;
+    requestClassCooldowns?: Record<string, number>;
+    modelTierCooldowns?: Record<string, number>;
+    requestClassBackoffLevels?: Record<string, number>;
+    modelTierBackoffLevels?: Record<string, number>;
     lastToken?: string;
     lastRefreshToken?: string;
 };
@@ -689,3 +695,84 @@ export type CachedSession = {
     userId: string;
     expiresAt: number;
 };
+/** Model tier classification for proxy routing decisions. */
+export type ClaudeProxyModelTier = "opus" | "sonnet" | "haiku" | "other";
+/** Request class for proxy routing policy. */
+export type ClaudeProxyRequestClass = "multimodal" | "high-tool-count-non-stream-structured" | "strong-tool-fidelity" | "streaming-conversational" | "standard";
+/** Full classification profile for a proxy request. */
+export type ClaudeProxyRequestProfile = {
+    requestedModel: string;
+    modelTier: ClaudeProxyModelTier;
+    primaryClass: ClaudeProxyRequestClass;
+    classes: ClaudeProxyRequestClass[];
+    stream: boolean;
+    toolCount: number;
+    hasImages: boolean;
+    hasThinking: boolean;
+    hasToolHistory: boolean;
+    requiresToolUse: boolean;
+    requiresSpecificTool: boolean;
+    requiresStrongToolFidelity: boolean;
+    isHighToolCountNonStream: boolean;
+    isStreamingConversational: boolean;
+    isMultimodal: boolean;
+};
+/** Outcome of evaluating a single fallback candidate. */
+export type FallbackEligibilityDecision = {
+    provider?: string;
+    model?: string;
+    eligible: boolean;
+    reason: string;
+};
+/** A single provider attempt in the proxy translation plan. */
+export type ProxyTranslationAttempt = {
+    provider?: string;
+    model?: string;
+    label: string;
+};
+/** Ordered plan of provider attempts and skipped candidates. */
+export type ProxyTranslationPlan = {
+    profile: ClaudeProxyRequestProfile;
+    attempts: ProxyTranslationAttempt[];
+    skipped: FallbackEligibilityDecision[];
+};
+/** Discriminated union describing why a cooldown is active. */
+export type CooldownScope = {
+    scope: "request_class";
+    key: string;
+    until: number;
+} | {
+    scope: "model_tier";
+    key: string;
+    until: number;
+} | {
+    scope: "generic";
+    key: "generic";
+    until: number;
+};
+/** An account skipped during partitioning, with the cooldown that caused it. */
+export type CooldownSkippedAccount<T> = {
+    account: T;
+    cooldown: CooldownScope;
+};
+/** Mutable readiness state tracked by the proxy process. */
+export type ProxyReadinessState = {
+    startTimeMs: number;
+    acceptingConnections: boolean;
+    ready: boolean;
+    readyAtMs?: number;
+};
+/** Structured response returned by the proxy /health endpoint. */
+export type ProxyHealthResponse = {
+    status: "ok" | "starting";
+    ready: boolean;
+    acceptingConnections: boolean;
+    strategy: string;
+    passthrough: boolean;
+    version: string;
+    startedAt: string;
+    readyAt: string | null;
+    uptime: number;
+    healthPath: "/health";
+    statusPath: "/status";
+};

package/dist/lib/types/tools.d.ts

@@ -294,6 +294,8 @@ export type ToolExecutionContext = {
 export type ToolExecutionEvent = {
     type: "tool:start" | "tool:end";
     tool: string;
+    /** Compatibility alias for older consumers that expect `toolName`. */
+    toolName?: string;
     input?: unknown;
     result?: unknown;
     error?: string;
@@ -301,6 +303,22 @@ export type ToolExecutionEvent = {
     duration?: number;
     executionId: string;
 };
+/**
+ * Payload emitted for tool:start and tool:end events.
+ * Always includes both `tool` and `toolName` for backward compatibility.
+ */
+export type ToolEventPayload = {
+    tool: string;
+    toolName: string;
+    input?: unknown;
+    result?: unknown;
+    error?: string;
+    success?: boolean;
+    responseTime?: number;
+    timestamp?: number;
+    duration?: number;
+    executionId?: string;
+};
 /**
  * Tool execution summary for completed executions
  */

package/dist/lib/utils/schemaConversion.d.ts

@@ -20,6 +20,7 @@ export declare function inlineJsonSchema(schema: Record<string, unknown>, defini
  * 3. Plain JSON Schema objects (have `type`/`properties` but no `_def`) — returned as-is
  */
 export declare function convertZodToJsonSchema(zodSchema: ZodUnknownSchema): object;
+export declare function normalizeJsonSchemaObject(schema: Record<string, unknown> | undefined | null): Record<string, unknown>;
 /**
  * Check if a value is a Zod schema
  */

package/dist/lib/utils/schemaConversion.js

@@ -138,6 +138,9 @@ export function convertZodToJsonSchema(zodSchema) {
         return { type: "object", properties: {} };
     }
 }
+export function normalizeJsonSchemaObject(schema) {
+    return ensureTypeField(inlineJsonSchema(schema ? { ...schema } : { type: "object", properties: {} }));
+}
 /**
  * Ensure a JSON Schema object has a `type` field (required by Vertex/Gemini).
  */

package/dist/neurolink.js

@@ -28,6 +28,7 @@ import { getContextOverflowProvider, isContextOverflowError, parseProviderOverfl
 import { ContextBudgetExceededError } from "./context/errors.js";
 import { repairToolPairs } from "./context/toolPairRepair.js";
 import { SYSTEM_LIMITS } from "./core/constants.js";
+import { createToolEventPayload } from "./core/toolEvents.js";
 import { ConversationMemoryManager } from "./core/conversationMemoryManager.js";
 import { AIProviderFactory } from "./core/factory.js";
 import { ProviderRegistry } from "./factories/providerRegistry.js";
@@ -236,14 +237,13 @@ export class NeuroLink {
         // Emit tool end event (NeuroLink format - enhanced with result/error)
         // Serialize error to string for consumer compatibility (event listeners
         // commonly check `typeof event.error === "string"`).
-        this.emitter.emit("tool:end", {
-            toolName,
+        this.emitter.emit("tool:end", createToolEventPayload(toolName, {
             responseTime: Date.now() - startTime,
             success,
             timestamp: Date.now(),
-            result: result, // Enhanced: include actual result
-            error: error ? error.message : undefined, // Emit as string, not Error object
-        });
+            result,
+            error: error ? error.message : undefined,
+        }));
     }
     // Conversation memory support
     conversationMemory;
@@ -4662,16 +4662,31 @@ Current user's request: ${currentInput}`;
         };
         const onToolStart = (...args) => {
             const data = args[0];
-            captureEvent("tool:start", data);
+            captureEvent("tool:start", {
+                ...data,
+                toolName: data.toolName ?? data.tool,
+            });
         };
         const onToolEnd = (...args) => {
             const data = args[0];
-            captureEvent("tool:end", data);
-            if (data.result && data.result.uiComponent === true) {
+            const toolName = data.toolName ?? data.tool;
+            const responseTime = data.responseTime ?? data.duration;
+            const success = data.success ?? (data.error !== undefined ? false : undefined);
+            const augmented = {
+                ...data,
+                toolName,
+                ...(responseTime !== undefined ? { responseTime } : {}),
+                ...(success !== undefined ? { success } : {}),
+                ...(data.error !== undefined ? { error: data.error } : {}),
+            };
+            captureEvent("tool:end", augmented);
+            if (augmented.result && augmented.result.uiComponent === true) {
                 captureEvent("ui-component", {
-                    toolName: data.toolName,
-                    componentData: data.result,
+                    toolName,
+                    componentData: augmented.result,
                     timestamp: Date.now(),
+                    ...(success !== undefined ? { success } : {}),
+                    ...(responseTime !== undefined ? { responseTime } : {}),
                 });
             }
         };
@@ -5410,12 +5425,11 @@ Current user's request: ${currentInput}`;
         this.activeToolExecutions.set(executionId, context);
         this.currentStreamToolExecutions.push(context);
         // Emit event (NeuroLinkEvents format for compatibility)
-        this.emitter.emit("tool:start", {
-            tool: toolName,
+        this.emitter.emit("tool:start", createToolEventPayload(toolName, {
             input,
             timestamp: startTime,
             executionId,
-        });
+        }));
         logger.debug(`tool:start emitted for ${toolName}`, {
             toolName,
             executionId,
@@ -5473,14 +5487,15 @@ Current user's request: ${currentInput}`;
         // Store in history
         this.toolExecutionHistory.push(summary);
         // Emit event (NeuroLinkEvents format for compatibility)
-        this.emitter.emit("tool:end", {
-            tool: toolName,
+        this.emitter.emit("tool:end", createToolEventPayload(toolName, {
             result,
             error,
+            success,
+            responseTime: duration,
             timestamp: endTime,
             duration,
             executionId: finalExecutionId,
-        });
+        }));
         logger.debug(`tool:end emitted for ${toolName}`, {
             toolName,
             executionId: finalExecutionId,
@@ -6024,11 +6039,10 @@ Current user's request: ${currentInput}`;
             options,
             hasExternalManager: !!this.externalServerManager,
         });
-        this.emitter.emit("tool:start", {
-            toolName,
+        this.emitter.emit("tool:start", createToolEventPayload(toolName, {
             timestamp: executionContext.executionStartTime,
             input: params,
-        });
+        }));
         const toolInfo = this.toolRegistry.getToolInfo(toolName);
         const finalOptions = {
             timeout: options?.timeout ??

package/dist/providers/googleNativeGemini3.d.ts

@@ -38,6 +38,10 @@ export declare function sanitizeToolsForGemini(tools: Record<string, Tool>): {
     tools: Record<string, Tool>;
     dropped: string[];
 };
+export declare function normalizeToolsForJsonSchemaProvider(tools: Record<string, Tool>): {
+    tools: Record<string, Tool>;
+    normalized: string[];
+};
 /**
  * Convert Vercel AI SDK tools to @google/genai FunctionDeclarations and an execute map.
  *

package/dist/providers/googleNativeGemini3.js

@@ -12,7 +12,7 @@ import { randomUUID } from "node:crypto";
 import { jsonSchema as aiJsonSchema, tool as createAISDKTool, } from "ai";
 import { DEFAULT_MAX_STEPS, DEFAULT_TOOL_MAX_RETRIES, } from "../core/constants.js";
 import { logger } from "../utils/logger.js";
-import { convertZodToJsonSchema, inlineJsonSchema, isZodSchema, } from "../utils/schemaConversion.js";
+import { convertZodToJsonSchema, inlineJsonSchema, isZodSchema, normalizeJsonSchemaObject, } from "../utils/schemaConversion.js";
 import { createNativeThinkingConfig } from "../utils/thinkingConfig.js";
 // ── Functions ──
 /**
@@ -163,6 +163,44 @@ export function sanitizeToolsForGemini(tools) {
     }
     return { tools: sanitized, dropped };
 }
+export function normalizeToolsForJsonSchemaProvider(tools) {
+    const normalizedTools = {};
+    const normalized = [];
+    for (const [name, tool] of Object.entries(tools)) {
+        const legacyTool = tool;
+        const toolParams = legacyTool.parameters || tool.inputSchema;
+        let rawSchema;
+        if (isZodSchema(toolParams)) {
+            rawSchema = convertZodToJsonSchema(toolParams);
+        }
+        else if (toolParams && typeof toolParams === "object") {
+            rawSchema = toolParams;
+        }
+        else {
+            rawSchema = { type: "object", properties: {} };
+        }
+        if (rawSchema.jsonSchema &&
+            typeof rawSchema.jsonSchema === "object" &&
+            !rawSchema.type) {
+            rawSchema = rawSchema.jsonSchema;
+        }
+        const schemaBefore = JSON.stringify(rawSchema);
+        const normalizedSchema = normalizeJsonSchemaObject(rawSchema);
+        if (JSON.stringify(normalizedSchema) !== schemaBefore) {
+            normalized.push(name);
+        }
+        const wrappedSchema = aiJsonSchema(normalizedSchema);
+        normalizedTools[name] = {
+            ...tool,
+            inputSchema: wrappedSchema,
+            ...(legacyTool.parameters ? { parameters: wrappedSchema } : {}),
+        };
+    }
+    return {
+        tools: normalizedTools,
+        normalized,
+    };
+}
 /**
  * Convert Vercel AI SDK tools to @google/genai FunctionDeclarations and an execute map.
  *

package/dist/providers/googleVertex.js

@@ -23,7 +23,7 @@ import { convertZodToJsonSchema, inlineJsonSchema, } from "../utils/schemaConver
 import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
 import { estimateTokens } from "../utils/tokenEstimation.js";
 import { resolveToolChoice } from "../utils/toolChoice.js";
-import { buildNativeConfig, buildNativeToolDeclarations, collectStreamChunks, collectStreamChunksIncremental, computeMaxSteps as computeMaxStepsShared, createTextChannel, executeNativeToolCalls, extractTextFromParts, handleMaxStepsTermination, pushModelResponseToHistory, sanitizeToolsForGemini, } from "./googleNativeGemini3.js";
+import { buildNativeConfig, buildNativeToolDeclarations, collectStreamChunks, collectStreamChunksIncremental, computeMaxSteps as computeMaxStepsShared, createTextChannel, executeNativeToolCalls, extractTextFromParts, handleMaxStepsTermination, normalizeToolsForJsonSchemaProvider, pushModelResponseToHistory, sanitizeToolsForGemini, } from "./googleNativeGemini3.js";
 import { getModelId } from "./providerTypeUtils.js";
 // Import proper types for multimodal message handling
 // Keep-alive note: Node.js native fetch and undici (used by createProxyFetch)
@@ -878,7 +878,15 @@ export class GoogleVertexProvider extends BaseProvider {
                 Object.keys(sanitized.tools).length > 0 ? sanitized.tools : undefined;
         }
         else if (isAnthropic && Object.keys(rawTools).length > 0) {
-            tools = rawTools;
+            const normalized = normalizeToolsForJsonSchemaProvider(rawTools);
+            if (normalized.normalized.length > 0) {
+                logger.debug("[GoogleVertex] Normalized Anthropic tool schema(s)", {
+                    toolCount: normalized.normalized.length,
+                    toolNames: normalized.normalized,
+                });
+            }
+            tools =
+                Object.keys(normalized.tools).length > 0 ? normalized.tools : undefined;
         }
         else {
             tools = undefined;

package/dist/proxy/claudeFormat.js

@@ -10,6 +10,7 @@
  */
 import { jsonSchema, tool } from "ai";
 import { randomBytes } from "crypto";
+import { normalizeJsonSchemaObject } from "../utils/schemaConversion.js";
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
@@ -153,7 +154,7 @@ export function parseClaudeRequest(body) {
                 // Fallback providers consume AI SDK-style tools, not Claude wire-format
                 // tool descriptors. Wrap the raw JSON schema once here so every
                 // downstream provider sees a canonical `inputSchema` shape.
-                inputSchema: jsonSchema(t.input_schema ?? { type: "object" }),
+                inputSchema: jsonSchema(normalizeJsonSchemaObject(t.input_schema ?? { type: "object" })),
             });
         }
     }

package/dist/proxy/proxyHealth.d.ts

@@ -0,0 +1,17 @@
+import type { ProxyHealthResponse, ProxyReadinessState } from "../types/index.js";
+export type { ProxyHealthResponse, ProxyReadinessState };
+export declare function createProxyReadinessState(startTimeMs?: number): ProxyReadinessState;
+export declare function markProxyReady(state: ProxyReadinessState, readyAtMs?: number): void;
+export declare function buildProxyHealthResponse(state: ProxyReadinessState, options: {
+    strategy: string;
+    passthrough: boolean;
+    version: string;
+    now?: number;
+}): ProxyHealthResponse;
+export declare function waitForProxyReadiness(args: {
+    host: string;
+    port: number;
+    timeoutMs?: number;
+    intervalMs?: number;
+    fetchImpl?: typeof fetch;
+}): Promise<void>;

package/dist/proxy/proxyHealth.js

@@ -0,0 +1,54 @@
+export function createProxyReadinessState(startTimeMs = Date.now()) {
+    return {
+        startTimeMs,
+        acceptingConnections: false,
+        ready: false,
+    };
+}
+export function markProxyReady(state, readyAtMs = Date.now()) {
+    state.acceptingConnections = true;
+    state.ready = true;
+    state.readyAtMs = readyAtMs;
+}
+export function buildProxyHealthResponse(state, options) {
+    const now = options.now ?? Date.now();
+    return {
+        status: state.ready ? "ok" : "starting",
+        ready: state.ready,
+        acceptingConnections: state.acceptingConnections,
+        strategy: options.strategy,
+        passthrough: options.passthrough,
+        version: options.version,
+        startedAt: new Date(state.startTimeMs).toISOString(),
+        readyAt: state.readyAtMs ? new Date(state.readyAtMs).toISOString() : null,
+        uptime: Math.max(0, (now - state.startTimeMs) / 1000),
+        healthPath: "/health",
+        statusPath: "/status",
+    };
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export async function waitForProxyReadiness(args) {
+    const timeoutMs = args.timeoutMs ?? 5_000;
+    const intervalMs = args.intervalMs ?? 100;
+    const fetchImpl = args.fetchImpl ?? fetch;
+    const deadline = Date.now() + timeoutMs;
+    let lastError;
+    while (Date.now() < deadline) {
+        try {
+            const response = await fetchImpl(`http://${args.host}:${args.port}/health`, {
+                signal: AbortSignal.timeout(Math.min(intervalMs * 4, 1_000)),
+            });
+            if (response.ok) {
+                return;
+            }
+            lastError = `health endpoint returned ${response.status}`;
+        }
+        catch (error) {
+            lastError = error instanceof Error ? error.message : String(error);
+        }
+        await sleep(intervalMs);
+    }
+    throw new Error(`Proxy failed readiness check on http://${args.host}:${args.port}/health within ${timeoutMs}ms${lastError ? ` (${lastError})` : ""}`);
+}

package/dist/proxy/requestLogger.js

@@ -489,12 +489,17 @@ export async function logBodyCapture(entry) {
         : bridge.getCurrentTraceContext();
     const redactedHeaders = redactHeaders(entry.headers);
     const preparedBody = prepareRedactedBody(entry.body);
-    let stored = {};
+    let stored;
     try {
         stored = await writeBodyArtifact(entry, redactedHeaders, preparedBody.value, preparedBody.truncated);
     }
-    catch {
-        // Best-effort artifact persistence; continue with in-memory metadata only.
+    catch (writeError) {
+        logger.warn("[RequestLogger] writeBodyArtifact failed, falling back to in-memory body for OTLP", { error: writeError });
+        stored = {
+            redactedBody: preparedBody.value,
+            redactedBodyBytes: preparedBody.bytes,
+            bodyTruncated: preparedBody.truncated,
+        };
     }
     const dateStr = new Date(entry.timestamp).toISOString().split("T")[0];
     const logFile = join(logDir, `proxy-debug-${dateStr}.jsonl`);

package/dist/proxy/routingPolicy.d.ts

@@ -0,0 +1,33 @@
+import type { ClaudeProxyModelTier, ClaudeProxyRequestClass, ClaudeProxyRequestProfile, CooldownScope, CooldownSkippedAccount, FallbackEligibilityDecision, FallbackEntry, ParsedClaudeRequest, ProxyTranslationAttempt, ProxyTranslationPlan, RuntimeAccountState } from "../types/index.js";
+export type { ClaudeProxyModelTier, ClaudeProxyRequestClass, ClaudeProxyRequestProfile, CooldownScope, CooldownSkippedAccount, FallbackEligibilityDecision, ProxyTranslationAttempt, ProxyTranslationPlan, };
+export declare function inferClaudeProxyModelTier(modelName: string): ClaudeProxyModelTier;
+export declare function classifyClaudeProxyRequest(requestedModel: string, parsed: ParsedClaudeRequest): ClaudeProxyRequestProfile;
+export declare function getRequestClassCooldownKey(profile: ClaudeProxyRequestProfile): string;
+export declare function getModelTierCooldownKey(profile: ClaudeProxyRequestProfile): string;
+export declare function evaluateFallbackEligibility(profile: ClaudeProxyRequestProfile, candidate: {
+    provider?: string;
+    model?: string;
+}): FallbackEligibilityDecision;
+export declare function buildProxyTranslationPlan(primary: {
+    provider: string;
+    model?: string;
+}, fallbackChain: FallbackEntry[], requestedModel: string, parsed: ParsedClaudeRequest): ProxyTranslationPlan;
+export declare function summarizeSkippedFallbacks(plan: Pick<ProxyTranslationPlan, "profile" | "skipped">): string | null;
+export declare function getActiveCooldownScope(state: RuntimeAccountState, profile: ClaudeProxyRequestProfile, now?: number): CooldownScope | null;
+export declare function partitionAccountsByCooldown<T extends {
+    key: string;
+}>(accounts: T[], getState: (account: T) => RuntimeAccountState, profile: ClaudeProxyRequestProfile, now?: number): {
+    eligible: T[];
+    skipped: CooldownSkippedAccount<T>[];
+};
+export declare function applyRateLimitCooldownScope(args: {
+    state: RuntimeAccountState;
+    profile: ClaudeProxyRequestProfile;
+    retryAfterMs?: number;
+    now?: number;
+    capMs: number;
+}): {
+    backoffMs: number;
+    requestClassKey: string;
+    modelTierKey: string;
+};