@juspay/neurolink 12.14.21 → 12.15.1

package/dist/providers/amazonBedrock/client.js

@@ -10,6 +10,7 @@ import { createBedrockLoopAdapter } from "./loopAdapter.js";
 import { AuthenticationError, ProviderError, RateLimitError, } from "../../types/index.js";
 import { classifyProviderError } from "../../utils/errorClassifier.js";
 import { isAbortError, withTimeout } from "../../utils/errorHandling.js";
+import { ImageProcessor } from "../../utils/imageProcessor.js";
 import { logger } from "../../utils/logger.js";
 import { resolveSamplingParams } from "../../models/modelRegistry.js";
 import { buildMultimodalMessagesArray } from "../../utils/messageBuilder.js";
@@ -18,6 +19,36 @@ import { convertZodToJsonSchema } from "../../utils/schemaConversion.js";
 import { SpanKind, SpanStatusCode } from "@opentelemetry/api";
 import { bedrockTracer } from "./constants.js";
 import { loadBedrockControl } from "./utils.js";
+/**
+ * The only image formats Nova Multimodal Embeddings accepts.
+ *
+ * An allowlist rather than a derivation from the mimetype, because every
+ * shortcut here produces a value Nova rejects for some ordinary input:
+ * splitting on "/" yields `svg+xml` for an SVG and `jpeg; charset=binary`
+ * when the mimetype carries parameters, and normalising `jpeg` to `jpg` —
+ * the natural-looking direction — turns the single most common input into
+ * the one spelling that is not on this list.
+ */
+const NOVA_IMAGE_FORMATS = {
+    "image/png": "png",
+    "image/jpeg": "jpeg",
+    "image/jpg": "jpeg",
+    "image/gif": "gif",
+    "image/webp": "webp",
+};
+/**
+ * Nova's format name for `mimeType`, or undefined when Nova has no name for it.
+ *
+ * Deliberately not defaulting to png. The RAG image path accepts bmp, tiff and
+ * avif, none of which Nova names, so a default would hand AWS a BMP labelled as
+ * a PNG — bytes and declared format disagreeing, with no error and no way for
+ * the caller to tell it happened. An unnamed format is surfaced to the caller
+ * instead; see the throw at the call site.
+ */
+function novaImageFormat(mimeType) {
+    const normalized = (mimeType ?? "").split(";").at(0)?.trim().toLowerCase();
+    return NOVA_IMAGE_FORMATS[normalized ?? ""];
+}
 export class AmazonBedrockProvider extends BaseProvider {
     bedrockClient;
     conversationHistory = [];
@@ -1162,24 +1193,100 @@ export class AmazonBedrockProvider extends BaseProvider {
         return classifyProviderError(error, rules, this.providerName, this.modelName);
     }
     /**
-     * Generate embeddings for text using Amazon Bedrock embedding models
-     * Uses the native AWS SDK InvokeModel command for Titan embeddings
-     * @param text - The text to embed
+     * Generate embeddings for text or multi-modal input using Amazon Bedrock.
+     * Supports both text-only models (Titan Embed Text) and multi-modal models
+     * (Titan Embed Image, Nova Multimodal Embeddings).
+     *
+     * @param input - Text string or EmbedInput with text/image/mimeType
      * @param modelName - The embedding model to use (default: amazon.titan-embed-text-v2:0)
      * @returns Promise resolving to the embedding vector
      */
-    async embed(text, modelName) {
-        const embeddingModelName = modelName || "amazon.titan-embed-text-v2:0";
+    async embed(input, modelName) {
+        // Normalize input to EmbedInput shape
+        const embedInput = typeof input === "string" ? { text: input } : input;
+        const embeddingModelName = modelName || this.getDefaultEmbeddingModel();
+        const isNovaModel = embeddingModelName.includes("nova") &&
+            embeddingModelName.includes("multimodal");
+        const isMultiModalModel = embeddingModelName.includes("image") ||
+            embeddingModelName.includes("multimodal") ||
+            embeddingModelName === "amazon.titan-embed-image-v1" ||
+            isNovaModel;
         logger.debug("Generating embedding", {
             provider: this.providerName,
             model: embeddingModelName,
-            textLength: text.length,
+            hasText: typeof embedInput.text === "string",
+            hasImage: embedInput.image !== undefined,
+            isMultiModalModel,
         });
         try {
-            // Titan Embed models expect a specific input format
-            const requestBody = JSON.stringify({
-                inputText: text,
-            });
+            // Build request body based on model type
+            let requestBody;
+            if (embedInput.image && !isMultiModalModel) {
+                throw new ProviderError(`${this.providerName} model ${embeddingModelName} does not support image embeddings`, this.providerName);
+            }
+            if (isNovaModel) {
+                // Nova Multimodal Embeddings uses SINGLE_EMBEDDING + singleEmbeddingParams
+                // for BOTH text-only and image requests. Nova requires exactly one
+                // modality per request — combined image+text is rejected explicitly
+                // rather than silently dropping one of them.
+                if (embedInput.image && embedInput.text) {
+                    throw new ProviderError(`${this.providerName} model ${embeddingModelName} does not support combined image+text embeddings; provide exactly one of image or text`, this.providerName);
+                }
+                const singleEmbeddingParams = {
+                    embeddingPurpose: "GENERIC_RETRIEVAL",
+                };
+                if (embedInput.image) {
+                    const imageBuffer = Buffer.isBuffer(embedInput.image)
+                        ? embedInput.image
+                        : Buffer.from(embedInput.image, "base64");
+                    const imageFormat = novaImageFormat(embedInput.mimeType);
+                    if (imageFormat === undefined) {
+                        throw new ProviderError(`${this.providerName} model ${embeddingModelName} does not support image format ` +
+                            `'${embedInput.mimeType ?? "unknown"}'; supported formats are ` +
+                            `${Object.keys(NOVA_IMAGE_FORMATS).join(", ")}`, this.providerName);
+                    }
+                    singleEmbeddingParams.image = {
+                        detailLevel: "STANDARD_IMAGE",
+                        format: imageFormat,
+                        source: {
+                            // Bounded on purpose. `Buffer.toString("base64")` allocates ~4/3
+                            // the buffer in one go, so an oversized image exhausts memory
+                            // before the request is ever built. The chat-image path already
+                            // routes through this guard (messageBuilder.ts); the embed paths
+                            // never adopted it, even though ImageLoader enforces the same
+                            // ceiling for images it loads itself.
+                            bytes: ImageProcessor.safeBase64Convert(imageBuffer, "bedrock nova embed image"),
+                        },
+                    };
+                }
+                if (embedInput.text) {
+                    singleEmbeddingParams.text = {
+                        value: embedInput.text,
+                        truncationMode: "NONE",
+                    };
+                }
+                requestBody = JSON.stringify({
+                    taskType: "SINGLE_EMBEDDING",
+                    singleEmbeddingParams,
+                });
+            }
+            else if (embedInput.image) {
+                // Titan Multimodal Embeddings expects inputImage as a base64 string
+                const imageBuffer = Buffer.isBuffer(embedInput.image)
+                    ? embedInput.image
+                    : Buffer.from(embedInput.image, "base64");
+                requestBody = JSON.stringify({
+                    inputText: embedInput.text ?? "",
+                    // Same ceiling as the Nova branch above.
+                    inputImage: ImageProcessor.safeBase64Convert(imageBuffer, "bedrock titan embed image"),
+                });
+            }
+            else {
+                // Text-only embedding (Titan Embed Text)
+                requestBody = JSON.stringify({
+                    inputText: embedInput.text ?? "",
+                });
+            }
             const command = new InvokeModelCommand({
                 modelId: embeddingModelName,
                 contentType: "application/json",
@@ -1187,23 +1294,25 @@ export class AmazonBedrockProvider extends BaseProvider {
                 body: requestBody,
             });
             const response = await withTimeout(this.bedrockClient.send(command), 60_000, new Error("Bedrock embedding API call timed out"));
-            // Parse the response
+            // Parse the response — Titan returns `embedding`, Nova returns `embeddings[0].embedding`
             const responseBody = JSON.parse(new TextDecoder().decode(response.body));
-            if (!responseBody.embedding || !Array.isArray(responseBody.embedding)) {
+            const embedding = isNovaModel
+                ? responseBody.embeddings?.at(0)?.embedding
+                : responseBody.embedding;
+            if (!Array.isArray(embedding)) {
                 throw new Error("Invalid embedding response from Bedrock");
             }
             logger.debug("Embedding generated successfully", {
                 provider: this.providerName,
                 model: embeddingModelName,
-                embeddingDimension: responseBody.embedding.length,
+                embeddingDimension: embedding.length,
             });
-            return responseBody.embedding;
+            return embedding;
         }
         catch (error) {
             logger.error("Embedding generation failed", {
                 error: error instanceof Error ? error.message : String(error),
                 model: embeddingModelName,
-                textLength: text.length,
             });
             throw this.handleProviderError(error);
         }
@@ -1215,7 +1324,7 @@ export class AmazonBedrockProvider extends BaseProvider {
      * @returns Promise resolving to an array of embedding vectors
      */
     async embedMany(texts, modelName) {
-        const embeddingModelName = modelName || "amazon.titan-embed-text-v2:0";
+        const embeddingModelName = modelName || this.getDefaultEmbeddingModel();
         logger.debug("Generating batch embeddings", {
             provider: this.providerName,
             model: embeddingModelName,

package/dist/providers/cohere.d.ts

@@ -1,5 +1,5 @@
 import type { AIProviderName } from "../constants/enums.js";
-import type { NeurolinkCredentials } from "../types/index.js";
+import type { EmbedInput, NeurolinkCredentials } from "../types/index.js";
 import { OpenAIChatCompletionsProvider } from "./openaiChatCompletionsBase.js";
 /**
  * Cohere Provider — direct HTTP, no AI SDK.
@@ -41,7 +41,7 @@ export declare class CohereProvider extends OpenAIChatCompletionsProvider {
      * lives on the native API (POST /v2/embed). Documented at
      * https://docs.cohere.com/reference/embed.
      */
-    embed(text: string, modelName?: string): Promise<number[]>;
+    embed(input: string | EmbedInput, modelName?: string): Promise<number[]>;
     /**
      * Batch embedding via Cohere's native /v2/embed endpoint. Cohere caps at
      * 96 inputs per request; larger batches are chunked.

package/dist/providers/cohere.js

@@ -115,7 +115,11 @@ export class CohereProvider extends OpenAIChatCompletionsProvider {
      * lives on the native API (POST /v2/embed). Documented at
      * https://docs.cohere.com/reference/embed.
      */
-    async embed(text, modelName) {
+    async embed(input, modelName) {
+        if (typeof input !== "string" && input.image) {
+            throw new ProviderError(`${this.providerName} does not support image embeddings; provide text input`, this.providerName);
+        }
+        const text = typeof input === "string" ? input : (input.text ?? "");
         const vectors = await this.embedMany([text], modelName);
         if (!vectors[0]) {
             throw new ProviderError("Cohere /v2/embed returned no embeddings.", "cohere");

package/dist/providers/googleAiStudio/client.d.ts

@@ -1,6 +1,6 @@
 import { type AIProviderName } from "../../constants/enums.js";
 import { BaseProvider } from "../../core/baseProvider.js";
-import type { ZodUnknownSchema, EnhancedGenerateResult, TextGenerationOptions, StreamOptions, StreamResult } from "../../types/index.js";
+import type { EmbedInput, ZodUnknownSchema, EnhancedGenerateResult, TextGenerationOptions, StreamOptions, StreamResult } from "../../types/index.js";
 import type { LanguageModel, Schema } from "../../types/index.js";
 export declare class GoogleAIStudioProvider extends BaseProvider {
     private credentials?;
@@ -74,11 +74,11 @@ export declare class GoogleAIStudioProvider extends BaseProvider {
     protected getDefaultEmbeddingModel(): string;
     /**
      * Generate embeddings for text using Google AI Studio embedding models
-     * @param text - The text to embed
+     * @param input - The text to embed (string or EmbedInput)
      * @param modelName - The embedding model to use (default: gemini-embedding-001)
      * @returns Promise resolving to the embedding vector
      */
-    embed(text: string, modelName?: string): Promise<number[]>;
+    embed(input: string | EmbedInput, modelName?: string): Promise<number[]>;
     /**
      * Generate embeddings for multiple texts in a single batch
      * @param texts - The texts to embed

package/dist/providers/googleAiStudio/client.js

@@ -1571,11 +1571,15 @@ export class GoogleAIStudioProvider extends BaseProvider {
     }
     /**
      * Generate embeddings for text using Google AI Studio embedding models
-     * @param text - The text to embed
+     * @param input - The text to embed (string or EmbedInput)
      * @param modelName - The embedding model to use (default: gemini-embedding-001)
      * @returns Promise resolving to the embedding vector
      */
-    async embed(text, modelName) {
+    async embed(input, modelName) {
+        if (typeof input !== "string" && input.image) {
+            throw new ProviderError(`${this.providerName} does not support image embeddings; provide text input`, this.providerName);
+        }
+        const text = typeof input === "string" ? input : (input.text ?? "");
         const embeddingModelName = modelName || this.getDefaultEmbeddingModel() || "gemini-embedding-001";
         logger.debug("Generating embedding", {
             provider: this.providerName,

package/dist/providers/googleVertex/client.d.ts

@@ -1,7 +1,7 @@
 import type { ZodType } from "zod";
 import { AIProviderName } from "../../constants/enums.js";
 import { BaseProvider } from "../../core/baseProvider.js";
-import type { EnhancedGenerateResult, TextGenerationOptions, StreamOptions, StreamResult, VertexAnthropicMessage, ChatMessage, MinimalChatMessage } from "../../types/index.js";
+import type { EmbedInput, EnhancedGenerateResult, TextGenerationOptions, StreamOptions, StreamResult, VertexAnthropicMessage, ChatMessage, MinimalChatMessage } from "../../types/index.js";
 import type { Schema, LanguageModel } from "../../types/index.js";
 export declare function buildAnthropicHistoryMessages(conversationMessages: Array<ChatMessage | MinimalChatMessage>): VertexAnthropicMessage[];
 export declare function appendUserMessage(messages: VertexAnthropicMessage[], content: VertexAnthropicMessage["content"]): void;
@@ -424,7 +424,7 @@ export declare class GoogleVertexProvider extends BaseProvider {
      * provider", and `neurolink rag index --provider=vertex` fails even
      * though the SDK conceptually supports it.
      */
-    embed(text: string, modelName?: string): Promise<number[]>;
+    embed(input: string | EmbedInput, modelName?: string): Promise<number[]>;
     /**
      * Batch-embed an array of strings via Vertex @google/genai.
      * Mirrors {@link embed} but returns one vector per input string.

package/dist/providers/googleVertex/client.js

@@ -6500,7 +6500,11 @@ export class GoogleVertexProvider extends BaseProvider {
      * provider", and `neurolink rag index --provider=vertex` fails even
      * though the SDK conceptually supports it.
      */
-    async embed(text, modelName) {
+    async embed(input, modelName) {
+        if (typeof input !== "string" && input.image) {
+            throw new ProviderError(`${this.providerName} does not support image embeddings; provide text input`, this.providerName);
+        }
+        const text = typeof input === "string" ? input : (input.text ?? "");
         const embeddingModelName = modelName || this.getDefaultEmbeddingModel() || "text-embedding-004";
         logger.debug("Generating embedding", {
             provider: this.providerName,

package/dist/providers/jina.d.ts

@@ -1,6 +1,6 @@
 import type { AIProviderName } from "../constants/enums.js";
 import { BaseProvider } from "../core/baseProvider.js";
-import type { NeurolinkCredentials, StreamOptions, StreamResult, ValidationSchema } from "../types/index.js";
+import type { EmbedInput, NeurolinkCredentials, StreamOptions, StreamResult, ValidationSchema } from "../types/index.js";
 import type { LanguageModel } from "../types/index.js";
 /**
  * Jina AI Provider — embeddings + reranking.
@@ -23,7 +23,7 @@ export declare class JinaProvider extends BaseProvider {
     protected getAISDKModel(): LanguageModel;
     protected executeStream(_options: StreamOptions, _analysisSchema?: ValidationSchema): Promise<StreamResult>;
     protected formatProviderError(error: unknown): Error;
-    embed(text: string, modelName?: string): Promise<number[]>;
+    embed(input: string | EmbedInput, modelName?: string): Promise<number[]>;
     embedMany(texts: string[], modelName?: string): Promise<number[][]>;
     /**
      * Rerank a list of documents against a query.

package/dist/providers/jina.js

@@ -76,7 +76,11 @@ export class JinaProvider extends BaseProvider {
         }
         return new ProviderError(`Jina AI error: ${message}`, "jina");
     }
-    async embed(text, modelName) {
+    async embed(input, modelName) {
+        if (typeof input !== "string" && input.image) {
+            throw new ProviderError(`${this.providerName} does not support image embeddings; provide text input`, this.providerName);
+        }
+        const text = typeof input === "string" ? input : (input.text ?? "");
         const vectors = await this.callEmbeddings([text], modelName);
         if (!vectors[0]) {
             throw new Error("Jina AI returned no embedding for the provided text");

package/dist/providers/litellm/client.d.ts

@@ -1,5 +1,5 @@
 import type { AIProviderName } from "../../constants/enums.js";
-import type { OpenAICompatBuildBodyArgs, OpenAICompatStreamLifecycleListeners } from "../../types/index.js";
+import type { EmbedInput, OpenAICompatBuildBodyArgs, OpenAICompatStreamLifecycleListeners } from "../../types/index.js";
 import { OpenAIChatCompletionsProvider } from "../openaiChatCompletionsBase.js";
 /** Test hook: reset the discovery caches (state is module-global). */
 export declare function clearLiteLLMModelLimitsCache(): void;
@@ -87,7 +87,7 @@ export declare class LiteLLMProvider extends OpenAIChatCompletionsProvider {
     /**
      * Generate an embedding for a single text input via native /v1/embeddings.
      */
-    embed(text: string, modelName?: string): Promise<number[]>;
+    embed(input: string | EmbedInput, modelName?: string): Promise<number[]>;
     /**
      * Generate embeddings for multiple text inputs via native /v1/embeddings.
      */

package/dist/providers/litellm/client.js

@@ -466,7 +466,11 @@ export class LiteLLMProvider extends OpenAIChatCompletionsProvider {
     /**
      * Generate an embedding for a single text input via native /v1/embeddings.
      */
-    async embed(text, modelName) {
+    async embed(input, modelName) {
+        if (typeof input !== "string" && input.image) {
+            throw new ProviderError(`${this.providerName} does not support image embeddings; provide text input`, this.providerName);
+        }
+        const text = typeof input === "string" ? input : (input.text ?? "");
         const embeddingModelName = modelName ||
             process.env.LITELLM_EMBEDDING_MODEL ||
             "gemini-embedding-001";

package/dist/providers/ollama/client.d.ts

@@ -1,5 +1,5 @@
 import type { AIProviderName } from "../../constants/enums.js";
-import type { NeurolinkCredentials, StreamOptions, TextGenerationOptions } from "../../types/index.js";
+import type { EmbedInput, NeurolinkCredentials, StreamOptions, TextGenerationOptions } from "../../types/index.js";
 import { OpenAIChatCompletionsProvider } from "../openaiChatCompletionsBase.js";
 /**
  * Ollama Provider — direct HTTP, no AI SDK.
@@ -62,7 +62,7 @@ export declare class OllamaProvider extends OpenAIChatCompletionsProvider {
      * Uses `OLLAMA_EMBEDDING_MODEL` (default `nomic-embed-text`); the embedding
      * model must be pulled locally (`ollama pull nomic-embed-text`).
      */
-    embed(text: string, modelName?: string): Promise<number[]>;
+    embed(input: string | EmbedInput, modelName?: string): Promise<number[]>;
     /**
      * Generate embeddings for multiple text inputs via native /v1/embeddings.
      */

package/dist/providers/ollama/client.js

@@ -214,7 +214,11 @@ export class OllamaProvider extends OpenAIChatCompletionsProvider {
      * Uses `OLLAMA_EMBEDDING_MODEL` (default `nomic-embed-text`); the embedding
      * model must be pulled locally (`ollama pull nomic-embed-text`).
      */
-    async embed(text, modelName) {
+    async embed(input, modelName) {
+        if (typeof input !== "string" && input.image) {
+            throw new ProviderError(`${this.providerName} does not support image embeddings; provide text input`, this.providerName);
+        }
+        const text = typeof input === "string" ? input : (input.text ?? "");
         const embeddingModel = modelName ||
             process.env.OLLAMA_EMBEDDING_MODEL ||
             DEFAULT_EMBEDDING_MODEL;

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

@@ -1,5 +1,5 @@
 import type { AIProviderName } from "../../constants/enums.js";
-import type { EnhancedGenerateResult, NeurolinkCredentials, OpenAICompatStreamLifecycleListeners, TextGenerationOptions } from "../../types/index.js";
+import type { EmbedInput, EnhancedGenerateResult, NeurolinkCredentials, OpenAICompatStreamLifecycleListeners, TextGenerationOptions } from "../../types/index.js";
 import { OpenAIChatCompletionsProvider } from "../openaiChatCompletionsBase.js";
 /**
  * OpenAI Provider — direct HTTP, no AI SDK.
@@ -38,11 +38,11 @@ export declare class OpenAIProvider extends OpenAIChatCompletionsProvider {
     /**
      * Generate an embedding for a single text input via native /v1/embeddings.
      *
-     * @param text - The text to embed
+     * @param input - The text to embed (string or EmbedInput)
      * @param modelName - The embedding model to use (default: text-embedding-3-small)
      * @returns Promise resolving to the embedding vector
      */
-    embed(text: string, modelName?: string): Promise<number[]>;
+    embed(input: string | EmbedInput, modelName?: string): Promise<number[]>;
     /**
      * Generate embeddings for multiple texts in a single batch via native /v1/embeddings.
      *

package/dist/providers/openAI/client.js

@@ -220,11 +220,15 @@ export class OpenAIProvider extends OpenAIChatCompletionsProvider {
     /**
      * Generate an embedding for a single text input via native /v1/embeddings.
      *
-     * @param text - The text to embed
+     * @param input - The text to embed (string or EmbedInput)
      * @param modelName - The embedding model to use (default: text-embedding-3-small)
      * @returns Promise resolving to the embedding vector
      */
-    async embed(text, modelName) {
+    async embed(input, modelName) {
+        if (typeof input !== "string" && input.image) {
+            throw new ProviderError(`${this.providerName} does not support image embeddings; provide text input`, this.providerName);
+        }
+        const text = typeof input === "string" ? input : (input.text ?? "");
         const embeddingModelName = modelName || this.getDefaultEmbeddingModel();
         logger.debug("Generating embedding", {
             provider: this.providerName,

package/dist/providers/voyage.d.ts

@@ -1,6 +1,6 @@
 import type { AIProviderName } from "../constants/enums.js";
 import { BaseProvider } from "../core/baseProvider.js";
-import type { NeurolinkCredentials, StreamOptions, StreamResult, ValidationSchema } from "../types/index.js";
+import type { EmbedInput, NeurolinkCredentials, StreamOptions, StreamResult, ValidationSchema } from "../types/index.js";
 import type { LanguageModel } from "../types/index.js";
 /**
  * Voyage AI Provider — embedding-only.
@@ -29,7 +29,7 @@ export declare class VoyageProvider extends BaseProvider {
     protected getAISDKModel(): LanguageModel;
     protected executeStream(_options: StreamOptions, _analysisSchema?: ValidationSchema): Promise<StreamResult>;
     protected formatProviderError(error: unknown): Error;
-    embed(text: string, modelName?: string): Promise<number[]>;
+    embed(input: string | EmbedInput, modelName?: string): Promise<number[]>;
     embedMany(texts: string[], modelName?: string): Promise<number[][]>;
     /**
      * POST /embeddings — Voyage accepts up to 128 inputs per request.

package/dist/providers/voyage.js

@@ -86,7 +86,11 @@ export class VoyageProvider extends BaseProvider {
         return new ProviderError(`Voyage AI error: ${message}`, "voyage");
     }
     // ===== Embedding implementations =====
-    async embed(text, modelName) {
+    async embed(input, modelName) {
+        if (typeof input !== "string" && input.image) {
+            throw new ProviderError(`${this.providerName} does not support image embeddings; provide text input`, this.providerName);
+        }
+        const text = typeof input === "string" ? input : (input.text ?? "");
         const vectors = await this.callEmbeddings([text], modelName);
         if (!vectors[0]) {
             throw new ProviderError("Voyage AI returned no embedding for the provided text", "voyage");

package/dist/proxy/codexAccountUsage.js

@@ -103,9 +103,14 @@ function windowResetEpochSeconds(window, nowSeconds) {
     }
     return 0;
 }
-function deriveWindowStatus(usedFraction) {
-    return usedFraction >= 1 ? "rejected" : "allowed";
+/** Classify only finite, nonnegative utilization; invalid measurements stay unknown. */
+function deriveWindowStatus(percent) {
+    if (typeof percent !== "number" || !Number.isFinite(percent) || percent < 0) {
+        return "unknown";
+    }
+    return percent >= 100 ? "rejected" : "allowed";
 }
+/** Normalize a reported window while retaining uncertainty in its status. */
 function toQuotaWindow(kind, group, window, nowSeconds) {
     if (!window) {
         return null;
@@ -115,7 +120,7 @@ function toQuotaWindow(kind, group, window, nowSeconds) {
         kind,
         group,
         used,
-        status: deriveWindowStatus(used),
+        status: deriveWindowStatus(window.used_percent),
         resetsAt: windowResetEpochSeconds(window, nowSeconds),
         isActive: true,
     };
@@ -137,11 +142,16 @@ export function codexRateLimitsToQuota(rateLimits, now = Date.now()) {
         windows.push(secondaryWindow);
     }
     return {
+        unifiedStatus: rateLimits?.limit_reached === true || rateLimits?.allowed === false
+            ? "rejected"
+            : rateLimits?.allowed === true
+                ? "allowed"
+                : "unknown",
         sessionUsed,
-        sessionStatus: deriveWindowStatus(sessionUsed),
+        sessionStatus: deriveWindowStatus(primary?.used_percent),
         sessionResetAt: windowResetEpochSeconds(primary, nowSeconds),
         weeklyUsed,
-        weeklyStatus: deriveWindowStatus(weeklyUsed),
+        weeklyStatus: deriveWindowStatus(secondary?.used_percent),
         weeklyResetAt: windowResetEpochSeconds(secondary, nowSeconds),
         // Codex has no overage/fallback concept; keep neutral defaults.
         fallbackPercentage: 0,
@@ -169,7 +179,7 @@ export function parseCodexRateLimitHeaders(headers, now = Date.now()) {
         const rateLimits = "rate_limits" in parsed && parsed.rate_limits
             ? parsed.rate_limits
             : parsed;
-        return codexRateLimitsToQuota(rateLimits, now);
+        return { ...codexRateLimitsToQuota(rateLimits, now), source: "headers" };
     }
     catch {
         return null;
@@ -204,6 +214,8 @@ export async function fetchCodexAccountUsage(account, options = {}) {
         const usage = (await response.json());
         const rateLimits = usage.rate_limit
             ? {
+                allowed: usage.rate_limit.allowed,
+                limit_reached: usage.rate_limit.limit_reached,
                 primary: usage.rate_limit.primary_window,
                 secondary: usage.rate_limit.secondary_window,
             }

package/dist/proxy/codexFallback.js

@@ -8,6 +8,7 @@
  */
 import { ClaudeStreamSerializer, generateToolUseId } from "./claudeFormat.js";
 import { extractCodexUsage } from "./codexUsage.js";
+import { proxyTokenUsage } from "./proxyTokenUsage.js";
 export class CodexFallbackResponseError extends Error {
     status;
     responseBody;
@@ -367,13 +368,16 @@ export function parseCodexFallbackSSE(sse) {
         }
         const parsedUsage = extractCodexUsage(payload);
         if (parsedUsage) {
-            usage = {
-                input: parsedUsage.inputTokens,
-                output: parsedUsage.outputTokens,
-                total: parsedUsage.inputTokens + parsedUsage.outputTokens,
+            usage = proxyTokenUsage({
+                inputTokens: parsedUsage.inputTokens,
+                outputTokens: parsedUsage.outputTokens,
+                reasoningTokens: parsedUsage.reasoningTokensObserved
+                    ? parsedUsage.reasoningTokens
+                    : undefined,
                 cacheReadTokens: parsedUsage.cacheReadTokens,
                 cacheCreationTokens: parsedUsage.cacheCreationTokens,
-            };
+                inputIncludesCachedTokens: true,
+            });
         }
         textFromResponse = outputTextFromResponse(payload);
     }
@@ -516,13 +520,16 @@ export async function createCodexFallbackStream(response, model) {
                     completed = true;
                     const parsedUsage = extractCodexUsage(payload);
                     if (parsedUsage) {
-                        usage = {
-                            input: parsedUsage.inputTokens,
-                            output: parsedUsage.outputTokens,
-                            total: parsedUsage.inputTokens + parsedUsage.outputTokens,
+                        usage = proxyTokenUsage({
+                            inputTokens: parsedUsage.inputTokens,
+                            outputTokens: parsedUsage.outputTokens,
+                            reasoningTokens: parsedUsage.reasoningTokensObserved
+                                ? parsedUsage.reasoningTokens
+                                : undefined,
                             cacheReadTokens: parsedUsage.cacheReadTokens,
                             cacheCreationTokens: parsedUsage.cacheCreationTokens,
-                        };
+                            inputIncludesCachedTokens: true,
+                        });
                     }
                     const responseBody = payload.response;
                     if (isRecord(responseBody) && Array.isArray(responseBody.output)) {

package/dist/proxy/codexUsage.js

@@ -107,6 +107,9 @@ export function extractCodexUsage(payload) {
         cacheReadTokens: nonNegativeInt(inputDetails?.cached_tokens),
         cacheCreationTokens: nonNegativeInt(inputDetails?.cache_write_tokens),
         reasoningTokens: nonNegativeInt(outputDetails?.reasoning_tokens),
+        reasoningTokensObserved: typeof outputDetails?.reasoning_tokens === "number" &&
+            Number.isFinite(outputDetails.reasoning_tokens) &&
+            outputDetails.reasoning_tokens >= 0,
     };
 }
 /**