@juspay/neurolink 12.49.3 → 12.49.5

package/dist/constants/contextWindows.d.ts

@@ -56,6 +56,17 @@ export declare function getRuntimeOutputCeiling(provider: string, model?: string
 export declare function clearRuntimeOutputCeiling(provider: string, model: string): void;
 /** Test hook: clear runtime-discovered output ceilings (state is module-global). */
 export declare function clearRuntimeOutputCeilings(): void;
+/**
+ * `us.anthropic.claude-sonnet-4-6` -> `anthropic.claude-sonnet-4-6`.
+ *
+ * Undefined for any other shape, so an id that merely starts with `us.` is
+ * never rewritten. Removes one geography at most: no vendor is a geography.
+ *
+ * Every Bedrock table keyed by bare ids (context windows here, output ceilings
+ * in `getSafeMaxTokens`) goes through this one function, so they cannot
+ * disagree about which ids are cross-region profile ids.
+ */
+export declare function stripBedrockGeoPrefix(model: string): string | undefined;
 /**
  * Resolve context window size for a provider/model combination.
  *
@@ -81,6 +92,10 @@ export declare function clearRuntimeOutputCeilings(): void;
  *     MODEL_CONTEXT_WINDOWS.mistral values).
  *  2. Exact model match under provider in static registry
  *  3. Prefix match under provider in static registry
+ *  3.5 Bedrock only: an id shaped `<geography>.<vendor>.<model>` (a
+ *      cross-region inference profile) is resolved again from step 0 without
+ *      the geography. Every step above saw the id as given, so an explicit row
+ *      or discovered window for the prefixed id still wins.
  *  4. Provider's _default in static registry
  *  5. Global DEFAULT_CONTEXT_WINDOW
  */

package/dist/constants/contextWindows.js

@@ -14,6 +14,7 @@ import { DynamicModelProvider } from "../core/dynamicModels.js";
 import { logger } from "../utils/logger.js";
 import { resolveManifestEntryStrict } from "../models/manifestRegistry.js";
 import { getCatalogJsonEntries } from "../providers/catalog/loader.js";
+import { BedrockModels } from "./enums.js";
 /**
  * Per-provider context window blocks for the 9 JSON-catalog providers
  * (cerebras, cloudflare, fireworks, groq, mistral, perplexity, sambanova,
@@ -478,6 +479,48 @@ export function clearRuntimeOutputCeiling(provider, model) {
 export function clearRuntimeOutputCeilings() {
     RUNTIME_OUTPUT_CEILINGS.clear();
 }
+/**
+ * Geographies AWS puts in front of a model id to name a cross-region inference
+ * profile (`us.anthropic.claude-sonnet-4-6`). For many models that prefixed id
+ * is the only one a caller can invoke, but the Bedrock table above is keyed by
+ * bare ids, apart from one explicit `us.` row. AWS lists the prefixes on each
+ * model card, not in one place, and the set differs by model, so it is closed
+ * on purpose: a geography added later keeps taking the Bedrock default instead
+ * of being guessed at.
+ */
+const BEDROCK_GEO_PREFIXES = new Set([
+    "us",
+    "eu",
+    "apac",
+    "jp",
+    "au",
+    "in",
+    "us-gov",
+    "global",
+]);
+/** Vendor segment of every id `BedrockModels` ships: `anthropic`, `amazon`, `meta`, ... */
+const BEDROCK_VENDORS = new Set(Object.values(BedrockModels)
+    .map((id) => id.split(".")[0])
+    .filter((vendor) => !BEDROCK_GEO_PREFIXES.has(vendor)));
+/**
+ * `us.anthropic.claude-sonnet-4-6` -> `anthropic.claude-sonnet-4-6`.
+ *
+ * Undefined for any other shape, so an id that merely starts with `us.` is
+ * never rewritten. Removes one geography at most: no vendor is a geography.
+ *
+ * Every Bedrock table keyed by bare ids (context windows here, output ceilings
+ * in `getSafeMaxTokens`) goes through this one function, so they cannot
+ * disagree about which ids are cross-region profile ids.
+ */
+export function stripBedrockGeoPrefix(model) {
+    const [geo, vendor, ...rest] = model.split(".");
+    if (rest.length === 0 ||
+        !BEDROCK_GEO_PREFIXES.has(geo) ||
+        !BEDROCK_VENDORS.has(vendor)) {
+        return undefined;
+    }
+    return model.slice(geo.length + 1);
+}
 /**
  * Resolve context window size for a provider/model combination.
  *
@@ -503,6 +546,10 @@ export function clearRuntimeOutputCeilings() {
  *     MODEL_CONTEXT_WINDOWS.mistral values).
  *  2. Exact model match under provider in static registry
  *  3. Prefix match under provider in static registry
+ *  3.5 Bedrock only: an id shaped `<geography>.<vendor>.<model>` (a
+ *      cross-region inference profile) is resolved again from step 0 without
+ *      the geography. Every step above saw the id as given, so an explicit row
+ *      or discovered window for the prefixed id still wins.
  *  4. Provider's _default in static registry
  *  5. Global DEFAULT_CONTEXT_WINDOW
  */
@@ -565,6 +612,10 @@ export function getContextWindowSize(provider, model) {
             }
         }
     }
+    const bareModel = canonical === "bedrock" && model ? stripBedrockGeoPrefix(model) : undefined;
+    if (bareModel !== undefined) {
+        return getContextWindowSize(provider, bareModel);
+    }
     return providerWindows._default ?? DEFAULT_CONTEXT_WINDOW;
 }
 /**

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

@@ -112,6 +112,14 @@ export declare class AmazonBedrockProvider extends BaseProvider {
      * @returns Promise resolving to the embedding vector
      */
     embed(input: string | EmbedInput, modelName?: string): Promise<number[]>;
+    /**
+     * One InvokeModel round trip. Resolves to the vector the model returned
+     * (empty or not), or `undefined` when the answer carries no embedding array.
+     * What that means is for `embed` and `embedMany` to decide, outside this
+     * try: inside it, handleProviderError would wrap the message in a second
+     * provider error and run it through its keyword rules.
+     */
+    private requestEmbedding;
     /**
      * Generate embeddings for multiple texts in a single batch
      * @param texts - The texts to embed

package/dist/providers/amazonBedrock/client.js

@@ -1542,9 +1542,28 @@ export class AmazonBedrockProvider extends BaseProvider {
      * @returns Promise resolving to the embedding vector
      */
     async embed(input, modelName) {
+        const embeddingModelName = modelName || this.getDefaultEmbeddingModel();
+        const embedding = await this.requestEmbedding(input, embeddingModelName);
+        if (!embedding || embedding.length === 0) {
+            throw new ProviderError("No embedding returned from Bedrock", this.providerName);
+        }
+        logger.debug("Embedding generated successfully", {
+            provider: this.providerName,
+            model: embeddingModelName,
+            embeddingDimension: embedding.length,
+        });
+        return embedding;
+    }
+    /**
+     * One InvokeModel round trip. Resolves to the vector the model returned
+     * (empty or not), or `undefined` when the answer carries no embedding array.
+     * What that means is for `embed` and `embedMany` to decide, outside this
+     * try: inside it, handleProviderError would wrap the message in a second
+     * provider error and run it through its keyword rules.
+     */
+    async requestEmbedding(input, embeddingModelName) {
         // 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") ||
@@ -1639,15 +1658,7 @@ export class AmazonBedrockProvider extends BaseProvider {
             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: embedding.length,
-            });
-            return embedding;
+            return Array.isArray(embedding) ? embedding : undefined;
         }
         catch (error) {
             logger.error("Embedding generation failed", {
@@ -1670,15 +1681,9 @@ export class AmazonBedrockProvider extends BaseProvider {
             model: embeddingModelName,
             count: texts.length,
         });
+        let rows;
         try {
-            const embeddings = await Promise.all(texts.map((text) => this.embed(text, embeddingModelName)));
-            logger.debug("Batch embeddings generated successfully", {
-                provider: this.providerName,
-                model: embeddingModelName,
-                count: embeddings.length,
-                embeddingDimension: embeddings[0]?.length,
-            });
-            return embeddings;
+            rows = await Promise.all(texts.map((text) => this.requestEmbedding(text, embeddingModelName)));
         }
         catch (error) {
             logger.error("Batch embedding generation failed", {
@@ -1688,5 +1693,25 @@ export class AmazonBedrockProvider extends BaseProvider {
             });
             throw this.handleProviderError(error);
         }
+        // Checked after the try on purpose: inside it, handleProviderError would
+        // wrap this message in a second provider error and run it through its
+        // keyword rules.
+        const embeddings = rows.map((values, index) => {
+            if (!values || values.length === 0) {
+                logger.error("Batch embedding returned no values", {
+                    model: embeddingModelName,
+                    index,
+                });
+                throw new ProviderError(`Embedding for the text at index ${index} came back without values`, this.providerName);
+            }
+            return values;
+        });
+        logger.debug("Batch embeddings generated successfully", {
+            provider: this.providerName,
+            model: embeddingModelName,
+            count: embeddings.length,
+            embeddingDimension: embeddings[0]?.length,
+        });
+        return embeddings;
     }
 }

package/dist/providers/googleVertex/client.js

@@ -7292,6 +7292,7 @@ export class GoogleVertexProvider extends BaseProvider {
             model: embeddingModelName,
             count: texts.length,
         });
+        let rows;
         try {
             const effectiveLocation = resolveVertexRegionForModel(embeddingModelName, undefined);
             const client = await this.createVertexGenAIClient(effectiveLocation);
@@ -7299,14 +7300,7 @@ export class GoogleVertexProvider extends BaseProvider {
                 model: embeddingModelName,
                 contents: texts,
             });
-            const embeddings = (result.embeddings || []).map((e) => e.values || []);
-            logger.debug("Batch embeddings generated successfully", {
-                provider: this.providerName,
-                model: embeddingModelName,
-                count: embeddings.length,
-                embeddingDimension: embeddings[0]?.length,
-            });
-            return embeddings;
+            rows = (result.embeddings || []).map((e) => e.values);
         }
         catch (error) {
             logger.error("Batch embedding generation failed", {
@@ -7316,6 +7310,35 @@ export class GoogleVertexProvider extends BaseProvider {
             });
             throw this.handleProviderError(error);
         }
+        // One vector per text, or fail: a dropped or empty row would pair later
+        // texts with the wrong vectors, or score 0 downstream. Checked after the
+        // try on purpose: inside it, handleProviderError would wrap this message
+        // in a second provider error and run it through its keyword rules.
+        if (rows.length !== texts.length) {
+            logger.error("Batch embedding returned the wrong number of vectors", {
+                model: embeddingModelName,
+                expected: texts.length,
+                received: rows.length,
+            });
+            throw new ProviderError(`Embedding response held ${rows.length} vectors for ${texts.length} texts`, this.providerName);
+        }
+        const embeddings = rows.map((values, index) => {
+            if (!values || values.length === 0) {
+                logger.error("Batch embedding returned no values", {
+                    model: embeddingModelName,
+                    index,
+                });
+                throw new ProviderError(`Embedding for the text at index ${index} came back without values`, this.providerName);
+            }
+            return values;
+        });
+        logger.debug("Batch embeddings generated successfully", {
+            provider: this.providerName,
+            model: embeddingModelName,
+            count: embeddings.length,
+            embeddingDimension: embeddings[0]?.length,
+        });
+        return embeddings;
     }
 }
 export default GoogleVertexProvider;

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

@@ -92,5 +92,10 @@ export declare class LiteLLMProvider extends OpenAIChatCompletionsProvider {
      * Generate embeddings for multiple text inputs via native /v1/embeddings.
      */
     embedMany(texts: string[], modelName?: string): Promise<number[][]>;
+    /**
+     * One non-empty vector per input, or fail: a dropped or empty row would
+     * pair later texts with the wrong vectors, or score 0 downstream.
+     */
+    private requireEmbeddings;
     private callEmbeddings;
 }

package/dist/providers/litellm/client.js

@@ -474,7 +474,8 @@ export class LiteLLMProvider extends OpenAIChatCompletionsProvider {
         const embeddingModelName = modelName ||
             process.env.LITELLM_EMBEDDING_MODEL ||
             "gemini-embedding-001";
-        const [embedding] = await this.callEmbeddings(embeddingModelName, [text], "embed");
+        const rows = await this.callEmbeddings(embeddingModelName, [text], "embed");
+        const [embedding] = this.requireEmbeddings(rows, 1, embeddingModelName);
         return embedding;
     }
     /**
@@ -484,7 +485,34 @@ export class LiteLLMProvider extends OpenAIChatCompletionsProvider {
         const embeddingModelName = modelName ||
             process.env.LITELLM_EMBEDDING_MODEL ||
             "gemini-embedding-001";
-        return this.callEmbeddings(embeddingModelName, texts, "embedMany");
+        const rows = await this.callEmbeddings(embeddingModelName, texts, "embedMany");
+        return this.requireEmbeddings(rows, texts.length, embeddingModelName);
+    }
+    /**
+     * One non-empty vector per input, or fail: a dropped or empty row would
+     * pair later texts with the wrong vectors, or score 0 downstream.
+     */
+    requireEmbeddings(rows, inputCount, modelName) {
+        if (rows.length !== inputCount) {
+            logger.error("Embedding response held the wrong number of vectors", {
+                provider: this.providerName,
+                model: modelName,
+                expected: inputCount,
+                received: rows.length,
+            });
+            throw new ProviderError(`Embedding response held ${rows.length} vectors for ${inputCount} texts`, this.providerName);
+        }
+        return rows.map((values, index) => {
+            if (!values || values.length === 0) {
+                logger.error("Embedding returned no values", {
+                    provider: this.providerName,
+                    model: modelName,
+                    index,
+                });
+                throw new ProviderError(`Embedding for the text at index ${index} came back without values`, this.providerName);
+            }
+            return values;
+        });
     }
     async callEmbeddings(modelName, input, operation) {
         const url = `${stripTrailingSlash(this.config.baseURL)}/embeddings`;
@@ -514,13 +542,11 @@ export class LiteLLMProvider extends OpenAIChatCompletionsProvider {
                     `LiteLLM ${operation} failed with status ${res.status}`));
             }
             const json = (await res.json());
-            const embeddings = (json.data ?? [])
-                .map((row) => row.embedding)
-                .filter((e) => Array.isArray(e));
-            if (embeddings.length === 0) {
+            const rows = (json.data ?? []).map((row) => Array.isArray(row.embedding) ? row.embedding : undefined);
+            if (rows.length === 0) {
                 throw new ProviderError(`LiteLLM ${operation} returned no embeddings`, this.providerName);
             }
-            return embeddings;
+            return rows;
         }
         finally {
             timeoutController?.cleanup();

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

@@ -67,5 +67,10 @@ export declare class OllamaProvider extends OpenAIChatCompletionsProvider {
      * Generate embeddings for multiple text inputs via native /v1/embeddings.
      */
     embedMany(texts: string[], modelName?: string): Promise<number[][]>;
+    /**
+     * One non-empty vector per input, or fail: a dropped or empty row would
+     * pair later texts with the wrong vectors, or score 0 downstream.
+     */
+    private requireEmbeddings;
     private callEmbeddings;
 }

package/dist/providers/ollama/client.js

@@ -216,7 +216,8 @@ export class OllamaProvider extends OpenAIChatCompletionsProvider {
         const embeddingModel = modelName ||
             process.env.OLLAMA_EMBEDDING_MODEL ||
             DEFAULT_EMBEDDING_MODEL;
-        const [embedding] = await this.callEmbeddings(embeddingModel, [text], "embed");
+        const rows = await this.callEmbeddings(embeddingModel, [text], "embed");
+        const [embedding] = this.requireEmbeddings(rows, 1, embeddingModel);
         return embedding;
     }
     /**
@@ -226,7 +227,34 @@ export class OllamaProvider extends OpenAIChatCompletionsProvider {
         const embeddingModel = modelName ||
             process.env.OLLAMA_EMBEDDING_MODEL ||
             DEFAULT_EMBEDDING_MODEL;
-        return this.callEmbeddings(embeddingModel, texts, "embedMany");
+        const rows = await this.callEmbeddings(embeddingModel, texts, "embedMany");
+        return this.requireEmbeddings(rows, texts.length, embeddingModel);
+    }
+    /**
+     * One non-empty vector per input, or fail: a dropped or empty row would
+     * pair later texts with the wrong vectors, or score 0 downstream.
+     */
+    requireEmbeddings(rows, inputCount, modelName) {
+        if (rows.length !== inputCount) {
+            logger.error("Embedding response held the wrong number of vectors", {
+                provider: this.providerName,
+                model: modelName,
+                expected: inputCount,
+                received: rows.length,
+            });
+            throw new ProviderError(`Embedding response held ${rows.length} vectors for ${inputCount} texts`, this.providerName);
+        }
+        return rows.map((values, index) => {
+            if (!values || values.length === 0) {
+                logger.error("Embedding returned no values", {
+                    provider: this.providerName,
+                    model: modelName,
+                    index,
+                });
+                throw new ProviderError(`Embedding for the text at index ${index} came back without values`, this.providerName);
+            }
+            return values;
+        });
     }
     async callEmbeddings(modelName, input, operation) {
         const url = `${stripTrailingSlash(this.config.baseURL)}/embeddings`;
@@ -265,13 +293,11 @@ export class OllamaProvider extends OpenAIChatCompletionsProvider {
                     `Ollama ${operation} failed with status ${res.status}`));
             }
             const json = (await res.json());
-            const embeddings = (json.data ?? [])
-                .map((row) => row.embedding)
-                .filter((e) => Array.isArray(e));
-            if (embeddings.length === 0) {
+            const rows = (json.data ?? []).map((row) => Array.isArray(row.embedding) ? row.embedding : undefined);
+            if (rows.length === 0) {
                 throw new ProviderError(`Ollama ${operation} returned no embeddings`, "ollama");
             }
-            return embeddings;
+            return rows;
         }
         finally {
             timeoutController?.cleanup();

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

@@ -51,6 +51,15 @@ export declare class OpenAIProvider extends OpenAIChatCompletionsProvider {
      * @returns Promise resolving to an array of embedding vectors
      */
     embedMany(texts: string[], modelName?: string): Promise<number[][]>;
+    /**
+     * One non-empty vector per input, or fail: a dropped or empty row would
+     * pair later texts with the wrong vectors, or score 0 downstream.
+     *
+     * Called after the request's try on purpose: inside it, handleProviderError
+     * would wrap this message in a second provider error and run it through its
+     * keyword rules.
+     */
+    private requireEmbeddings;
     private callEmbeddings;
     /**
      * Image generation via the OpenAI Images API (`/v1/images/generations`).

package/dist/providers/openAI/client.js

@@ -234,14 +234,9 @@ export class OpenAIProvider extends OpenAIChatCompletionsProvider {
             model: embeddingModelName,
             textLength: text.length,
         });
+        let rows;
         try {
-            const [embedding] = await this.callEmbeddings(embeddingModelName, [text], "embed");
-            logger.debug("Embedding generated successfully", {
-                provider: this.providerName,
-                model: embeddingModelName,
-                embeddingDimension: embedding.length,
-            });
-            return embedding;
+            rows = await this.callEmbeddings(embeddingModelName, [text], "embed");
         }
         catch (error) {
             logger.error("Embedding generation failed", {
@@ -251,6 +246,13 @@ export class OpenAIProvider extends OpenAIChatCompletionsProvider {
             });
             throw this.handleProviderError(error);
         }
+        const [embedding] = this.requireEmbeddings(rows, 1, embeddingModelName);
+        logger.debug("Embedding generated successfully", {
+            provider: this.providerName,
+            model: embeddingModelName,
+            embeddingDimension: embedding.length,
+        });
+        return embedding;
     }
     /**
      * Generate embeddings for multiple texts in a single batch via native /v1/embeddings.
@@ -266,15 +268,9 @@ export class OpenAIProvider extends OpenAIChatCompletionsProvider {
             model: embeddingModelName,
             count: texts.length,
         });
+        let rows;
         try {
-            const embeddings = await this.callEmbeddings(embeddingModelName, texts, "embedMany");
-            logger.debug("Batch embeddings generated successfully", {
-                provider: this.providerName,
-                model: embeddingModelName,
-                count: embeddings.length,
-                embeddingDimension: embeddings[0]?.length,
-            });
-            return embeddings;
+            rows = await this.callEmbeddings(embeddingModelName, texts, "embedMany");
         }
         catch (error) {
             logger.error("Batch embedding generation failed", {
@@ -284,6 +280,42 @@ export class OpenAIProvider extends OpenAIChatCompletionsProvider {
             });
             throw this.handleProviderError(error);
         }
+        const embeddings = this.requireEmbeddings(rows, texts.length, embeddingModelName);
+        logger.debug("Batch embeddings generated successfully", {
+            provider: this.providerName,
+            model: embeddingModelName,
+            count: embeddings.length,
+            embeddingDimension: embeddings[0]?.length,
+        });
+        return embeddings;
+    }
+    /**
+     * One non-empty vector per input, or fail: a dropped or empty row would
+     * pair later texts with the wrong vectors, or score 0 downstream.
+     *
+     * Called after the request's try on purpose: inside it, handleProviderError
+     * would wrap this message in a second provider error and run it through its
+     * keyword rules.
+     */
+    requireEmbeddings(rows, inputCount, modelName) {
+        if (rows.length !== inputCount) {
+            logger.error("Embedding response held the wrong number of vectors", {
+                model: modelName,
+                expected: inputCount,
+                received: rows.length,
+            });
+            throw new ProviderError(`Embedding response held ${rows.length} vectors for ${inputCount} texts`, this.providerName);
+        }
+        return rows.map((values, index) => {
+            if (!values || values.length === 0) {
+                logger.error("Embedding returned no values", {
+                    model: modelName,
+                    index,
+                });
+                throw new ProviderError(`Embedding for the text at index ${index} came back without values`, this.providerName);
+            }
+            return values;
+        });
     }
     async callEmbeddings(modelName, input, operation) {
         const url = `${stripTrailingSlash(this.config.baseURL)}/embeddings`;
@@ -329,13 +361,11 @@ export class OpenAIProvider extends OpenAIChatCompletionsProvider {
                 });
             }
             const json = (await res.json());
-            const embeddings = (json.data ?? [])
-                .map((row) => row.embedding)
-                .filter((e) => Array.isArray(e));
-            if (embeddings.length === 0) {
+            const rows = (json.data ?? []).map((row) => Array.isArray(row.embedding) ? row.embedding : undefined);
+            if (rows.length === 0) {
                 throw new ProviderError(`OpenAI ${operation} returned no embeddings`, this.providerName);
             }
-            return embeddings;
+            return rows;
         }
         finally {
             timeoutController?.cleanup();

package/dist/proxy/utils/noProxyUtils.d.ts

@@ -17,6 +17,8 @@
  * - "192.168.1.10", "::1", "[::1]:8080" - an IP literal, exactly
  * - "192.168.1.0/24" - an IPv4 CIDR range, for IPv4 literal targets (IPv6 CIDR
  *   ranges are not supported)
+ * - "." and ".." - an entry made only of dots names no host, so it matches
+ *   nothing, as in curl
  *
  * @param targetUrl - The URL to check for proxy bypass
  * @param noProxyEnv - Optional NO_PROXY environment variable value (if not provided, reads from process.env)
@@ -37,6 +39,8 @@ export declare function getNoProxyEnv(): string | undefined;
  * - "example.com" - exact match
  * - ".example.com" - domain suffix match
  *
+ * An entry made only of dots names no host and matches nothing.
+ *
  * @param targetUrl - The URL to check
  * @param noProxyValue - The NO_PROXY value to check against
  * @returns true if should bypass proxy

package/dist/proxy/utils/noProxyUtils.js

@@ -44,6 +44,10 @@ function canonicalIpv6Host(address) {
 function withoutTrailingDot(name) {
     return name.endsWith(".") ? name.slice(0, -1) : name;
 }
+/** An entry made only of dots (`.`, `..`) names no host. */
+function isDotsOnly(entry) {
+    return /^\.+$/.test(entry);
+}
 /**
  * curl's rules for one list entry: an optional leading `.` or `*.` is ignored;
  * the entry names that host and every subdomain of it, an IP literal only
@@ -106,13 +110,20 @@ function matchesNoProxyEntry(entry, hostname, port) {
     return name === domain || name.endsWith(`.${domain}`);
 }
 /**
- * The rules this function applied before it followed curl, unchanged and still
- * consulted, so that a configuration that bypassed the proxy through them keeps
- * doing so. That includes where they are looser than curl (`.example.com` also
- * matches `notexample.com`) and an IPv4 CIDR range such as `192.168.1.0/24`,
- * which curl-style entries do not express.
+ * The rules this function applied before it followed curl, still consulted so
+ * that a configuration that bypassed the proxy through them keeps doing so.
+ * That includes where they are looser than curl (`.example.com` also matches
+ * `notexample.com`) and an IPv4 CIDR range such as `192.168.1.0/24`, which
+ * curl-style entries do not express. They are unchanged except that an entry
+ * made only of dots names no host, as in the curl-style rules.
  */
 function matchesLegacyNoProxyEntry(lowerPattern, hostname, port) {
+    // Taken as a suffix, "." leaves the empty string, which every host name ends
+    // with, and ".." leaves ".", which every host written with a trailing dot
+    // ends with.
+    if (isDotsOnly(lowerPattern)) {
+        return false;
+    }
     // Domain suffix match (.example.com)
     if (lowerPattern.startsWith(".")) {
         const suffix = lowerPattern.slice(1);
@@ -145,6 +156,8 @@ function matchesLegacyNoProxyEntry(lowerPattern, hostname, port) {
  * - "192.168.1.10", "::1", "[::1]:8080" - an IP literal, exactly
  * - "192.168.1.0/24" - an IPv4 CIDR range, for IPv4 literal targets (IPv6 CIDR
  *   ranges are not supported)
+ * - "." and ".." - an entry made only of dots names no host, so it matches
+ *   nothing, as in curl
  *
  * @param targetUrl - The URL to check for proxy bypass
  * @param noProxyEnv - Optional NO_PROXY environment variable value (if not provided, reads from process.env)
@@ -197,6 +210,8 @@ export function getNoProxyEnv() {
  * - "example.com" - exact match
  * - ".example.com" - domain suffix match
  *
+ * An entry made only of dots names no host and matches nothing.
+ *
  * @param targetUrl - The URL to check
  * @param noProxyValue - The NO_PROXY value to check against
  * @returns true if should bypass proxy
@@ -211,6 +226,10 @@ export function shouldBypassProxySimple(targetUrl, noProxyValue) {
             if (!pattern) {
                 continue;
             }
+            // As a suffix, "." would match every host written with a trailing dot.
+            if (isDotsOnly(pattern)) {
+                continue;
+            }
             // Exact match
             if (hostname === pattern) {
                 return true;

package/dist/utils/tokenLimits.js

@@ -2,7 +2,7 @@
  * Provider-specific token limit utilities
  * Provides safe maxTokens values based on provider and model capabilities
  */
-import { getRuntimeOutputCeiling } from "../constants/contextWindows.js";
+import { getRuntimeOutputCeiling, stripBedrockGeoPrefix, } from "../constants/contextWindows.js";
 import { PROVIDER_MAX_TOKENS } from "../core/constants.js";
 import { logger } from "./logger.js";
 import { hasRestrictedOutputLimit, RESTRICTED_OUTPUT_TOKEN_LIMIT, } from "./modelDetection.js";
@@ -67,6 +67,11 @@ export function getSafeMaxTokens(provider, model, requestedMaxTokens) {
         }
         return requestedMaxTokens;
     }
+    // The Bedrock rows are keyed by bare id, but for many models the cross-region
+    // profile id (us.amazon.nova-pro-v1:0) is the only one a caller can invoke.
+    // The bare id is tried only after the id as given misses, so an explicit row
+    // for the prefixed id still wins.
+    const bareModel = provider === "bedrock" && model ? stripBedrockGeoPrefix(model) : undefined;
     // Get model-specific limit or provider default
     let maxLimit;
     if (model &&
@@ -74,6 +79,11 @@ export function getSafeMaxTokens(provider, model, requestedMaxTokens) {
         providerLimits[model]) {
         maxLimit = providerLimits[model];
     }
+    else if (bareModel !== undefined &&
+        typeof providerLimits === "object" &&
+        providerLimits[bareModel]) {
+        maxLimit = providerLimits[bareModel];
+    }
     else if (typeof providerLimits === "object" &&
         providerLimits.default) {
         maxLimit = providerLimits.default;