visual-ai-assertions 0.14.0 → 0.19.0

package/dist/index.cjs

@@ -38,6 +38,7 @@ __export(index_exports, {
   ConfidenceSchema: () => ConfidenceSchema,
   Content: () => Content,
   DEFAULT_MODELS: () => DEFAULT_MODELS,
+  ImageDetail: () => ImageDetail,
   IssueCategorySchema: () => IssueCategorySchema,
   IssuePrioritySchema: () => IssuePrioritySchema,
   IssueSchema: () => IssueSchema,
@@ -73,14 +74,23 @@ var ReasoningEffort = {
   HIGH: "high",
   XHIGH: "xhigh"
 };
+var ImageDetail = {
+  AUTO: "auto",
+  LOW: "low",
+  HIGH: "high"
+};
+var DEFAULT_IMAGE_DETAIL = ImageDetail.AUTO;
+var DEFAULT_MAX_IMAGE_DIMENSION = 1568;
 var Provider = {
   ANTHROPIC: "anthropic",
   OPENAI: "openai",
-  GOOGLE: "google"
+  GOOGLE: "google",
+  OPENROUTER: "openrouter"
 };
 var Model = {
   Anthropic: {
     FABLE_5: "claude-fable-5",
+    OPUS_5: "claude-opus-5",
     OPUS_4_8: "claude-opus-4-8",
     OPUS_4_7: "claude-opus-4-7",
     OPUS_4_6: "claude-opus-4-6",
@@ -101,29 +111,51 @@ var Model = {
     GPT_5_MINI: "gpt-5-mini"
   },
   Google: {
+    GEMINI_3_8_FLASH: "gemini-3.8-flash",
+    GEMINI_3_7_FLASH: "gemini-3.7-flash",
+    GEMINI_3_6_FLASH: "gemini-3.6-flash",
     GEMINI_3_5_FLASH: "gemini-3.5-flash",
+    GEMINI_3_5_FLASH_LITE: "gemini-3.5-flash-lite",
     GEMINI_3_1_PRO_PREVIEW: "gemini-3.1-pro-preview",
     GEMINI_3_1_FLASH_LITE: "gemini-3.1-flash-lite",
     GEMINI_3_FLASH_PREVIEW: "gemini-3-flash-preview"
+  },
+  /**
+   * Models routed through OpenRouter (https://openrouter.ai). Slugs always
+   * carry a vendor prefix (`vendor/model`), which is how provider inference
+   * recognizes them. All listed models accept image input.
+   */
+  OpenRouter: {
+    GROK_4_6: "x-ai/grok-4.6",
+    GROK_4_5: "x-ai/grok-4.5",
+    KIMI_K3: "moonshotai/kimi-k3",
+    KIMI_K2_7_CODE: "moonshotai/kimi-k2.7-code",
+    QWEN_3_8_MAX: "qwen/qwen3.8-max",
+    QWEN_3_7_PLUS: "qwen/qwen3.7-plus",
+    QWEN_3_6_FLASH: "qwen/qwen3.6-flash"
   }
 };
 var DEFAULT_MODELS = {
   [Provider.ANTHROPIC]: Model.Anthropic.SONNET_4_6,
   [Provider.OPENAI]: Model.OpenAI.GPT_5_4_MINI,
-  [Provider.GOOGLE]: Model.Google.GEMINI_3_FLASH_PREVIEW
+  [Provider.GOOGLE]: Model.Google.GEMINI_3_FLASH_PREVIEW,
+  [Provider.OPENROUTER]: Model.OpenRouter.QWEN_3_6_FLASH
 };
 var DEFAULT_MAX_TOKENS = 4096;
 var OPENAI_REASONING_MAX_TOKENS = 16384;
 var MODEL_TO_PROVIDER = new Map([
   ...Object.values(Model.Anthropic).map((m) => [m, Provider.ANTHROPIC]),
   ...Object.values(Model.OpenAI).map((m) => [m, Provider.OPENAI]),
-  ...Object.values(Model.Google).map((m) => [m, Provider.GOOGLE])
+  ...Object.values(Model.Google).map((m) => [m, Provider.GOOGLE]),
+  ...Object.values(Model.OpenRouter).map((m) => [m, Provider.OPENROUTER])
 ]);
 var VALID_PROVIDERS = Object.values(Provider);
 var PROVIDER_DEFAULT_REASONING = {
   openai: "medium",
   anthropic: "off",
-  google: "off"
+  google: "off",
+  // Varies by upstream model; the driver sends no reasoning field unless configured.
+  openrouter: "off"
 };
 var Content = {
   /** Detects Lorem ipsum, TODO, TBD, and similar placeholder text */
@@ -581,6 +613,7 @@ function parseRetryAfter(value) {
 // src/providers/anthropic.ts
 var XHIGH_CAPABLE_MODELS = /* @__PURE__ */ new Set([
   Model.Anthropic.FABLE_5,
+  Model.Anthropic.OPUS_5,
   Model.Anthropic.OPUS_4_8,
   Model.Anthropic.OPUS_4_7,
   Model.Anthropic.SONNET_5
@@ -589,6 +622,13 @@ function mapEffort(level, model) {
   if (level !== "xhigh") return level;
   return XHIGH_CAPABLE_MODELS.has(model) ? "xhigh" : "max";
 }
+var BUDGET_THINKING_MODELS = /* @__PURE__ */ new Set([Model.Anthropic.HAIKU_4_5]);
+var EFFORT_TO_BUDGET_TOKENS = {
+  low: 1024,
+  medium: 4096,
+  high: 8192,
+  xhigh: 16384
+};
 var AnthropicDriver = class {
   client;
   model;
@@ -644,10 +684,16 @@ var AnthropicDriver = class {
         ]
       };
       if (this.reasoningEffort) {
-        requestParams.thinking = { type: "adaptive" };
-        requestParams.output_config = {
-          effort: mapEffort(this.reasoningEffort, this.model)
-        };
+        if (BUDGET_THINKING_MODELS.has(this.model)) {
+          const budgetTokens = EFFORT_TO_BUDGET_TOKENS[this.reasoningEffort];
+          requestParams.thinking = { type: "enabled", budget_tokens: budgetTokens };
+          requestParams.max_tokens = Math.max(this.maxTokens, budgetTokens + DEFAULT_MAX_TOKENS);
+        } else {
+          requestParams.thinking = { type: "adaptive" };
+          requestParams.output_config = {
+            effort: mapEffort(this.reasoningEffort, this.model)
+          };
+        }
       }
       const message = await client.messages.create(requestParams);
       const textBlock = message.content.find((block) => block.type === "text");
@@ -663,7 +709,10 @@ var AnthropicDriver = class {
         text,
         usage: {
           inputTokens: message.usage.input_tokens,
-          outputTokens: message.usage.output_tokens
+          outputTokens: message.usage.output_tokens,
+          ...message.usage.cache_read_input_tokens !== void 0 && {
+            cachedInputTokens: message.usage.cache_read_input_tokens
+          }
         }
       };
     } catch (err) {
@@ -680,23 +729,41 @@ function needsCodeExecution(model) {
   return match !== null && match[1] !== void 0 && parseInt(match[1], 10) >= 3;
 }
 var GOOGLE_THINKING_LEVEL = {
-  low: "minimal",
-  medium: "low",
-  high: "medium",
+  low: "low",
+  medium: "medium",
+  high: "high",
   xhigh: "high"
 };
+var GOOGLE_MEDIA_RESOLUTION = {
+  low: "MEDIA_RESOLUTION_LOW",
+  high: "MEDIA_RESOLUTION_HIGH"
+};
+function toGeminiUsage(um) {
+  if (!um) return void 0;
+  const thoughts = um.thoughtsTokenCount ?? 0;
+  return {
+    inputTokens: um.promptTokenCount ?? 0,
+    outputTokens: (um.candidatesTokenCount ?? 0) + thoughts,
+    ...um.thoughtsTokenCount !== void 0 && { reasoningTokens: um.thoughtsTokenCount },
+    ...um.cachedContentTokenCount !== void 0 && {
+      cachedInputTokens: um.cachedContentTokenCount
+    }
+  };
+}
 var GoogleDriver = class {
   client;
   model;
   maxTokens;
   apiKeyOrEnv;
   reasoningEffort;
+  imageDetail;
   constructor(config) {
     this.model = config.model;
     this.maxTokens = config.maxTokens;
     this.client = null;
     this.apiKeyOrEnv = config.apiKey;
     this.reasoningEffort = config.reasoningEffort;
+    this.imageDetail = config.imageDetail;
   }
   toGeminiParts(images) {
     return images.map((img) => ({
@@ -736,6 +803,9 @@ var GoogleDriver = class {
             thinkingConfig: {
               thinkingLevel: GOOGLE_THINKING_LEVEL[this.reasoningEffort]
             }
+          },
+          ...this.imageDetail && GOOGLE_MEDIA_RESOLUTION[this.imageDetail] && {
+            mediaResolution: GOOGLE_MEDIA_RESOLUTION[this.imageDetail]
           }
         }
       });
@@ -753,14 +823,9 @@ var GoogleDriver = class {
         );
       }
       const text = response.text ?? "";
-      const thoughtsTokenCount = response.usageMetadata?.thoughtsTokenCount;
       return {
         text,
-        usage: response.usageMetadata ? {
-          inputTokens: response.usageMetadata.promptTokenCount ?? 0,
-          outputTokens: response.usageMetadata.candidatesTokenCount ?? 0,
-          ...thoughtsTokenCount !== void 0 && { reasoningTokens: thoughtsTokenCount }
-        } : void 0
+        usage: toGeminiUsage(response.usageMetadata)
       };
     } catch (err) {
       if (err instanceof VisualAITruncationError || err instanceof VisualAIProviderError) throw err;
@@ -791,10 +856,7 @@ var GoogleDriver = class {
       return {
         imageData: Buffer.from(imagePart.inlineData.data, "base64"),
         mimeType: imagePart.inlineData.mimeType,
-        usage: response.usageMetadata ? {
-          inputTokens: response.usageMetadata.promptTokenCount ?? 0,
-          outputTokens: response.usageMetadata.candidatesTokenCount ?? 0
-        } : void 0
+        usage: toGeminiUsage(response.usageMetadata)
       };
     } catch (err) {
       if (err instanceof VisualAIProviderError) throw err;
@@ -810,12 +872,14 @@ var OpenAIDriver = class {
   maxTokens;
   apiKeyOrEnv;
   reasoningEffort;
+  imageDetail;
   constructor(config) {
     this.model = config.model;
     this.maxTokens = config.maxTokens;
     this.client = null;
     this.apiKeyOrEnv = config.apiKey;
     this.reasoningEffort = config.reasoningEffort;
+    this.imageDetail = config.imageDetail;
   }
   async getClient() {
     if (this.client) return this.client;
@@ -837,9 +901,11 @@ var OpenAIDriver = class {
   }
   async sendMessage(images, prompt, options) {
     const client = await this.getClient();
+    const detail = this.imageDetail && this.imageDetail !== "auto" ? this.imageDetail : void 0;
     const imageBlocks = images.map((img) => ({
       type: "input_image",
-      image_url: `data:${img.mimeType};base64,${img.base64}`
+      image_url: `data:${img.mimeType};base64,${img.base64}`,
+      ...detail ? { detail } : {}
     }));
     try {
       const format = options?.responseSchema ? {
@@ -864,21 +930,23 @@ var OpenAIDriver = class {
       }
       const response = await client.responses.create(requestParams);
       if (response.status && response.status !== "completed") {
-        const detail = response.incomplete_details?.reason ? ` (${response.incomplete_details.reason})` : "";
+        const detail2 = response.incomplete_details?.reason ? ` (${response.incomplete_details.reason})` : "";
         throw new VisualAITruncationError(
-          `Response truncated: OpenAI returned status "${response.status}"${detail}. The model exhausted the output token budget (${this.maxTokens} tokens). This commonly happens with higher reasoning effort levels. Increase maxTokens in your config (e.g., maxTokens: 16384) or lower reasoningEffort.`,
+          `Response truncated: OpenAI returned status "${response.status}"${detail2}. The model exhausted the output token budget (${this.maxTokens} tokens). This commonly happens with higher reasoning effort levels. Increase maxTokens in your config (e.g., maxTokens: 16384) or lower reasoningEffort.`,
           response.output_text ?? "",
           this.maxTokens
         );
       }
       const text = response.output_text ?? "";
       const reasoningTokens = response.usage?.output_tokens_details?.reasoning_tokens;
+      const cachedInputTokens = response.usage?.input_tokens_details?.cached_tokens;
       return {
         text,
         usage: response.usage ? {
           inputTokens: response.usage.input_tokens,
           outputTokens: response.usage.output_tokens,
-          ...reasoningTokens !== void 0 && { reasoningTokens }
+          ...reasoningTokens !== void 0 && { reasoningTokens },
+          ...cachedInputTokens !== void 0 && { cachedInputTokens }
         } : void 0
       };
     } catch (err) {
@@ -888,6 +956,119 @@ var OpenAIDriver = class {
   }
 };
 
+// src/providers/openrouter.ts
+var OPENROUTER_BASE_URL = "https://openrouter.ai/api/v1";
+var OPENROUTER_REASONING_EFFORT = {
+  low: "low",
+  medium: "medium",
+  high: "high",
+  xhigh: "high"
+};
+var OpenRouterDriver = class {
+  client;
+  model;
+  maxTokens;
+  apiKeyOrEnv;
+  reasoningEffort;
+  imageDetail;
+  constructor(config) {
+    this.model = config.model;
+    this.maxTokens = config.maxTokens;
+    this.client = null;
+    this.apiKeyOrEnv = config.apiKey;
+    this.reasoningEffort = config.reasoningEffort;
+    this.imageDetail = config.imageDetail;
+  }
+  async getClient() {
+    if (this.client) return this.client;
+    let OpenAI;
+    try {
+      const mod = await import("openai");
+      OpenAI = mod.default;
+    } catch {
+      throw new VisualAIConfigError(
+        "OpenAI SDK not installed (required for the OpenRouter provider). Run: npm install openai"
+      );
+    }
+    const apiKey = this.apiKeyOrEnv ?? process.env.OPENROUTER_API_KEY;
+    if (!apiKey) {
+      throw new VisualAIAuthError(
+        "OpenRouter API key not found. Set OPENROUTER_API_KEY or pass apiKey in config."
+      );
+    }
+    this.client = new OpenAI({ apiKey, baseURL: OPENROUTER_BASE_URL });
+    return this.client;
+  }
+  async sendMessage(images, prompt, options) {
+    const client = await this.getClient();
+    const detail = this.imageDetail && this.imageDetail !== "auto" ? this.imageDetail : void 0;
+    const imageParts = images.map((img) => ({
+      type: "image_url",
+      image_url: {
+        url: `data:${img.mimeType};base64,${img.base64}`,
+        ...detail ? { detail } : {}
+      }
+    }));
+    try {
+      const responseFormat = options?.responseSchema ? {
+        type: "json_schema",
+        json_schema: {
+          name: "visual_ai_response",
+          strict: true,
+          schema: options.responseSchema
+        }
+      } : { type: "json_object" };
+      const requestParams = {
+        model: this.model,
+        max_tokens: this.maxTokens,
+        response_format: responseFormat,
+        messages: [
+          {
+            role: "user",
+            content: [...imageParts, { type: "text", text: prompt }]
+          }
+        ],
+        // OpenRouter-specific: include token accounting in the response.
+        usage: { include: true }
+      };
+      if (this.reasoningEffort) {
+        requestParams.reasoning = { effort: OPENROUTER_REASONING_EFFORT[this.reasoningEffort] };
+      }
+      const response = await client.chat.completions.create(requestParams);
+      const choice = response.choices?.[0];
+      if (!choice?.message) {
+        throw new VisualAIProviderError("OpenRouter returned an empty response (no choices).");
+      }
+      const text = choice.message.content ?? "";
+      if (choice.finish_reason === "length") {
+        throw new VisualAITruncationError(
+          `Response truncated: OpenRouter returned finish_reason "length". The model exhausted the output token budget (${this.maxTokens} tokens). This commonly happens with higher reasoning effort levels. Increase maxTokens in your config (e.g., maxTokens: 16384) or lower reasoningEffort.`,
+          text,
+          this.maxTokens
+        );
+      }
+      const reasoningTokens = response.usage?.completion_tokens_details?.reasoning_tokens;
+      const cachedInputTokens = response.usage?.prompt_tokens_details?.cached_tokens;
+      const cost = response.usage?.cost;
+      return {
+        text,
+        usage: response.usage ? {
+          inputTokens: response.usage.prompt_tokens,
+          outputTokens: response.usage.completion_tokens,
+          ...reasoningTokens !== void 0 && { reasoningTokens },
+          ...cachedInputTokens !== void 0 && { cachedInputTokens },
+          ...cost !== void 0 && { cost }
+        } : void 0
+      };
+    } catch (err) {
+      if (err instanceof VisualAITruncationError || err instanceof VisualAIProviderError) {
+        throw err;
+      }
+      throw mapProviderError(err);
+    }
+  }
+};
+
 // src/core/config.ts
 var MODEL_PREFIX_TO_PROVIDER = [
   ["claude-", "anthropic"],
@@ -900,6 +1081,7 @@ var MODEL_PREFIX_TO_PROVIDER = [
 function inferProviderFromModel(model) {
   const known = MODEL_TO_PROVIDER.get(model);
   if (known) return known;
+  if (model.includes("/")) return "openrouter";
   const prefixMatch = MODEL_PREFIX_TO_PROVIDER.find(([prefix]) => model.startsWith(prefix));
   return prefixMatch?.[1];
 }
@@ -912,12 +1094,13 @@ function resolveProvider(config) {
   const apiKeyProviderMap = [
     ["ANTHROPIC_API_KEY", "anthropic"],
     ["OPENAI_API_KEY", "openai"],
-    ["GOOGLE_API_KEY", "google"]
+    ["GOOGLE_API_KEY", "google"],
+    ["OPENROUTER_API_KEY", "openrouter"]
   ];
   const detected = apiKeyProviderMap.find(([key]) => process.env[key]);
   if (detected) return detected[1];
   throw new VisualAIConfigError(
-    "Cannot determine provider. Set a model name (config or VISUAL_AI_MODEL) or an API key env variable (ANTHROPIC_API_KEY, OPENAI_API_KEY, GOOGLE_API_KEY)."
+    "Cannot determine provider. Set a model name (config or VISUAL_AI_MODEL) or an API key env variable (ANTHROPIC_API_KEY, OPENAI_API_KEY, GOOGLE_API_KEY, OPENROUTER_API_KEY)."
   );
 }
 function parseBooleanEnv(envName, value) {
@@ -945,11 +1128,11 @@ function resolveConfig(config) {
   }
   const userSetMaxTokens = config.maxTokens !== void 0;
   let maxTokens = config.maxTokens ?? DEFAULT_MAX_TOKENS;
-  if (!userSetMaxTokens && provider === "openai" && (config.reasoningEffort === "high" || config.reasoningEffort === "xhigh")) {
+  if (!userSetMaxTokens && (provider === "openai" || provider === "openrouter") && (config.reasoningEffort === "high" || config.reasoningEffort === "xhigh")) {
     maxTokens = OPENAI_REASONING_MAX_TOKENS;
     if (debug) {
       process.stderr.write(
-        `[visual-ai-assertions] Auto-increased maxTokens from ${DEFAULT_MAX_TOKENS} to ${OPENAI_REASONING_MAX_TOKENS} for OpenAI with reasoningEffort "${config.reasoningEffort}".
+        `[visual-ai-assertions] Auto-increased maxTokens from ${DEFAULT_MAX_TOKENS} to ${OPENAI_REASONING_MAX_TOKENS} for provider "${provider}" with reasoningEffort "${config.reasoningEffort}".
 `
       );
     }
@@ -960,6 +1143,8 @@ function resolveConfig(config) {
     model,
     maxTokens,
     reasoningEffort: config.reasoningEffort,
+    maxImageDimension: config.maxImageDimension ?? DEFAULT_MAX_IMAGE_DIMENSION,
+    imageDetail: config.imageDetail ?? DEFAULT_IMAGE_DETAIL,
     debug,
     debugPrompt,
     debugResponse,
@@ -974,6 +1159,10 @@ var PRICING_TABLE = {
     inputPricePerToken: 10 / PER_MILLION,
     outputPricePerToken: 50 / PER_MILLION
   },
+  [`${Provider.ANTHROPIC}:${Model.Anthropic.OPUS_5}`]: {
+    inputPricePerToken: 5 / PER_MILLION,
+    outputPricePerToken: 25 / PER_MILLION
+  },
   [`${Provider.ANTHROPIC}:${Model.Anthropic.OPUS_4_8}`]: {
     inputPricePerToken: 5 / PER_MILLION,
     outputPricePerToken: 25 / PER_MILLION
@@ -1003,12 +1192,12 @@ var PRICING_TABLE = {
     outputPricePerToken: 30 / PER_MILLION
   },
   [`${Provider.OPENAI}:${Model.OpenAI.GPT_5_6_TERRA}`]: {
-    inputPricePerToken: 2.5 / PER_MILLION,
-    outputPricePerToken: 15 / PER_MILLION
+    inputPricePerToken: 2 / PER_MILLION,
+    outputPricePerToken: 12 / PER_MILLION
   },
   [`${Provider.OPENAI}:${Model.OpenAI.GPT_5_6_LUNA}`]: {
-    inputPricePerToken: 1 / PER_MILLION,
-    outputPricePerToken: 6 / PER_MILLION
+    inputPricePerToken: 0.2 / PER_MILLION,
+    outputPricePerToken: 1.2 / PER_MILLION
   },
   [`${Provider.OPENAI}:${Model.OpenAI.GPT_5_5}`]: {
     inputPricePerToken: 5 / PER_MILLION,
@@ -1038,10 +1227,30 @@ var PRICING_TABLE = {
     inputPricePerToken: 0.25 / PER_MILLION,
     outputPricePerToken: 2 / PER_MILLION
   },
+  // Introductory pricing through 2026-12-31; reverts to $1.50/$7.50 per MTok
+  // on 2027-01-01 (https://blog.google/.../3-8-flash-and-3-8-flash-cyber/).
+  [`${Provider.GOOGLE}:${Model.Google.GEMINI_3_8_FLASH}`]: {
+    inputPricePerToken: 0.75 / PER_MILLION,
+    outputPricePerToken: 3.75 / PER_MILLION
+  },
+  // Introductory pricing through 2026-12-31; reverts to $1.50/$7.50 per MTok
+  // on 2027-01-01 (https://blog.google/.../introducing-gemini-3-7-flash/).
+  [`${Provider.GOOGLE}:${Model.Google.GEMINI_3_7_FLASH}`]: {
+    inputPricePerToken: 0.75 / PER_MILLION,
+    outputPricePerToken: 3.75 / PER_MILLION
+  },
+  [`${Provider.GOOGLE}:${Model.Google.GEMINI_3_6_FLASH}`]: {
+    inputPricePerToken: 1.5 / PER_MILLION,
+    outputPricePerToken: 7.5 / PER_MILLION
+  },
   [`${Provider.GOOGLE}:${Model.Google.GEMINI_3_5_FLASH}`]: {
     inputPricePerToken: 1.5 / PER_MILLION,
     outputPricePerToken: 9 / PER_MILLION
   },
+  [`${Provider.GOOGLE}:${Model.Google.GEMINI_3_5_FLASH_LITE}`]: {
+    inputPricePerToken: 0.3 / PER_MILLION,
+    outputPricePerToken: 2.5 / PER_MILLION
+  },
   [`${Provider.GOOGLE}:${Model.Google.GEMINI_3_1_PRO_PREVIEW}`]: {
     inputPricePerToken: 2 / PER_MILLION,
     outputPricePerToken: 12 / PER_MILLION
@@ -1053,6 +1262,36 @@ var PRICING_TABLE = {
   [`${Provider.GOOGLE}:${Model.Google.GEMINI_3_FLASH_PREVIEW}`]: {
     inputPricePerToken: 0.5 / PER_MILLION,
     outputPricePerToken: 3 / PER_MILLION
+  },
+  // OpenRouter passes through upstream per-model pricing (verified 2026-07-22
+  // against https://openrouter.ai/api/v1/models).
+  [`${Provider.OPENROUTER}:${Model.OpenRouter.GROK_4_6}`]: {
+    inputPricePerToken: 2 / PER_MILLION,
+    outputPricePerToken: 6 / PER_MILLION
+  },
+  [`${Provider.OPENROUTER}:${Model.OpenRouter.GROK_4_5}`]: {
+    inputPricePerToken: 2 / PER_MILLION,
+    outputPricePerToken: 6 / PER_MILLION
+  },
+  [`${Provider.OPENROUTER}:${Model.OpenRouter.KIMI_K3}`]: {
+    inputPricePerToken: 3 / PER_MILLION,
+    outputPricePerToken: 15 / PER_MILLION
+  },
+  [`${Provider.OPENROUTER}:${Model.OpenRouter.KIMI_K2_7_CODE}`]: {
+    inputPricePerToken: 0.82 / PER_MILLION,
+    outputPricePerToken: 3.75 / PER_MILLION
+  },
+  [`${Provider.OPENROUTER}:${Model.OpenRouter.QWEN_3_8_MAX}`]: {
+    inputPricePerToken: 2 / PER_MILLION,
+    outputPricePerToken: 6 / PER_MILLION
+  },
+  [`${Provider.OPENROUTER}:${Model.OpenRouter.QWEN_3_7_PLUS}`]: {
+    inputPricePerToken: 0.32 / PER_MILLION,
+    outputPricePerToken: 1.28 / PER_MILLION
+  },
+  [`${Provider.OPENROUTER}:${Model.OpenRouter.QWEN_3_6_FLASH}`]: {
+    inputPricePerToken: 0.1875 / PER_MILLION,
+    outputPricePerToken: 1.125 / PER_MILLION
   }
 };
 function calculateCost(provider, model, inputTokens, outputTokens) {
@@ -1075,8 +1314,9 @@ function usageLog(config, method, usage) {
   const costStr = usage.estimatedCost !== void 0 ? `$${usage.estimatedCost.toFixed(6)}` : "unknown";
   const reasoningStr = config.reasoningEffort ? `reasoning: ${config.reasoningEffort}` : `reasoning: ${PROVIDER_DEFAULT_REASONING[config.provider]} (provider default)`;
   const reasoningTokenStr = usage.reasoningTokens !== void 0 ? ` (${usage.reasoningTokens} reasoning)` : "";
+  const cachedTokenStr = usage.cachedInputTokens !== void 0 ? ` (${usage.cachedInputTokens} cached)` : "";
   process.stderr.write(
-    `[visual-ai-assertions] ${method} usage: ${usage.inputTokens} input + ${usage.outputTokens} output${reasoningTokenStr} tokens (${costStr}) in ${usage.durationSeconds?.toFixed(3) ?? "0.000"}s [${config.model}, ${reasoningStr}]
+    `[visual-ai-assertions] ${method} usage: ${usage.inputTokens} input${cachedTokenStr} + ${usage.outputTokens} output${reasoningTokenStr} tokens (${costStr}) in ${usage.durationSeconds?.toFixed(3) ?? "0.000"}s [${config.model}, ${reasoningStr}]
 `
   );
 }
@@ -1087,7 +1327,11 @@ function processUsage(method, rawUsage, durationSeconds, config) {
     inputTokens,
     outputTokens,
     ...rawUsage?.reasoningTokens !== void 0 && { reasoningTokens: rawUsage.reasoningTokens },
+    ...rawUsage?.cachedInputTokens !== void 0 && {
+      cachedInputTokens: rawUsage.cachedInputTokens
+    },
     estimatedCost: calculateCost(config.provider, config.model, inputTokens, outputTokens),
+    ...rawUsage?.cost !== void 0 && { reportedCost: rawUsage.cost },
     durationSeconds
   };
   usageLog(config, method, usage);
@@ -1130,7 +1374,10 @@ async function timedSendMessage(driver, images, prompt, options) {
 var import_sharp = __toESM(require("sharp"), 1);
 var DIFF_ALLOWED_MODELS = /* @__PURE__ */ new Set([
   Model.Google.GEMINI_3_FLASH_PREVIEW,
-  Model.Google.GEMINI_3_5_FLASH
+  Model.Google.GEMINI_3_5_FLASH,
+  Model.Google.GEMINI_3_6_FLASH,
+  Model.Google.GEMINI_3_7_FLASH,
+  Model.Google.GEMINI_3_8_FLASH
 ]);
 async function generateAiDiff(imgA, imgB, model, driver) {
   if (!driver.generateImage) {
@@ -1220,7 +1467,6 @@ var EXTENSION_TO_MIME = {
   ".webp": "image/webp",
   ".gif": "image/gif"
 };
-var MAX_DIMENSION = 1568;
 var URL_FETCH_TIMEOUT_MS = 1e4;
 function isSupportedMimeType(value) {
   return SUPPORTED_FORMATS.has(value);
@@ -1244,14 +1490,14 @@ function detectMimeType(data) {
   }
   throw new VisualAIImageError("Unable to detect image format from file content");
 }
-async function resizeIfNeeded(data, mimeType) {
+async function resizeIfNeeded(data, mimeType, maxDimension) {
   if (mimeType === "image/gif") {
     return data;
   }
   if (mimeType === "image/png" && data.length >= 24) {
     const width2 = data.readUInt32BE(16);
     const height2 = data.readUInt32BE(20);
-    if (width2 <= MAX_DIMENSION && height2 <= MAX_DIMENSION) {
+    if (width2 <= maxDimension && height2 <= maxDimension) {
       return data;
     }
   }
@@ -1259,12 +1505,12 @@ async function resizeIfNeeded(data, mimeType) {
   const metadata = await pipeline.metadata();
   const width = metadata.width ?? 0;
   const height = metadata.height ?? 0;
-  if (width <= MAX_DIMENSION && height <= MAX_DIMENSION) {
+  if (width <= maxDimension && height <= maxDimension) {
     return data;
   }
   return pipeline.resize({
-    width: MAX_DIMENSION,
-    height: MAX_DIMENSION,
+    width: maxDimension,
+    height: maxDimension,
     fit: "inside",
     withoutEnlargement: true
   }).toBuffer();
@@ -1319,7 +1565,7 @@ function loadFromBase64(input) {
   }
   return { data, mimeType: mimeType ?? detectMimeType(data) };
 }
-async function normalizeImage(input) {
+async function normalizeImage(input, maxDimension = DEFAULT_MAX_IMAGE_DIMENSION) {
   let data;
   let mimeType;
   if (Buffer.isBuffer(input)) {
@@ -1348,7 +1594,7 @@ async function normalizeImage(input) {
       "Invalid image input: expected Buffer, Uint8Array, file path, URL, or base64 string"
     );
   }
-  data = await resizeIfNeeded(data, mimeType);
+  data = await resizeIfNeeded(data, mimeType, maxDimension);
   let cachedBase64;
   return {
     data,
@@ -1652,7 +1898,7 @@ async function probeDurationSeconds(videoPath) {
     });
   });
 }
-async function extractFrames(videoPath, options = {}) {
+async function extractFrames(videoPath, options = {}, maxDimension = FRAME_MAX_DIMENSION) {
   const fps = options.fps ?? DEFAULT_FPS;
   const maxFrames = options.maxFrames ?? DEFAULT_MAX_FRAMES;
   const maxDurationSeconds = options.maxDurationSeconds ?? DEFAULT_MAX_DURATION_SECONDS;
@@ -1681,7 +1927,7 @@ async function extractFrames(videoPath, options = {}) {
   }
   const outputDir = await (0, import_promises3.mkdtemp)((0, import_node_path3.join)((0, import_node_os.tmpdir)(), "visual-ai-frames-"));
   try {
-    const filter = `fps=${fps},scale='if(gt(iw,ih),min(${FRAME_MAX_DIMENSION},iw),-2)':'if(gt(iw,ih),-2,min(${FRAME_MAX_DIMENSION},ih))':flags=area`;
+    const filter = `fps=${fps},scale='if(gt(iw,ih),min(${maxDimension},iw),-2)':'if(gt(iw,ih),-2,min(${maxDimension},ih))':flags=area`;
     await new Promise((resolve2, reject) => {
       let settled = false;
       const cmd = ffmpeg(videoPath);
@@ -1779,7 +2025,7 @@ function isFramesInput(input) {
 function isTimestampedFrameInput(frame) {
   return typeof frame === "object" && !Buffer.isBuffer(frame) && !(frame instanceof Uint8Array) && "image" in frame;
 }
-async function normalizeFrames(input) {
+async function normalizeFrames(input, maxDimension = DEFAULT_MAX_IMAGE_DIMENSION) {
   const rawFrames = input.frames;
   const fps = input.fps ?? DEFAULT_FPS;
   if (rawFrames.length === 0) {
@@ -1804,7 +2050,7 @@ async function normalizeFrames(input) {
           `Invalid timestampSeconds for frame ${index}: ${String(timestampSeconds)}. Must be a finite number >= 0.`
         );
       }
-      const image = await normalizeImage(imageInput);
+      const image = await normalizeImage(imageInput, maxDimension);
       return {
         data: image.data,
         mimeType: image.mimeType,
@@ -1820,14 +2066,14 @@ async function normalizeFrames(input) {
   await saveDebugFrames(frames);
   return { kind: "video", frames, durationSeconds };
 }
-async function normalizeMedia(input, videoOptions) {
+async function normalizeMedia(input, videoOptions, maxDimension = DEFAULT_MAX_IMAGE_DIMENSION) {
   if (isFramesInput(input)) {
-    return normalizeFrames(input);
+    return normalizeFrames(input, maxDimension);
   }
   if (isVideoInput(input)) {
     const { path, cleanup } = await resolveVideoToPath(input);
     try {
-      const { frames, durationSeconds } = await extractFrames(path, videoOptions);
+      const { frames, durationSeconds } = await extractFrames(path, videoOptions, maxDimension);
       await saveDebugFrames(frames);
       return { kind: "video", frames, durationSeconds };
     } finally {
@@ -1837,7 +2083,7 @@ async function normalizeMedia(input, videoOptions) {
       }
     }
   }
-  const image = await normalizeImage(input);
+  const image = await normalizeImage(input, maxDimension);
   return { kind: "image", image };
 }
 
@@ -1878,7 +2124,17 @@ var UsageInfoSchema = import_zod.z.object({
   outputTokens: import_zod.z.number(),
   /** Reasoning/thinking tokens consumed by the model (informational, typically included within outputTokens). */
   reasoningTokens: import_zod.z.number().optional(),
+  /**
+   * Prompt tokens served from the provider's cache, when reported. Informational
+   * only — `estimatedCost` does not apply a cache discount, because providers
+   * differ on whether these are counted inside `inputTokens` (OpenAI, OpenRouter,
+   * Google) or billed as a separate bucket alongside it (Anthropic).
+   */
+  cachedInputTokens: import_zod.z.number().optional(),
+  /** Cost in USD from the library's local pricing table (inputTokens/outputTokens × per-model rates). */
   estimatedCost: import_zod.z.number().optional(),
+  /** Actual cost in USD reported by the provider itself, when available (OpenRouter). Authoritative over `estimatedCost`. */
+  reportedCost: import_zod.z.number().optional(),
   durationSeconds: import_zod.z.number().nonnegative().optional()
 });
 var BaseResultSchema = import_zod.z.object({
@@ -1980,7 +2236,8 @@ function toSchemaOptions(schema) {
 var PROVIDER_REGISTRY = {
   anthropic: (config) => new AnthropicDriver(config),
   openai: (config) => new OpenAIDriver(config),
-  google: (config) => new GoogleDriver(config)
+  google: (config) => new GoogleDriver(config),
+  openrouter: (config) => new OpenRouterDriver(config)
 };
 function createDriver(provider, config) {
   return PROVIDER_REGISTRY[provider](config);
@@ -2017,16 +2274,18 @@ function visualAI(config = {}) {
     apiKey: resolvedConfig.apiKey,
     model: resolvedConfig.model,
     maxTokens: resolvedConfig.maxTokens,
-    reasoningEffort: resolvedConfig.reasoningEffort
+    reasoningEffort: resolvedConfig.reasoningEffort,
+    imageDetail: resolvedConfig.imageDetail
   };
   const driver = createDriver(resolvedConfig.provider, driverConfig);
+  const maxImageDimension = resolvedConfig.maxImageDimension;
   async function checkElementsVisibility(image, elements, visible, options) {
     const methodName = visible ? "elementsVisible" : "elementsHidden";
     if (elements.length === 0) {
       throw new VisualAIConfigError(`At least one element is required for ${methodName}()`);
     }
     return withErrorDebug(resolvedConfig, methodName, async () => {
-      const img = await normalizeImage(image);
+      const img = await normalizeImage(image, maxImageDimension);
       const prompt = buildElementsVisibilityPrompt(elements, visible, options);
       debugLog(resolvedConfig, `${methodName} prompt`, prompt, "prompt");
       const response = await timedSendMessage(driver, [img], prompt, checkSchemaOptions);
@@ -2045,7 +2304,7 @@ function visualAI(config = {}) {
         throw new VisualAIConfigError("At least one statement is required for check()");
       }
       return withErrorDebug(resolvedConfig, "check", async () => {
-        const media = await normalizeMedia(input, options?.video);
+        const media = await normalizeMedia(input, options?.video, maxImageDimension);
         const { images, mediaContext, framesMetadata } = mediaToProviderInputs(media);
         const prompt = buildCheckPrompt(stmts, {
           instructions: options?.instructions,
@@ -2064,7 +2323,7 @@ function visualAI(config = {}) {
     },
     async ask(input, userPrompt, options) {
       return withErrorDebug(resolvedConfig, "ask", async () => {
-        const media = await normalizeMedia(input, options?.video);
+        const media = await normalizeMedia(input, options?.video, maxImageDimension);
         const { images, mediaContext, framesMetadata } = mediaToProviderInputs(media);
         const prompt = buildAskPrompt(userPrompt, {
           instructions: options?.instructions,
@@ -2083,7 +2342,10 @@ function visualAI(config = {}) {
     },
     async compare(imageA, imageB, options) {
       return withErrorDebug(resolvedConfig, "compare", async () => {
-        const [imgA, imgB] = await Promise.all([normalizeImage(imageA), normalizeImage(imageB)]);
+        const [imgA, imgB] = await Promise.all([
+          normalizeImage(imageA, maxImageDimension),
+          normalizeImage(imageB, maxImageDimension)
+        ]);
         const prompt = buildComparePrompt({
           userPrompt: options?.prompt,
           instructions: options?.instructions
@@ -2121,7 +2383,7 @@ function visualAI(config = {}) {
     },
     async accessibility(image, options) {
       return withErrorDebug(resolvedConfig, "accessibility", async () => {
-        const img = await normalizeImage(image);
+        const img = await normalizeImage(image, maxImageDimension);
         const prompt = buildAccessibilityPrompt(options);
         debugLog(resolvedConfig, "accessibility prompt", prompt, "prompt");
         const response = await timedSendMessage(driver, [img], prompt, checkSchemaOptions);
@@ -2140,7 +2402,7 @@ function visualAI(config = {}) {
     },
     async layout(image, options) {
       return withErrorDebug(resolvedConfig, "layout", async () => {
-        const img = await normalizeImage(image);
+        const img = await normalizeImage(image, maxImageDimension);
         const prompt = buildLayoutPrompt(options);
         debugLog(resolvedConfig, "layout prompt", prompt, "prompt");
         const response = await timedSendMessage(driver, [img], prompt, checkSchemaOptions);
@@ -2154,7 +2416,7 @@ function visualAI(config = {}) {
     },
     async pageLoad(image, options) {
       return withErrorDebug(resolvedConfig, "pageLoad", async () => {
-        const img = await normalizeImage(image);
+        const img = await normalizeImage(image, maxImageDimension);
         const prompt = buildPageLoadPrompt(options);
         debugLog(resolvedConfig, "pageLoad prompt", prompt, "prompt");
         const response = await timedSendMessage(driver, [img], prompt, checkSchemaOptions);
@@ -2168,7 +2430,7 @@ function visualAI(config = {}) {
     },
     async content(image, options) {
       return withErrorDebug(resolvedConfig, "content", async () => {
-        const img = await normalizeImage(image);
+        const img = await normalizeImage(image, maxImageDimension);
         const prompt = buildContentPrompt(options);
         debugLog(resolvedConfig, "content prompt", prompt, "prompt");
         const response = await timedSendMessage(driver, [img], prompt, checkSchemaOptions);
@@ -2247,6 +2509,7 @@ function assertVisualCompareResult(result, label) {
   ConfidenceSchema,
   Content,
   DEFAULT_MODELS,
+  ImageDetail,
   IssueCategorySchema,
   IssuePrioritySchema,
   IssueSchema,