@juspay/neurolink 13.8.18 → 13.8.19

package/dist/providers/openaiChatCompletionsClient.js

@@ -725,6 +725,8 @@ export const parseSSEStream = async (body, onTextDelta, onReasoningDelta) => {
     };
     const decoder = new TextDecoder();
     let parseErr;
+    // Key of the tool call the previous delta wrote to (for unindexed deltas).
+    let lastToolCallKey;
     const handleEvent = (msg) => {
         const data = msg.data;
         if (!data || data === "[DONE]") {
@@ -768,14 +770,21 @@ export const parseSSEStream = async (body, onTextDelta, onReasoningDelta) => {
         }
         if (delta?.tool_calls) {
             for (const tc of delta.tool_calls) {
-                let state = result.toolCalls.get(tc.index);
+                // Gemini's OpenAI-compatible endpoint omits `index`: an unindexed
+                // delta with an id or name starts a call, otherwise it continues one.
+                const index = tc.index ??
+                    (tc.id || tc.function?.name || lastToolCallKey === undefined
+                        ? Math.max(-1, ...result.toolCalls.keys()) + 1
+                        : lastToolCallKey);
+                lastToolCallKey = index;
+                let state = result.toolCalls.get(index);
                 if (!state) {
                     state = {
-                        id: tc.id ?? `call_${tc.index}_${Date.now()}`,
+                        id: tc.id ?? `call_${index}_${Date.now()}`,
                         name: tc.function?.name ?? "",
                         argsBuffered: "",
                     };
-                    result.toolCalls.set(tc.index, state);
+                    result.toolCalls.set(index, state);
                 }
                 else if (tc.id) {
                     state.id = tc.id;

package/dist/proxy/accountLedger.js

@@ -28,6 +28,7 @@
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { calculateCost, hasPricing } from "../utils/pricing.js";
+import { proxyTokenUsage } from "./proxyTokenUsage.js";
 /** Same pattern proxyAnalysis.ts uses, deliberately duplicated as a constant. */
 const REQUEST_FILE_PATTERN = /^proxy-\d{4}-\d{2}-\d{2}\.jsonl$/;
 /**
@@ -163,6 +164,7 @@ async function advanceCursor(fileName, cursor) {
             model: typeof record.model === "string" ? record.model : "",
             provider: typeof record.provider === "string" ? record.provider : undefined,
             inputTokens: finiteNumber(record.inputTokens),
+            inputIncludesCachedTokens: record.inputIncludesCachedTokens === true,
             outputTokens: finiteNumber(record.outputTokens),
             cacheReadTokens: finiteNumber(record.cacheReadTokens),
             cacheCreationTokens: finiteNumber(record.cacheCreationTokens),
@@ -196,6 +198,9 @@ async function advanceCursor(fileName, cursor) {
                 ...previous,
                 ...next,
                 inputTokens: Math.max(previous.inputTokens, next.inputTokens),
+                inputIncludesCachedTokens: next.inputTokens > previous.inputTokens
+                    ? next.inputIncludesCachedTokens
+                    : previous.inputIncludesCachedTokens,
                 outputTokens: Math.max(previous.outputTokens, next.outputTokens),
                 cacheReadTokens: Math.max(previous.cacheReadTokens, next.cacheReadTokens),
                 cacheCreationTokens: Math.max(previous.cacheCreationTokens, next.cacheCreationTokens),
@@ -335,14 +340,7 @@ export async function readAccountUsage(date = currentUsageDate()) {
         const provider = resolveProvider(entry);
         if (entry.model && entry.model !== "-") {
             if (hasPricing(provider, entry.model)) {
-                const cost = calculateCost(provider, entry.model, {
-                    input: entry.inputTokens,
-                    output: entry.outputTokens,
-                    total: entry.inputTokens + entry.outputTokens,
-                    cacheReadTokens: entry.cacheReadTokens,
-                    cacheCreationTokens: entry.cacheCreationTokens,
-                    cacheCreation1hTokens: entry.cacheCreation1hTokens,
-                });
+                const cost = calculateCost(provider, entry.model, proxyTokenUsage(entry));
                 row.costUsd += cost;
                 client.costUsd += cost;
             }

package/dist/proxy/geminiFormat.d.ts

@@ -18,7 +18,7 @@
  * its own usage line, so getting them wrong is visible to the user rather than
  * merely wrong in a log.
  */
-import type { ParsedGeminiRequest, StreamSerializerAdapter } from "../types/index.js";
+import type { ParsedGeminiRequest, StreamSerializerAdapter, TokenUsage } from "../types/index.js";
 /**
  * Parse a `generateContent` body into the shape the translation engine takes.
  *
@@ -46,11 +46,7 @@ export declare function parseGeminiRequest(model: string, body: Record<string, u
  * cannot drift.
  */
 export declare function renderGeminiToolUse(name: string, input: unknown): string;
-export declare function buildGeminiResponse(text: string, finishReason: string, usage: {
-    input: number;
-    output: number;
-    total: number;
-}, modelVersion: string, toolCalls?: ReadonlyArray<{
+export declare function buildGeminiResponse(text: string, finishReason: string, usage: TokenUsage, modelVersion: string, toolCalls?: ReadonlyArray<{
     toolName: string;
     args: Record<string, unknown>;
 }>): Record<string, unknown>;
@@ -81,11 +77,7 @@ export declare class GeminiStreamSerializer {
      * that is never coming; rendering it as text keeps the turn terminating.
      */
     pushToolUse(_id: string, name: string, input: unknown): string[];
-    finish(finishReason: string, usage: {
-        input: number;
-        output: number;
-        total: number;
-    }): string[];
+    finish(finishReason: string, usage: TokenUsage): string[];
     /**
      * Errors ride the stream as a Google error object.
      *

package/dist/proxy/geminiFormat.js

@@ -206,10 +206,19 @@ function toGeminiFinishReason(reason) {
     }
 }
 function usageMetadata(usage) {
+    const promptTokens = usage.input +
+        (usage.cacheReadTokens ?? 0) +
+        (usage.cacheCreationTokens ?? 0);
     return {
-        promptTokenCount: usage.input,
+        promptTokenCount: promptTokens,
         candidatesTokenCount: usage.output,
-        totalTokenCount: usage.total || usage.input + usage.output,
+        totalTokenCount: usage.total || promptTokens + usage.output,
+        ...(usage.cacheReadTokens !== undefined && {
+            cachedContentTokenCount: usage.cacheReadTokens,
+        }),
+        ...(usage.reasoning !== undefined && {
+            thoughtsTokenCount: usage.reasoning,
+        }),
     };
 }
 /** Build a complete `generateContent` response body. */

package/dist/proxy/openaiFormat.d.ts

@@ -8,7 +8,7 @@
  *
  * Reference: https://platform.openai.com/docs/api-reference/chat/create
  */
-import type { ClaudeRequest, ClaudeResponse, InternalResult, OpenAICompletionRequest, OpenAICompletionResponse, OpenAIErrorResponse, ParsedOpenAIRequest, StreamLifecycleState } from "../types/index.js";
+import type { ClaudeRequest, ClaudeResponse, InternalResult, OpenAICompletionRequest, OpenAICompletionResponse, OpenAIErrorResponse, ParsedOpenAIRequest, StreamLifecycleState, TokenUsage } from "../types/index.js";
 /** Generate a unique chat completion ID in the OpenAI format. */
 export declare function generateChatCompletionId(): string;
 /** Generate an OpenAI-format tool call ID (`call_` + random chars). */
@@ -25,9 +25,7 @@ export declare function generateOpenAIToolCallId(): string;
  * - top_p, temperature, max_tokens pass-through
  */
 export declare function parseOpenAIRequest(body: OpenAICompletionRequest): ParsedOpenAIRequest;
-/**
- * Serialize a NeuroLink GenerateResult into an OpenAI Chat Completions response.
- */
+/** Serialize a NeuroLink GenerateResult into an OpenAI Chat Completions response. */
 export declare function serializeOpenAIResponse(result: InternalResult, requestModel: string): OpenAICompletionResponse;
 /**
  * Build an OpenAI-compatible error envelope.
@@ -97,11 +95,7 @@ export declare class OpenAIStreamSerializer {
     /**
      * Finalize the stream: emit finish_reason chunk, then `data: [DONE]`.
      */
-    finish(finishReason?: string, usage?: {
-        input: number;
-        output: number;
-        total: number;
-    }): Generator<string>;
+    finish(finishReason?: string, usage?: TokenUsage): Generator<string>;
     /**
      * Emit an error event.  Transitions to terminal ERROR state.
      */

package/dist/proxy/openaiFormat.js

@@ -205,9 +205,25 @@ function mapFinishReason(finishReason) {
             return finishReason ? "stop" : null;
     }
 }
-/**
- * Serialize a NeuroLink GenerateResult into an OpenAI Chat Completions response.
- */
+/** Add cache to the prompt total; reasoning is already part of completion. */
+function toOpenAIUsage(usage) {
+    const promptTokens = (usage?.input ?? 0) +
+        (usage?.cacheReadTokens ?? 0) +
+        (usage?.cacheCreationTokens ?? 0);
+    const completionTokens = usage?.output ?? 0;
+    return {
+        prompt_tokens: promptTokens,
+        completion_tokens: completionTokens,
+        total_tokens: usage?.total ?? promptTokens + completionTokens,
+        ...(usage?.cacheReadTokens !== undefined && {
+            prompt_tokens_details: { cached_tokens: usage.cacheReadTokens },
+        }),
+        ...(usage?.reasoning !== undefined && {
+            completion_tokens_details: { reasoning_tokens: usage.reasoning },
+        }),
+    };
+}
+/** Serialize a NeuroLink GenerateResult into an OpenAI Chat Completions response. */
 export function serializeOpenAIResponse(result, requestModel) {
     const inferredFinishReason = result.toolCalls &&
         result.toolCalls.length > 0 &&
@@ -244,11 +260,7 @@ export function serializeOpenAIResponse(result, requestModel) {
                 finish_reason: mapFinishReason(inferredFinishReason),
             },
         ],
-        usage: {
-            prompt_tokens: result.usage?.input ?? 0,
-            completion_tokens: result.usage?.output ?? 0,
-            total_tokens: result.usage?.total ?? 0,
-        },
+        usage: toOpenAIUsage(result.usage),
     };
 }
 // ---------------------------------------------------------------------------
@@ -450,13 +462,7 @@ export class OpenAIStreamSerializer {
             return;
         }
         const mappedReason = mapFinishReason(finishReason) ?? "stop";
-        const usagePayload = usage
-            ? {
-                prompt_tokens: usage.input,
-                completion_tokens: usage.output,
-                total_tokens: usage.total,
-            }
-            : undefined;
+        const usagePayload = usage ? toOpenAIUsage(usage) : undefined;
         yield formatOpenAISSE(this.makeChunk({}, mappedReason, usagePayload));
         yield "data: [DONE]\n\n";
         this.state = "done";

package/dist/proxy/proxyTranslationEngine.d.ts

@@ -12,7 +12,7 @@
  * JSON handlers that accept a format discriminator.
  */
 import type { ProxyTracer } from "./proxyTracer.js";
-import type { ParsedClaudeRequest, ParsedGeminiRequest, ParsedOpenAIRequest, ProxyFormat, ProxyTranslationAttempt, ServerContext } from "../types/index.js";
+import type { ParsedClaudeRequest, ParsedGeminiRequest, ParsedOpenAIRequest, ProxyFormat, ProxyTranslationAttempt, ServerContext, TokenUsage } from "../types/index.js";
 /**
  * Extract text content from a stream chunk (handles various chunk formats).
  */
@@ -29,11 +29,7 @@ export declare function hasTranslatedOutput(collectedText: string, toolCalls: un
  * - AI SDK v4: promptTokens / completionTokens
  * - NeuroLink internal: input / output
  */
-export declare function extractUsageFromStreamResult(usage: unknown): {
-    input: number;
-    output: number;
-    total: number;
-};
+export declare function extractUsageFromStreamResult(usage: unknown): TokenUsage;
 /**
  * Detect which proxy format a request is using based on path and headers.
  */

package/dist/proxy/proxyTranslationEngine.js

@@ -77,17 +77,25 @@ export function hasTranslatedOutput(collectedText, toolCalls) {
  * - NeuroLink internal: input / output
  */
 export function extractUsageFromStreamResult(usage) {
-    if (!usage || typeof usage !== "object") {
-        return { input: 0, output: 0, total: 0 };
-    }
-    const u = usage;
-    const input = (typeof u.inputTokens === "number" ? u.inputTokens : 0) ||
-        (typeof u.promptTokens === "number" ? u.promptTokens : 0) ||
-        (typeof u.input === "number" ? u.input : 0);
-    const output = (typeof u.outputTokens === "number" ? u.outputTokens : 0) ||
-        (typeof u.completionTokens === "number" ? u.completionTokens : 0) ||
-        (typeof u.output === "number" ? u.output : 0);
-    return { input, output, total: input + output };
+    const observed = readTranslationUsage(usage);
+    const cacheReadTokens = observed.cacheReadTokens ?? 0;
+    const cacheCreationTokens = observed.cacheCreationTokens ?? 0;
+    const input = observed.inputIncludesCachedTokens
+        ? Math.max(0, (observed.inputTokens ?? 0) - cacheReadTokens - cacheCreationTokens)
+        : (observed.inputTokens ?? 0);
+    const output = observed.outputTokens ?? 0;
+    return {
+        input,
+        output,
+        total: input + cacheReadTokens + cacheCreationTokens + output,
+        ...(observed.cacheReadTokens !== undefined ? { cacheReadTokens } : {}),
+        ...(observed.cacheCreationTokens !== undefined
+            ? { cacheCreationTokens }
+            : {}),
+        ...(observed.reasoningTokens !== undefined
+            ? { reasoning: observed.reasoningTokens }
+            : {}),
+    };
 }
 // ---------------------------------------------------------------------------
 // Format detection
@@ -250,11 +258,11 @@ function defaultFinishReason(format) {
     return format === "claude" ? "end_turn" : "stop";
 }
 /** Preserve unknown usage as absent; zero is only reported when observed. */
-function translationUsage(result) {
-    const raw = result?.usage;
-    if (!raw) {
+function readTranslationUsage(usage) {
+    if (!usage || typeof usage !== "object") {
         return {};
     }
+    const raw = usage;
     const number = (...values) => values.find((value) => typeof value === "number" && Number.isFinite(value) && value >= 0);
     const details = raw.outputTokenDetails;
     const inputs = raw.inputTokenDetails;
@@ -275,6 +283,9 @@ function translationUsage(result) {
         reasoningTokens: number(raw.reasoningTokens, raw.reasoning, details?.reasoningTokens),
     };
 }
+function translationUsage(result) {
+    return readTranslationUsage(result?.usage);
+}
 /** Shared request owner, independent of a consumer asking for another chunk. */
 function createTranslationRequest(args) {
     const { ctx, requestModel, parsed, tracer, requestStartTime, stream } = args;

package/dist/proxy/routingPolicy.d.ts

@@ -14,6 +14,8 @@ export declare function buildProxyTranslationPlan(primary: {
 }, fallbackChain: FallbackEntry[], requestedModel: string, _parsed?: ParsedClaudeRequest, allowAutoFallback?: boolean): ProxyTranslationPlan;
 /**
  * Parse the retry-after header from an upstream 429 response.
- * Returns milliseconds to wait, or 0 if no valid header present.
+ *
+ * @param retryAfterHeader - The raw Retry-After header string or null
+ * @returns Milliseconds to wait (minimum 1000ms if valid), or 0 if no valid header present
  */
 export declare function parseRetryAfterMs(retryAfterHeader: string | null): number;

package/dist/proxy/routingPolicy.js

@@ -1,3 +1,4 @@
+import { parseRetryAfterHeaderValue } from "../utils/retryAfter.js";
 export function inferClaudeProxyModelTier(modelName) {
     const normalized = modelName.toLowerCase();
     if (normalized.includes("opus")) {
@@ -59,19 +60,17 @@ export function buildProxyTranslationPlan(primary, fallbackChain, requestedModel
 // ---------------------------------------------------------------------------
 /**
  * Parse the retry-after header from an upstream 429 response.
- * Returns milliseconds to wait, or 0 if no valid header present.
+ *
+ * @param retryAfterHeader - The raw Retry-After header string or null
+ * @returns Milliseconds to wait (minimum 1000ms if valid), or 0 if no valid header present
  */
 export function parseRetryAfterMs(retryAfterHeader) {
     if (!retryAfterHeader) {
         return 0;
     }
-    const seconds = parseInt(retryAfterHeader, 10);
-    if (!Number.isNaN(seconds)) {
-        return Math.max(1, seconds) * 1000;
-    }
-    const date = new Date(retryAfterHeader);
-    if (!Number.isNaN(date.getTime())) {
-        return Math.max(1000, date.getTime() - Date.now());
+    const delay = parseRetryAfterHeaderValue(retryAfterHeader);
+    if (delay !== undefined) {
+        return Math.max(1000, delay);
     }
     return 0;
 }

package/dist/types/openaiCompatible.d.ts

@@ -129,7 +129,7 @@ export type OpenAICompatStreamDelta = {
     role?: OpenAICompatChatRole;
     content?: string | null;
     tool_calls?: Array<{
-        index: number;
+        index?: number;
         id?: string;
         type?: "function";
         function?: {

package/dist/types/proxy.d.ts

@@ -1,5 +1,6 @@
 import type { ProxyTokenBudgetLease, ProxyTokenBudgetSnapshot } from "./proxyBudget.js";
 import type { CodexRuntimeAccount } from "./codex.js";
+import type { TokenUsage } from "./analytics.js";
 import type { JsonObject, JsonValue } from "./common.js";
 import type { ProxyContextEvidence, ProxyPreparedContext } from "./proxyContext.js";
 /**
@@ -258,14 +259,7 @@ export type InternalResult = {
     finishReason?: string;
     /** Thinking/reasoning text from provider (Anthropic thinking blocks, Gemini thought parts) */
     reasoning?: string;
-    usage?: {
-        input: number;
-        output: number;
-        total: number;
-        cacheCreationTokens?: number;
-        cacheReadTokens?: number;
-        reasoning?: number;
-    };
+    usage?: TokenUsage;
     toolCalls?: Array<{
         toolCallId: string;
         toolName: string;
@@ -3524,11 +3518,7 @@ export type StreamSerializerAdapter = {
     start(): Iterable<string>;
     pushDelta(text: string): Iterable<string>;
     pushToolUse(id: string, name: string, input: unknown): Iterable<string>;
-    finish(finishReason: string, usage: {
-        input: number;
-        output: number;
-        total: number;
-    }): Iterable<string>;
+    finish(finishReason: string, usage: TokenUsage): Iterable<string>;
     emitError(message: string): Iterable<string>;
 };
 /** OpenAI content part in a user message. */
@@ -3615,6 +3605,12 @@ export type OpenAIUsage = {
     prompt_tokens: number;
     completion_tokens: number;
     total_tokens: number;
+    prompt_tokens_details?: {
+        cached_tokens: number;
+    };
+    completion_tokens_details?: {
+        reasoning_tokens: number;
+    };
 };
 /** OpenAI non-streaming response. */
 export type OpenAICompletionResponse = {

package/dist/types/proxyClient.d.ts

@@ -268,6 +268,8 @@ export type ProxyLedgerEntry = {
     model: string;
     provider?: string;
     inputTokens: number;
+    /** Native Codex input includes cache reads and writes. */
+    inputIncludesCachedTokens: boolean;
     outputTokens: number;
     cacheReadTokens: number;
     cacheCreationTokens: number;

package/dist/utils/retryAfter.d.ts

@@ -1,3 +1,35 @@
+/**
+ * Parses a duration string (e.g., "6m0s", "30s", "1h30m", "500ms") into milliseconds.
+ *
+ * @param raw - The raw duration string
+ * @returns Duration in milliseconds, or undefined if invalid
+ */
+export declare function parseDurationMs(raw: string): number | undefined;
+/**
+ * Parses a single Retry-After header value into milliseconds.
+ *
+ * Checks in strict order:
+ * 1. Strict numeric seconds (e.g. "5", "120", "1.5") without truncation of dates or durations
+ * 2. HTTP-date or RFC 3339 / ISO 8601 date (e.g. "2026-10-18T12:00:00Z" or "Sun, 18 Oct 2026 12:00:00 GMT")
+ * 3. Duration string (e.g. "6m0s", "30s", "1h30m", "500ms")
+ *
+ * @param value - The header value string
+ * @returns Milliseconds to wait, or undefined if not parseable
+ */
+export declare function parseRetryAfterHeaderValue(value: string | null | undefined): number | undefined;
+/**
+ * Parses X-RateLimit-Reset header value into milliseconds until reset.
+ *
+ * Handles:
+ * - Delta seconds when value < 1e9 (e.g. "30", "60")
+ * - Epoch seconds when 1e9 <= value <= 1e12
+ * - Epoch milliseconds when value > 1e12
+ * - Fallback to date or duration strings
+ *
+ * @param value - The X-RateLimit-Reset header value
+ * @returns Milliseconds until reset, or undefined if not parseable
+ */
+export declare function parseRateLimitResetValue(value: string | null | undefined): number | undefined;
 /**
  * Parse standard and commonly used rate-limit response headers.
  *

package/dist/utils/retryAfter.js

@@ -1,3 +1,10 @@
+/**
+ * Retrieves a header value case-insensitively from either a Headers object or a plain record.
+ *
+ * @param headers - The HTTP headers object or record
+ * @param headerName - The case-insensitive name of the header to retrieve
+ * @returns The header value, or null if not found
+ */
 function getHeader(headers, headerName) {
     if ("get" in headers && typeof headers.get === "function") {
         return headers.get(headerName);
@@ -10,6 +17,128 @@ function getHeader(headers, headerName) {
     }
     return null;
 }
+/**
+ * Parses a duration string (e.g., "6m0s", "30s", "1h30m", "500ms") into milliseconds.
+ *
+ * @param raw - The raw duration string
+ * @returns Duration in milliseconds, or undefined if invalid
+ */
+export function parseDurationMs(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    // Must consist of one or more [number][unit] components
+    const durationPattern = /^(\d+(?:\.\d+)?(?:ms|s|m|h))+$/i;
+    if (!durationPattern.test(trimmed)) {
+        return undefined;
+    }
+    const tokenRegex = /(\d+(?:\.\d+)?)(ms|s|m|h)/gi;
+    let totalMs = 0;
+    let match;
+    let matchedLength = 0;
+    while ((match = tokenRegex.exec(trimmed)) !== null) {
+        matchedLength += match[0].length;
+        const num = parseFloat(match[1]);
+        const unit = match[2].toLowerCase();
+        switch (unit) {
+            case "h":
+                totalMs += num * 3600 * 1000;
+                break;
+            case "m":
+                totalMs += num * 60 * 1000;
+                break;
+            case "s":
+                totalMs += num * 1000;
+                break;
+            case "ms":
+                totalMs += num;
+                break;
+        }
+    }
+    return matchedLength === trimmed.length ? Math.round(totalMs) : undefined;
+}
+/**
+ * Parses a single Retry-After header value into milliseconds.
+ *
+ * Checks in strict order:
+ * 1. Strict numeric seconds (e.g. "5", "120", "1.5") without truncation of dates or durations
+ * 2. HTTP-date or RFC 3339 / ISO 8601 date (e.g. "2026-10-18T12:00:00Z" or "Sun, 18 Oct 2026 12:00:00 GMT")
+ * 3. Duration string (e.g. "6m0s", "30s", "1h30m", "500ms")
+ *
+ * @param value - The header value string
+ * @returns Milliseconds to wait, or undefined if not parseable
+ */
+export function parseRetryAfterHeaderValue(value) {
+    if (!value) {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    // 1. Strict numeric representation (delta seconds)
+    // Note: Avoid parseInt, which reads leading digits from dates ("2026-10-13..." -> 2026) or durations ("6m0s" -> 6)
+    if (/^\d+(?:\.\d+)?$/.test(trimmed)) {
+        const seconds = Number(trimmed);
+        if (Number.isFinite(seconds) && seconds >= 0) {
+            return Math.round(seconds * 1000);
+        }
+    }
+    // 2. HTTP-date or RFC 3339 / ISO 8601 date
+    const parsedDate = Date.parse(trimmed);
+    if (Number.isFinite(parsedDate)) {
+        return Math.max(0, parsedDate - Date.now());
+    }
+    // 3. Duration string (e.g. "6m0s", "30s", "500ms")
+    const duration = parseDurationMs(trimmed);
+    if (duration !== undefined && duration >= 0) {
+        return duration;
+    }
+    return undefined;
+}
+/**
+ * Parses X-RateLimit-Reset header value into milliseconds until reset.
+ *
+ * Handles:
+ * - Delta seconds when value < 1e9 (e.g. "30", "60")
+ * - Epoch seconds when 1e9 <= value <= 1e12
+ * - Epoch milliseconds when value > 1e12
+ * - Fallback to date or duration strings
+ *
+ * @param value - The X-RateLimit-Reset header value
+ * @returns Milliseconds until reset, or undefined if not parseable
+ */
+export function parseRateLimitResetValue(value) {
+    if (!value) {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    if (/^\d+(?:\.\d+)?$/.test(trimmed)) {
+        const num = Number(trimmed);
+        if (Number.isFinite(num) && num >= 0) {
+            if (num < 1e9) {
+                // Delta seconds (e.g. 30, 60, 300)
+                return Math.round(num * 1000);
+            }
+            // Unix epoch timestamp
+            const resetTime = num > 1e12 ? num : num * 1000;
+            return Math.max(0, Math.round(resetTime - Date.now()));
+        }
+    }
+    const parsedDate = Date.parse(trimmed);
+    if (Number.isFinite(parsedDate)) {
+        return Math.max(0, parsedDate - Date.now());
+    }
+    const duration = parseDurationMs(trimmed);
+    if (duration !== undefined && duration >= 0) {
+        return duration;
+    }
+    return undefined;
+}
 /**
  * Parse standard and commonly used rate-limit response headers.
  *
@@ -19,21 +148,16 @@ function getHeader(headers, headerName) {
 export function parseRetryAfterMs(headers) {
     const retryAfter = getHeader(headers, "Retry-After");
     if (retryAfter) {
-        const seconds = parseInt(retryAfter, 10);
-        if (!Number.isNaN(seconds)) {
-            return Math.max(0, seconds * 1000);
-        }
-        const retryDate = new Date(retryAfter);
-        if (!Number.isNaN(retryDate.getTime())) {
-            return Math.max(0, retryDate.getTime() - Date.now());
+        const delay = parseRetryAfterHeaderValue(retryAfter);
+        if (delay !== undefined) {
+            return delay;
         }
     }
     const rateLimitReset = getHeader(headers, "X-RateLimit-Reset");
     if (rateLimitReset) {
-        const resetTimestamp = parseInt(rateLimitReset, 10);
-        if (!Number.isNaN(resetTimestamp)) {
-            const resetTime = resetTimestamp > 1e12 ? resetTimestamp : resetTimestamp * 1000;
-            return Math.max(0, resetTime - Date.now());
+        const delay = parseRateLimitResetValue(rateLimitReset);
+        if (delay !== undefined) {
+            return delay;
         }
     }
     if (getHeader(headers, "X-RateLimit-Remaining") === "0") {

package/dist/workflow/workflows/adaptiveWorkflow.d.ts

@@ -42,7 +42,7 @@ export declare const QUALITY_MAX_WORKFLOW: WorkflowConfig;
  *
  * Optimizes for speed with quality fallback:
  * 1. Fast tier: Single fast model (GPT-4o-mini)
- * 2. Balanced tier: If fast fails, use Gemini 2.0
+ * 2. Balanced tier: If fast fails, use Gemini 3.8 Flash
  * 3. Quality tier: If both fail, use GPT-4o
  */
 export declare const SPEED_FIRST_WORKFLOW: WorkflowConfig;
@@ -51,7 +51,7 @@ export declare const SPEED_FIRST_WORKFLOW: WorkflowConfig;
  *
  * Balances speed, cost, and quality:
  * 1. Standard tier (parallel): GPT-4o-mini + Gemini Flash
- * 2. Premium tier (parallel): GPT-4o + Claude 3.5 if standard uncertain
+ * 2. Premium tier (parallel): GPT-4o + Claude Sonnet 4.6 if standard uncertain
  */
 export declare const BALANCED_ADAPTIVE_WORKFLOW: WorkflowConfig;
 /**