@juspay/neurolink 9.42.1 → 9.43.0

package/dist/lib/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/lib/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/lib/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/lib/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/lib/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/lib/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/lib/proxy/proxyHealth.js

@@ -0,0 +1,55 @@
+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})` : ""}`);
+}
+//# sourceMappingURL=proxyHealth.js.map

package/dist/lib/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/lib/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;
+};

package/dist/lib/proxy/routingPolicy.js

@@ -0,0 +1,255 @@
+const STREAMING_CONVERSATIONAL_TOOL_THRESHOLD = 4;
+const STRONG_TOOL_FIDELITY_THRESHOLD = 8;
+const HIGH_TOOL_COUNT_THRESHOLD = 24;
+const DEFAULT_COOLDOWN_FLOOR_MS = 1_000;
+const HIGH_TOOL_COUNT_COOLDOWN_FLOOR_MS = 120_000;
+const HIGH_FIDELITY_COOLDOWN_FLOOR_MS = 300_000;
+export function inferClaudeProxyModelTier(modelName) {
+    const normalized = modelName.toLowerCase();
+    if (normalized.includes("opus")) {
+        return "opus";
+    }
+    if (normalized.includes("sonnet")) {
+        return "sonnet";
+    }
+    if (normalized.includes("haiku")) {
+        return "haiku";
+    }
+    return "other";
+}
+function detectToolHistory(parsed) {
+    return parsed.conversationMessages.some((message) => {
+        return (message.content.includes("[tool_use:") ||
+            message.content.includes("[tool_result:"));
+    });
+}
+export function classifyClaudeProxyRequest(requestedModel, parsed) {
+    const toolCount = Object.keys(parsed.tools).length;
+    const hasImages = parsed.images.length > 0;
+    const hasThinking = !!parsed.thinkingConfig?.enabled;
+    const hasToolHistory = detectToolHistory(parsed);
+    const requiresSpecificTool = !!parsed.toolChoiceName;
+    const requiresToolUse = parsed.toolChoice === "required" || requiresSpecificTool || hasToolHistory;
+    const requiresStrongToolFidelity = toolCount >= STRONG_TOOL_FIDELITY_THRESHOLD ||
+        requiresSpecificTool ||
+        hasToolHistory;
+    const isHighToolCountNonStream = !parsed.stream && toolCount >= HIGH_TOOL_COUNT_THRESHOLD;
+    const isStreamingConversational = parsed.stream &&
+        !hasImages &&
+        toolCount <= STREAMING_CONVERSATIONAL_TOOL_THRESHOLD &&
+        !requiresStrongToolFidelity;
+    const classes = [];
+    if (hasImages) {
+        classes.push("multimodal");
+    }
+    if (isHighToolCountNonStream) {
+        classes.push("high-tool-count-non-stream-structured");
+    }
+    if (requiresStrongToolFidelity) {
+        classes.push("strong-tool-fidelity");
+    }
+    if (isStreamingConversational) {
+        classes.push("streaming-conversational");
+    }
+    if (classes.length === 0) {
+        classes.push("standard");
+    }
+    return {
+        requestedModel,
+        modelTier: inferClaudeProxyModelTier(requestedModel),
+        primaryClass: classes[0],
+        classes,
+        stream: parsed.stream,
+        toolCount,
+        hasImages,
+        hasThinking,
+        hasToolHistory,
+        requiresToolUse,
+        requiresSpecificTool,
+        requiresStrongToolFidelity,
+        isHighToolCountNonStream,
+        isStreamingConversational,
+        isMultimodal: hasImages,
+    };
+}
+export function getRequestClassCooldownKey(profile) {
+    return `${profile.primaryClass}:${profile.requestedModel.toLowerCase()}`;
+}
+export function getModelTierCooldownKey(profile) {
+    return profile.modelTier;
+}
+function getQualityGuardReason(profile, provider, _model) {
+    // Only gate auto-provider fallback (no explicit provider).
+    // Configured fallback-chain entries are always allowed through —
+    // let them attempt the request and fail naturally if the provider
+    // cannot handle it.
+    if (!provider) {
+        if (profile.modelTier === "opus" ||
+            profile.requiresStrongToolFidelity ||
+            profile.isHighToolCountNonStream) {
+            return "auto-provider fallback is disabled for requests that require contract preservation";
+        }
+        return null;
+    }
+    return null;
+}
+export function evaluateFallbackEligibility(profile, candidate) {
+    const policyBlockReason = getQualityGuardReason(profile, candidate.provider, candidate.model);
+    if (policyBlockReason) {
+        return {
+            provider: candidate.provider,
+            model: candidate.model,
+            eligible: false,
+            reason: policyBlockReason,
+        };
+    }
+    return {
+        provider: candidate.provider,
+        model: candidate.model,
+        eligible: true,
+        reason: "eligible",
+    };
+}
+export function buildProxyTranslationPlan(primary, fallbackChain, requestedModel, parsed) {
+    const profile = classifyClaudeProxyRequest(requestedModel, parsed);
+    const attempts = [
+        {
+            provider: primary.provider,
+            model: primary.model,
+            label: `${primary.provider}/${primary.model ?? "unknown"}`,
+        },
+    ];
+    const skipped = [];
+    for (const fallback of fallbackChain) {
+        if (fallback.provider === primary.provider &&
+            fallback.model === primary.model) {
+            continue;
+        }
+        const decision = evaluateFallbackEligibility(profile, fallback);
+        if (!decision.eligible) {
+            skipped.push(decision);
+            continue;
+        }
+        attempts.push({
+            provider: fallback.provider,
+            model: fallback.model,
+            label: `${fallback.provider}/${fallback.model}`,
+        });
+    }
+    if (fallbackChain.length === 0) {
+        const autoDecision = evaluateFallbackEligibility(profile, {});
+        if (autoDecision.eligible) {
+            attempts.push({ label: "auto-provider" });
+        }
+        else {
+            skipped.push(autoDecision);
+        }
+    }
+    return {
+        profile,
+        attempts,
+        skipped,
+    };
+}
+export function summarizeSkippedFallbacks(plan) {
+    if (plan.skipped.length === 0) {
+        return null;
+    }
+    const summary = plan.skipped
+        .map((decision) => {
+        const label = decision.provider
+            ? `${decision.provider}/${decision.model ?? "unknown"}`
+            : "auto-provider";
+        return `${label}: ${decision.reason}`;
+    })
+        .join("; ");
+    return `Fallback policy preserved the requested ${plan.profile.primaryClass} contract by skipping ineligible targets. ${summary}`;
+}
+export function getActiveCooldownScope(state, profile, now = Date.now()) {
+    let longest = null;
+    const requestClassKey = getRequestClassCooldownKey(profile);
+    const requestClassUntil = state.requestClassCooldowns?.[requestClassKey] ?? undefined;
+    if (requestClassUntil && requestClassUntil > now) {
+        longest = {
+            scope: "request_class",
+            key: requestClassKey,
+            until: requestClassUntil,
+        };
+    }
+    const modelTierKey = getModelTierCooldownKey(profile);
+    const modelTierUntil = state.modelTierCooldowns?.[modelTierKey] ?? undefined;
+    if (modelTierUntil &&
+        modelTierUntil > now &&
+        modelTierUntil > (longest?.until ?? 0)) {
+        longest = {
+            scope: "model_tier",
+            key: modelTierKey,
+            until: modelTierUntil,
+        };
+    }
+    if (state.coolingUntil &&
+        state.coolingUntil > now &&
+        state.coolingUntil > (longest?.until ?? 0)) {
+        longest = {
+            scope: "generic",
+            key: "generic",
+            until: state.coolingUntil,
+        };
+    }
+    return longest;
+}
+export function partitionAccountsByCooldown(accounts, getState, profile, now = Date.now()) {
+    const eligible = [];
+    const skipped = [];
+    for (const account of accounts) {
+        const cooldown = getActiveCooldownScope(getState(account), profile, now);
+        if (cooldown) {
+            skipped.push({ account, cooldown });
+            continue;
+        }
+        eligible.push(account);
+    }
+    return {
+        eligible,
+        skipped,
+    };
+}
+export function applyRateLimitCooldownScope(args) {
+    const now = args.now ?? Date.now();
+    const requestClassKey = getRequestClassCooldownKey(args.profile);
+    const modelTierKey = getModelTierCooldownKey(args.profile);
+    const rcBackoffLevels = args.state.requestClassBackoffLevels ?? {};
+    const mtBackoffLevels = args.state.modelTierBackoffLevels ?? {};
+    const scopedBackoffLevel = Math.max(rcBackoffLevels[requestClassKey] ?? 0, mtBackoffLevels[modelTierKey] ?? 0);
+    const floorMs = args.profile.modelTier === "opus" || args.profile.requiresStrongToolFidelity
+        ? HIGH_FIDELITY_COOLDOWN_FLOOR_MS
+        : args.profile.isHighToolCountNonStream
+            ? HIGH_TOOL_COUNT_COOLDOWN_FLOOR_MS
+            : DEFAULT_COOLDOWN_FLOOR_MS;
+    const baseCooldownMs = Math.max(args.retryAfterMs ?? 0, floorMs);
+    const backoffMs = Math.min(baseCooldownMs * 2 ** scopedBackoffLevel, args.capMs);
+    const until = now + backoffMs;
+    args.state.requestClassCooldowns = {
+        ...(args.state.requestClassCooldowns ?? {}),
+        [requestClassKey]: Math.max(args.state.requestClassCooldowns?.[requestClassKey] ?? 0, until),
+    };
+    args.state.modelTierCooldowns = {
+        ...(args.state.modelTierCooldowns ?? {}),
+        [modelTierKey]: Math.max(args.state.modelTierCooldowns?.[modelTierKey] ?? 0, until),
+    };
+    args.state.requestClassBackoffLevels = {
+        ...rcBackoffLevels,
+        [requestClassKey]: (rcBackoffLevels[requestClassKey] ?? 0) + 1,
+    };
+    args.state.modelTierBackoffLevels = {
+        ...mtBackoffLevels,
+        [modelTierKey]: (mtBackoffLevels[modelTierKey] ?? 0) + 1,
+    };
+    args.state.backoffLevel += 1;
+    return {
+        backoffMs,
+        requestClassKey,
+        modelTierKey,
+    };
+}
+//# sourceMappingURL=routingPolicy.js.map

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

@@ -0,0 +1,2 @@
+export declare function writeJsonSnapshotAtomically(targetPath: string, data: unknown, mode?: number): Promise<void>;
+export declare function clearSnapshotWriteLocksForTests(): void;

package/dist/lib/proxy/snapshotPersistence.js

@@ -0,0 +1,41 @@
+import { randomUUID } from "node:crypto";
+import { mkdir, rename, rm, writeFile } from "node:fs/promises";
+import { basename, dirname, join } from "node:path";
+const writeLocks = new Map();
+async function writeSnapshotFile(targetPath, payload, mode) {
+    const dir = dirname(targetPath);
+    const baseName = basename(targetPath);
+    await mkdir(dir, { recursive: true });
+    const tempPath = join(dir, `.${baseName}.${process.pid}.${randomUUID()}.tmp`);
+    try {
+        await writeFile(tempPath, payload, { mode });
+        await rename(tempPath, targetPath);
+    }
+    finally {
+        await rm(tempPath, { force: true }).catch(() => {
+            // Best-effort cleanup only.
+        });
+    }
+}
+export async function writeJsonSnapshotAtomically(targetPath, data, mode = 0o600) {
+    const payload = JSON.stringify(data, null, 2);
+    const previous = writeLocks.get(targetPath) ?? Promise.resolve();
+    const next = previous
+        .catch(() => {
+        // Preserve the queue even if a previous write failed.
+    })
+        .then(() => writeSnapshotFile(targetPath, payload, mode));
+    writeLocks.set(targetPath, next);
+    try {
+        await next;
+    }
+    finally {
+        if (writeLocks.get(targetPath) === next) {
+            writeLocks.delete(targetPath);
+        }
+    }
+}
+export function clearSnapshotWriteLocksForTests() {
+    writeLocks.clear();
+}
+//# sourceMappingURL=snapshotPersistence.js.map