ak-gemini 2.4.1 → 2.6.0

package/index.cjs

@@ -32,19 +32,26 @@ __export(index_exports, {
   BaseGemini: () => base_default,
   Chat: () => chat_default,
   CodeAgent: () => code_agent_default,
+  EFFORT_LEVELS: () => EFFORT_LEVELS,
   Embedding: () => Embedding,
   HarmBlockThreshold: () => import_genai2.HarmBlockThreshold,
   HarmCategory: () => import_genai2.HarmCategory,
   ImageGenerator: () => ImageGenerator,
+  MODEL_ALIASES: () => MODEL_ALIASES,
+  MODEL_PRICING: () => MODEL_PRICING,
+  MODEL_PRICING_AS_OF: () => MODEL_PRICING_AS_OF,
   Message: () => message_default,
   RagAgent: () => rag_agent_default,
   ThinkingLevel: () => import_genai2.ThinkingLevel,
   ToolAgent: () => tool_agent_default,
   Transformer: () => transformer_default,
   attemptJSONRecovery: () => attemptJSONRecovery,
+  computeCost: () => computeCost,
   default: () => index_default,
   extractJSON: () => extractJSON,
-  log: () => logger_default
+  log: () => logger_default,
+  resolvePricing: () => resolvePricing,
+  validateSchema: () => validateSchema
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -255,6 +262,79 @@ function findCompleteJSONStructures(text) {
   }
   return results;
 }
+function validateSchema(data, schema, path2 = "$") {
+  const errors = [];
+  if (!schema || typeof schema !== "object") return errors;
+  if (data === null && schema.nullable === true) return errors;
+  if (Array.isArray(schema.enum)) {
+    const target = JSON.stringify(data);
+    const ok = schema.enum.some((v) => v === data || JSON.stringify(v) === target);
+    if (!ok) errors.push(`${path2}: value ${JSON.stringify(data)} is not one of allowed enum values ${JSON.stringify(schema.enum)}`);
+  }
+  if (schema.type !== void 0) {
+    const types = Array.isArray(schema.type) ? schema.type : [schema.type];
+    if (schema.nullable === true) types.push("null");
+    if (!types.some((t) => matchesType(data, t))) {
+      errors.push(`${path2}: expected type ${types.join("|")} but got ${describeType(data)}`);
+      return errors;
+    }
+  }
+  const isObject = data !== null && typeof data === "object" && !Array.isArray(data);
+  if (isObject && (schema.properties || schema.required || schema.additionalProperties === false)) {
+    const props = schema.properties || {};
+    if (Array.isArray(schema.required)) {
+      for (const key of schema.required) {
+        if (!Object.hasOwn(data, key)) errors.push(`${path2}: missing required property "${key}"`);
+      }
+    }
+    if (schema.additionalProperties === false) {
+      for (const key of Object.keys(data)) {
+        if (!Object.hasOwn(props, key)) errors.push(`${path2}: unexpected property "${key}" (additionalProperties is false)`);
+      }
+    }
+    for (const [key, subSchema] of Object.entries(props)) {
+      if (Object.hasOwn(data, key)) {
+        errors.push(...validateSchema(
+          data[key],
+          /** @type {any} */
+          subSchema,
+          `${path2}.${key}`
+        ));
+      }
+    }
+  }
+  if (Array.isArray(data) && schema.items && typeof schema.items === "object" && !Array.isArray(schema.items)) {
+    data.forEach((item, i) => {
+      errors.push(...validateSchema(item, schema.items, `${path2}[${i}]`));
+    });
+  }
+  return errors;
+}
+function matchesType(value, type) {
+  switch (type) {
+    case "string":
+      return typeof value === "string";
+    case "number":
+      return typeof value === "number" && !Number.isNaN(value);
+    case "integer":
+      return typeof value === "number" && Number.isInteger(value);
+    case "boolean":
+      return typeof value === "boolean";
+    case "object":
+      return value !== null && typeof value === "object" && !Array.isArray(value);
+    case "array":
+      return Array.isArray(value);
+    case "null":
+      return value === null;
+    default:
+      return true;
+  }
+}
+function describeType(value) {
+  if (value === null) return "null";
+  if (Array.isArray(value)) return "array";
+  return typeof value;
+}
 function extractJSON(text) {
   if (!text || typeof text !== "string") {
     throw new Error("No text provided for JSON extraction");
@@ -322,6 +402,15 @@ var DEFAULT_THINKING_CONFIG = {
   thinkingBudget: 0
 };
 var DEFAULT_MAX_OUTPUT_TOKENS = 5e4;
+var EFFORT_LEVELS = ["minimal", "low", "medium", "high", "xhigh", "max"];
+var EFFORT_TO_THINKING_LEVEL = {
+  minimal: "minimal",
+  low: "low",
+  medium: "medium",
+  high: "high",
+  xhigh: "high",
+  max: "high"
+};
 var THINKING_SUPPORTED_MODELS = [
   /^gemini-3(\.\d+)?-pro(-preview)?$/,
   /^gemini-3(\.\d+)?-flash(-preview)?$/,
@@ -331,26 +420,42 @@ var THINKING_SUPPORTED_MODELS = [
   /^gemini-2\.5-flash-lite(-preview)?$/,
   /^gemini-2\.0-flash$/
 ];
+var MODEL_PRICING_AS_OF = "2026-07-28";
+var TIER_THRESHOLD = 2e5;
 var MODEL_PRICING = {
   // Gemini 3.x stable
-  "gemini-3.5-flash": { input: 1.5, output: 9 },
-  "gemini-3.1-flash-lite": { input: 0.25, output: 1.5 },
+  "gemini-3.6-flash": { input: 1.5, output: 7.5, cachedInput: 0.15 },
+  "gemini-3.5-flash": { input: 1.5, output: 9, cachedInput: 0.15 },
+  "gemini-3.5-flash-lite": { input: 0.3, output: 2.5, cachedInput: 0.03 },
+  "gemini-3.1-flash-lite": { input: 0.25, output: 1.5, cachedInput: 0.025 },
   // Gemini 3.x preview
-  "gemini-3.1-pro-preview": { input: 2, output: 12 },
-  // ≤200k tier
+  "gemini-3.1-pro-preview": {
+    input: 2,
+    output: 12,
+    cachedInput: 0.2,
+    inputAbove200k: 4,
+    outputAbove200k: 18,
+    cachedInputAbove200k: 0.4
+  },
   "gemini-3-pro-preview": { input: 2, output: 12 },
   // ≤200k tier; launch rate (superseded by 3.1, off the pricing page)
   "gemini-3-flash-preview": { input: 0.5, output: 3 },
-  "gemini-3.1-flash-lite-preview": { input: 0.25, output: 1.5 },
+  "gemini-3.1-flash-lite-preview": { input: 0.25, output: 1.5, cachedInput: 0.025 },
   "gemini-3.1-flash-image-preview": { input: 0.5, output: 3 },
   // text-only; image-output is $60/M
   "gemini-3-pro-image-preview": { input: 2, output: 12 },
   // text-only; image-output is $120/M
   // Gemini 2.5 stable
-  "gemini-2.5-flash": { input: 0.3, output: 2.5 },
-  "gemini-2.5-flash-lite": { input: 0.1, output: 0.4 },
-  "gemini-2.5-pro": { input: 1.25, output: 10 },
-  // ≤200k tier
+  "gemini-2.5-flash": { input: 0.3, output: 3, cachedInput: 0.05 },
+  "gemini-2.5-flash-lite": { input: 0.1, output: 0.4, cachedInput: 0.01 },
+  "gemini-2.5-pro": {
+    input: 1.25,
+    output: 10,
+    cachedInput: 0.125,
+    inputAbove200k: 2.5,
+    outputAbove200k: 15,
+    cachedInputAbove200k: 0.25
+  },
   "gemini-2.5-flash-image": { input: 0.3, output: 0 },
   // image-output is ~$0.039/image (1290 tokens)
   // Deprecated but kept for back-compat (shut down June 2026)
@@ -359,6 +464,50 @@ var MODEL_PRICING = {
   // Embeddings
   "gemini-embedding-001": { input: 0.15, output: 0 }
 };
+var MODEL_ALIASES = {
+  "gemini-flash-latest": "gemini-3.6-flash",
+  "gemini-pro-latest": "gemini-3.1-pro-preview",
+  "gemini-flash-lite-latest": "gemini-3.5-flash-lite"
+};
+function resolvePricing(modelId) {
+  const entry = _lookupPricing(modelId);
+  if (!entry) return null;
+  return { ...entry, tierThreshold: TIER_THRESHOLD, asOf: MODEL_PRICING_AS_OF };
+}
+function _lookupPricing(modelId) {
+  if (!modelId) return null;
+  const tryKey = (id) => {
+    if (MODEL_PRICING[id]) return MODEL_PRICING[id];
+    const alias = MODEL_ALIASES[id];
+    if (alias && MODEL_PRICING[alias]) {
+      logger_default.debug(`Pricing: alias "${id}" resolved to "${alias}". If Google has rotated this alias the rate may be wrong \u2014 prefer the echoed modelVersion.`);
+      return MODEL_PRICING[alias];
+    }
+    return null;
+  };
+  let hit = tryKey(modelId);
+  if (hit) return hit;
+  let stripped = modelId;
+  while (true) {
+    const next = stripped.replace(/-\d{2,}$/, "");
+    if (next === stripped) break;
+    stripped = next;
+    hit = tryKey(stripped);
+    if (hit) return hit;
+  }
+  return null;
+}
+function computeCost(modelId, promptTokens, responseTokens, thoughtsTokens = 0, cachedTokens = 0) {
+  const pricing = resolvePricing(modelId);
+  if (!pricing) return null;
+  const above = (promptTokens || 0) > TIER_THRESHOLD;
+  const inputRate = above && pricing.inputAbove200k || pricing.input;
+  const outputRate = above && pricing.outputAbove200k || pricing.output;
+  const cachedRate = above ? pricing.cachedInputAbove200k ?? pricing.cachedInput ?? inputRate : pricing.cachedInput ?? inputRate;
+  const cached = Math.max(0, Math.min(cachedTokens || 0, promptTokens || 0));
+  const billablePrompt = Math.max(0, (promptTokens || 0) - cached);
+  return billablePrompt / 1e6 * inputRate + cached / 1e6 * cachedRate + ((responseTokens || 0) + (thoughtsTokens || 0)) / 1e6 * outputRate;
+}
 var BaseGemini = class {
   /**
    * @param {BaseGeminiOptions} [options={}]
@@ -422,6 +571,7 @@ var BaseGemini = class {
     } else {
       this.chatConfig.maxOutputTokens = DEFAULT_MAX_OUTPUT_TOKENS;
     }
+    this.effort = this._normalizeEffort(options.effort);
     this._configureThinking(options.thinkingConfig);
     const clientOptions = this.vertexai ? {
       vertexai: true,
@@ -436,6 +586,8 @@ var BaseGemini = class {
     this._cumulativeUsage = {
       promptTokens: 0,
       responseTokens: 0,
+      thoughtsTokens: 0,
+      cachedTokens: 0,
       totalTokens: 0,
       attempts: 0
     };
@@ -453,16 +605,25 @@ var BaseGemini = class {
     logger_default.debug(`Initializing ${this.constructor.name} chat session with model: ${this.modelName}...`);
     const chatOptions = this._getChatCreateOptions();
     this.chatSession = this.genAIClient.chats.create(chatOptions);
-    if (this.healthCheck) {
-      try {
-        await this._withRetry(() => this.genAIClient.models.list());
-        logger_default.debug(`${this.constructor.name}: API connection successful.`);
-      } catch (e) {
-        throw new Error(`${this.constructor.name} initialization failed: ${e.message}`);
-      }
-    }
+    await this._healthCheckPing();
     logger_default.debug(`${this.constructor.name}: Chat session initialized.`);
   }
+  /**
+   * Opt-in connectivity check via `models.list()` — runs only when
+   * `healthCheck: true`. Fails fast (no exponential backoff): a readiness probe
+   * should surface a bad config immediately, not after ~30s of 429 retries.
+   * @returns {Promise<void>}
+   * @protected
+   */
+  async _healthCheckPing() {
+    if (!this.healthCheck) return;
+    try {
+      await this.genAIClient.models.list();
+      logger_default.debug(`${this.constructor.name}: API connection successful.`);
+    } catch (e) {
+      throw new Error(`${this.constructor.name} initialization failed: ${e.message}`);
+    }
+  }
   /**
    * Builds the options object for `genAIClient.chats.create()`.
    * Override in subclasses to add tools, grounding, etc.
@@ -523,7 +684,7 @@ var BaseGemini = class {
     }
     this.chatSession = this._createChatSession([]);
     this.lastResponseMetadata = null;
-    this._cumulativeUsage = { promptTokens: 0, responseTokens: 0, totalTokens: 0, attempts: 0 };
+    this._cumulativeUsage = { promptTokens: 0, responseTokens: 0, thoughtsTokens: 0, cachedTokens: 0, totalTokens: 0, attempts: 0 };
     logger_default.debug(`${this.constructor.name}: Conversation history cleared.`);
   }
   // ── Few-Shot Seeding ─────────────────────────────────────────────────────
@@ -609,12 +770,19 @@ ${contextText}
    */
   _captureMetadata(response) {
     const modelStatus = response?.modelStatus || null;
+    const promptTokens = response.usageMetadata?.promptTokenCount || 0;
+    const responseTokens = response.usageMetadata?.candidatesTokenCount || 0;
+    const thoughtsTokens = response.usageMetadata?.thoughtsTokenCount || 0;
+    const cachedTokens = response.usageMetadata?.cachedContentTokenCount || 0;
     this.lastResponseMetadata = {
       modelVersion: response.modelVersion || null,
       requestedModel: this.modelName,
-      promptTokens: response.usageMetadata?.promptTokenCount || 0,
-      responseTokens: response.usageMetadata?.candidatesTokenCount || 0,
-      totalTokens: response.usageMetadata?.totalTokenCount || 0,
+      promptTokens,
+      responseTokens,
+      thoughtsTokens,
+      cachedTokens,
+      // totalTokenCount includes thoughts; fall back to summing the parts.
+      totalTokens: response.usageMetadata?.totalTokenCount || promptTokens + responseTokens + thoughtsTokens,
       timestamp: Date.now(),
       groundingMetadata: response.candidates?.[0]?.groundingMetadata || null,
       modelStatus
@@ -632,18 +800,73 @@ ${contextText}
   getLastUsage() {
     if (!this.lastResponseMetadata) return null;
     const meta = this.lastResponseMetadata;
-    const cumulative = this._cumulativeUsage || { promptTokens: 0, responseTokens: 0, totalTokens: 0, attempts: 1 };
+    const cumulative = this._cumulativeUsage || { promptTokens: 0, responseTokens: 0, totalTokens: 0, thoughtsTokens: 0, cachedTokens: 0, attempts: 1 };
     const useCumulative = cumulative.attempts > 0;
+    const promptTokens = useCumulative ? cumulative.promptTokens : meta.promptTokens;
+    const responseTokens = useCumulative ? cumulative.responseTokens : meta.responseTokens;
+    const thoughtsTokens = useCumulative ? cumulative.thoughtsTokens || 0 : meta.thoughtsTokens || 0;
+    const totalTokens = useCumulative ? cumulative.totalTokens : meta.totalTokens;
+    const cachedTokens = useCumulative && cumulative.cachedTokens !== void 0 ? cumulative.cachedTokens : meta.cachedTokens || 0;
     return {
-      promptTokens: useCumulative ? cumulative.promptTokens : meta.promptTokens,
-      responseTokens: useCumulative ? cumulative.responseTokens : meta.responseTokens,
-      totalTokens: useCumulative ? cumulative.totalTokens : meta.totalTokens,
+      promptTokens,
+      responseTokens,
+      thoughtsTokens,
+      cachedTokens,
+      totalTokens,
       attempts: useCumulative ? cumulative.attempts : 1,
       modelVersion: meta.modelVersion,
       requestedModel: meta.requestedModel,
       timestamp: meta.timestamp,
       groundingMetadata: meta.groundingMetadata || null,
-      modelStatus: meta.modelStatus || null
+      modelStatus: meta.modelStatus || null,
+      estimatedCost: this._estimatedCost(meta.modelVersion, promptTokens, responseTokens, thoughtsTokens, cachedTokens)
+    };
+  }
+  /**
+   * Estimated USD cost, preferring the model id the API echoed (`modelVersion`)
+   * and falling back to the requested model when that build isn't priced.
+   * @param {string|null|undefined} modelVersion
+   * @param {number} promptTokens
+   * @param {number} responseTokens
+   * @param {number} [thoughtsTokens=0]
+   * @param {number} [cachedTokens=0] - Cached-content tokens (a SUBSET of promptTokens)
+   * @returns {number|null}
+   * @protected
+   */
+  _estimatedCost(modelVersion, promptTokens, responseTokens, thoughtsTokens = 0, cachedTokens = 0) {
+    return computeCost(modelVersion, promptTokens, responseTokens, thoughtsTokens, cachedTokens) ?? computeCost(this.modelName, promptTokens, responseTokens, thoughtsTokens, cachedTokens);
+  }
+  /**
+   * Builds a usage object directly from a single API response, WITHOUT reading
+   * mutable instance state (`lastResponseMetadata`/`_cumulativeUsage`). Safe to
+   * call under concurrent send() calls on a shared instance — unlike
+   * getLastUsage(), which reflects whichever call most recently mutated the
+   * instance and can cross-talk between concurrent sends.
+   * @param {Object} response - A single generateContent() response
+   * @param {number} [attempts=1] - Attempts this call consumed
+   * @returns {UsageData}
+   * @protected
+   */
+  _usageFromResponse(response, attempts = 1) {
+    const promptTokens = response?.usageMetadata?.promptTokenCount || 0;
+    const responseTokens = response?.usageMetadata?.candidatesTokenCount || 0;
+    const thoughtsTokens = response?.usageMetadata?.thoughtsTokenCount || 0;
+    const cachedTokens = response?.usageMetadata?.cachedContentTokenCount || 0;
+    const totalTokens = response?.usageMetadata?.totalTokenCount || promptTokens + responseTokens + thoughtsTokens;
+    const modelVersion = response?.modelVersion || null;
+    return {
+      promptTokens,
+      responseTokens,
+      thoughtsTokens,
+      cachedTokens,
+      totalTokens,
+      attempts,
+      modelVersion,
+      requestedModel: this.modelName,
+      timestamp: Date.now(),
+      groundingMetadata: response?.candidates?.[0]?.groundingMetadata || null,
+      modelStatus: response?.modelStatus || null,
+      estimatedCost: this._estimatedCost(modelVersion, promptTokens, responseTokens, thoughtsTokens, cachedTokens)
     };
   }
   // ── Token Estimation ─────────────────────────────────────────────────────
@@ -679,13 +902,13 @@ ${contextText}
    */
   async estimateCost(nextPayload) {
     const tokenInfo = await this.estimate(nextPayload);
-    const pricing = MODEL_PRICING[this.modelName] || { input: 0, output: 0 };
+    const pricing = resolvePricing(this.modelName);
     return {
       inputTokens: tokenInfo.inputTokens,
       model: this.modelName,
       pricing,
-      estimatedInputCost: tokenInfo.inputTokens / 1e6 * pricing.input,
-      note: "Cost is for input tokens only; output cost depends on response length"
+      estimatedInputCost: pricing ? tokenInfo.inputTokens / 1e6 * pricing.input : null,
+      note: pricing ? "Cost is for input tokens only; output cost depends on response length" : `No pricing known for model "${this.modelName}"; estimatedInputCost is null`
     };
   }
   // ── Context Caching ─────────────────────────────────────────────────────
@@ -848,23 +1071,49 @@ ${contextText}
    */
   _configureThinking(thinkingConfig) {
     const modelSupportsThinking = THINKING_SUPPORTED_MODELS.some((p) => p.test(this.modelName));
-    if (thinkingConfig === void 0) return;
+    if (thinkingConfig === void 0 && this.effort === null) return;
     if (thinkingConfig === null) {
       delete this.chatConfig.thinkingConfig;
       logger_default.debug(`thinkingConfig set to null - removed from configuration`);
       return;
     }
     if (!modelSupportsThinking) {
-      logger_default.warn(`Model ${this.modelName} does not support thinking features. Ignoring thinkingConfig.`);
+      logger_default.warn(`Model ${this.modelName} does not support thinking features. Ignoring thinkingConfig/effort.`);
       return;
     }
-    const config = { ...DEFAULT_THINKING_CONFIG, ...thinkingConfig };
-    if (thinkingConfig.thinkingLevel !== void 0) {
+    const config = { ...DEFAULT_THINKING_CONFIG, ...thinkingConfig || {} };
+    if (this.effort !== null) {
+      const level = EFFORT_TO_THINKING_LEVEL[this.effort];
+      if (level !== this.effort) {
+        logger_default.debug(`Effort '${this.effort}' has no Gemini equivalent; using thinkingLevel '${level}'.`);
+      }
+      config.thinkingLevel = level;
+    }
+    if (config.thinkingLevel !== void 0) {
       delete config.thinkingBudget;
     }
     this.chatConfig.thinkingConfig = config;
     logger_default.debug(`Thinking config applied: ${JSON.stringify(config)}`);
   }
+  /**
+   * Validates the cross-package `effort` option.
+   * Throws rather than warns: this runs in the constructor before log levels are
+   * finalized, so a warning could be swallowed.
+   * @param {string|null|undefined} effort
+   * @returns {'minimal'|'low'|'medium'|'high'|'xhigh'|'max'|null}
+   * @protected
+   */
+  _normalizeEffort(effort) {
+    if (effort === void 0 || effort === null) return null;
+    const level = String(effort).toLowerCase();
+    if (!EFFORT_LEVELS.includes(level)) {
+      throw new Error(`Invalid effort "${effort}". Expected one of: ${EFFORT_LEVELS.join(", ")}.`);
+    }
+    return (
+      /** @type {any} */
+      level
+    );
+  }
 };
 var base_default = BaseGemini;
 
@@ -996,7 +1245,7 @@ var Transformer = class extends base_default {
     let lastPayload = this._preparePayload(payload);
     const messageOptions = {};
     if (opts.labels) messageOptions.labels = opts.labels;
-    this._cumulativeUsage = { promptTokens: 0, responseTokens: 0, totalTokens: 0, attempts: 0 };
+    this._cumulativeUsage = { promptTokens: 0, responseTokens: 0, thoughtsTokens: 0, cachedTokens: 0, totalTokens: 0, attempts: 0 };
     let lastError = null;
     for (let attempt = 0; attempt <= maxRetries; attempt++) {
       try {
@@ -1004,6 +1253,8 @@ var Transformer = class extends base_default {
         if (this.lastResponseMetadata) {
           this._cumulativeUsage.promptTokens += this.lastResponseMetadata.promptTokens || 0;
           this._cumulativeUsage.responseTokens += this.lastResponseMetadata.responseTokens || 0;
+          this._cumulativeUsage.thoughtsTokens += this.lastResponseMetadata.thoughtsTokens || 0;
+          this._cumulativeUsage.cachedTokens += this.lastResponseMetadata.cachedTokens || 0;
           this._cumulativeUsage.totalTokens += this.lastResponseMetadata.totalTokens || 0;
           this._cumulativeUsage.attempts = attempt + 1;
         }
@@ -1139,6 +1390,8 @@ Respond with JSON only \u2013 no comments or explanations.
     this._cumulativeUsage = {
       promptTokens: this.lastResponseMetadata.promptTokens,
       responseTokens: this.lastResponseMetadata.responseTokens,
+      thoughtsTokens: this.lastResponseMetadata.thoughtsTokens,
+      cachedTokens: this.lastResponseMetadata.cachedTokens,
       totalTokens: this.lastResponseMetadata.totalTokens,
       attempts: 1
     };
@@ -1164,7 +1417,7 @@ Respond with JSON only \u2013 no comments or explanations.
     const exampleHistory = history.slice(0, this.exampleCount || 0);
     this.chatSession = this._createChatSession(exampleHistory);
     this.lastResponseMetadata = null;
-    this._cumulativeUsage = { promptTokens: 0, responseTokens: 0, totalTokens: 0, attempts: 0 };
+    this._cumulativeUsage = { promptTokens: 0, responseTokens: 0, thoughtsTokens: 0, cachedTokens: 0, totalTokens: 0, attempts: 0 };
     logger_default.debug(`Conversation cleared. Preserved ${exampleHistory.length} example items.`);
   }
   /**
@@ -1263,6 +1516,8 @@ var Chat = class extends base_default {
     this._cumulativeUsage = {
       promptTokens: this.lastResponseMetadata.promptTokens,
       responseTokens: this.lastResponseMetadata.responseTokens,
+      thoughtsTokens: this.lastResponseMetadata.thoughtsTokens,
+      cachedTokens: this.lastResponseMetadata.cachedTokens,
       totalTokens: this.lastResponseMetadata.totalTokens,
       attempts: 1
     };
@@ -1310,6 +1565,9 @@ var Message = class extends base_default {
     }
     if (options.responseMimeType) {
       this.chatConfig.responseMimeType = options.responseMimeType;
+    } else if (options.responseSchema) {
+      this.chatConfig.responseMimeType = "application/json";
+      logger_default.debug("responseSchema set without responseMimeType \u2014 defaulting responseMimeType to 'application/json'.");
     }
     this._isStructured = !!(options.responseSchema || options.responseMimeType === "application/json");
     logger_default.debug(`Message created (structured=${this._isStructured})`);
@@ -1323,12 +1581,7 @@ var Message = class extends base_default {
   async init(force = false) {
     if (this._initialized && !force) return;
     logger_default.debug(`Initializing ${this.constructor.name} with model: ${this.modelName}...`);
-    try {
-      await this.genAIClient.models.list();
-      logger_default.debug(`${this.constructor.name}: API connection successful.`);
-    } catch (e) {
-      throw new Error(`${this.constructor.name} initialization failed: ${e.message}`);
-    }
+    await this._healthCheckPing();
     this._initialized = true;
     logger_default.debug(`${this.constructor.name}: Initialized (stateless mode).`);
   }
@@ -1354,10 +1607,13 @@ var Message = class extends base_default {
         ...this.vertexai && Object.keys(mergedLabels).length > 0 && { labels: mergedLabels }
       }
     }));
+    const usage = this._usageFromResponse(result);
     this._captureMetadata(result);
     this._cumulativeUsage = {
       promptTokens: this.lastResponseMetadata.promptTokens,
       responseTokens: this.lastResponseMetadata.responseTokens,
+      thoughtsTokens: this.lastResponseMetadata.thoughtsTokens,
+      cachedTokens: this.lastResponseMetadata.cachedTokens,
       totalTokens: this.lastResponseMetadata.totalTokens,
       attempts: 1
     };
@@ -1367,7 +1623,7 @@ var Message = class extends base_default {
     const text = result.text || "";
     const response = {
       text,
-      usage: this.getLastUsage()
+      usage
     };
     if (this._isStructured) {
       try {
@@ -1515,6 +1771,8 @@ var ToolAgent = class extends base_default {
     this._cumulativeUsage = {
       promptTokens: this.lastResponseMetadata.promptTokens,
       responseTokens: this.lastResponseMetadata.responseTokens,
+      thoughtsTokens: this.lastResponseMetadata.thoughtsTokens,
+      cachedTokens: this.lastResponseMetadata.cachedTokens,
       totalTokens: this.lastResponseMetadata.totalTokens,
       attempts: 1
     };
@@ -2526,6 +2784,8 @@ ${this.envOverview}`;
     this._cumulativeUsage = {
       promptTokens: this.lastResponseMetadata.promptTokens,
       responseTokens: this.lastResponseMetadata.responseTokens,
+      thoughtsTokens: this.lastResponseMetadata.thoughtsTokens,
+      cachedTokens: this.lastResponseMetadata.cachedTokens,
       totalTokens: this.lastResponseMetadata.totalTokens,
       attempts: 1
     };
@@ -2844,6 +3104,8 @@ ${serialized}` });
     this._cumulativeUsage = {
       promptTokens: this.lastResponseMetadata.promptTokens,
       responseTokens: this.lastResponseMetadata.responseTokens,
+      thoughtsTokens: this.lastResponseMetadata.thoughtsTokens,
+      cachedTokens: this.lastResponseMetadata.cachedTokens,
       totalTokens: this.lastResponseMetadata.totalTokens,
       attempts: 1
     };
@@ -2981,12 +3243,7 @@ var Embedding = class extends base_default {
   async init(force = false) {
     if (this._initialized && !force) return;
     logger_default.debug(`Initializing ${this.constructor.name} with model: ${this.modelName}...`);
-    try {
-      await this.genAIClient.models.list();
-      logger_default.debug(`${this.constructor.name}: API connection successful.`);
-    } catch (e) {
-      throw new Error(`${this.constructor.name} initialization failed: ${e.message}`);
-    }
+    await this._healthCheckPing();
     this._initialized = true;
     logger_default.debug(`${this.constructor.name}: Initialized (stateless mode).`);
   }
@@ -3118,12 +3375,7 @@ var ImageGenerator = class extends base_default {
   async init(force = false) {
     if (this._initialized && !force) return;
     logger_default.debug(`Initializing ${this.constructor.name} with model: ${this.modelName}...`);
-    try {
-      await this.genAIClient.models.list();
-      logger_default.debug(`${this.constructor.name}: API connection successful.`);
-    } catch (e) {
-      throw new Error(`${this.constructor.name} initialization failed: ${e.message}`);
-    }
+    await this._healthCheckPing();
     this._initialized = true;
   }
   /**
@@ -3165,10 +3417,13 @@ var ImageGenerator = class extends base_default {
       contents: [{ role: "user", parts }],
       config: this._buildConfig(opts)
     }));
+    const usage = this._usageFromResponse(result);
     this._captureMetadata(result);
     this._cumulativeUsage = {
       promptTokens: this.lastResponseMetadata.promptTokens,
       responseTokens: this.lastResponseMetadata.responseTokens,
+      thoughtsTokens: this.lastResponseMetadata.thoughtsTokens,
+      cachedTokens: this.lastResponseMetadata.cachedTokens,
       totalTokens: this.lastResponseMetadata.totalTokens,
       attempts: 1
     };
@@ -3188,7 +3443,7 @@ var ImageGenerator = class extends base_default {
     if (images.length === 0) {
       logger_default.warn("ImageGenerator: no images returned. Check prompt or safety filters.");
     }
-    return { images, text: text || null, usage: this.getLastUsage() };
+    return { images, text: text || null, usage };
   }
   /**
    * Convenience: write one or all images to disk.
@@ -3244,16 +3499,23 @@ var index_default = { Transformer: transformer_default, Chat: chat_default, Mess
   BaseGemini,
   Chat,
   CodeAgent,
+  EFFORT_LEVELS,
   Embedding,
   HarmBlockThreshold,
   HarmCategory,
   ImageGenerator,
+  MODEL_ALIASES,
+  MODEL_PRICING,
+  MODEL_PRICING_AS_OF,
   Message,
   RagAgent,
   ThinkingLevel,
   ToolAgent,
   Transformer,
   attemptJSONRecovery,
+  computeCost,
   extractJSON,
-  log
+  log,
+  resolvePricing,
+  validateSchema
 });

package/index.js

@@ -29,9 +29,10 @@ export { default as RagAgent } from './rag-agent.js';
 export { default as Embedding } from './embedding.js';
 export { default as ImageGenerator } from './image-generator.js';
 export { default as BaseGemini } from './base.js';
+export { MODEL_PRICING, MODEL_PRICING_AS_OF, MODEL_ALIASES, EFFORT_LEVELS, resolvePricing, computeCost } from './base.js';
 export { default as log } from './logger.js';
 export { ThinkingLevel, HarmCategory, HarmBlockThreshold } from '@google/genai';
-export { extractJSON, attemptJSONRecovery } from './json-helpers.js';
+export { extractJSON, attemptJSONRecovery, validateSchema } from './json-helpers.js';
 
 // ── Default Export (namespace object) ──