cloudbroker-sdk 0.6.0 → 0.7.0

package/README.md

@@ -46,6 +46,62 @@ const res = await anthropic.messages.create({
 });
 ```
 
+## Uso com Gemini
+
+```js
+import { GoogleGenAI } from "@google/genai";
+import { CloudBrokerAI } from "cloudbroker-sdk";
+
+const gemini = CloudBrokerAI.wrap(new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY }), {
+  apiKey:  "cb-key-xxxx",
+  product: "checkout",
+  team:    "mobile",
+});
+
+const res = await gemini.models.generateContent({
+  model:    "gemini-2.5-flash",
+  contents: "Olá!",
+});
+```
+
+O `cbLabel` pode ir no próprio params (a API do Gemini é de argumento único) ou
+no segundo argumento, como nos outros wrappers. Nos dois casos ele é removido
+antes de a chamada seguir pro Google:
+
+```js
+await gemini.models.generateContent({
+  model: "gemini-2.5-flash", contents: "…", cbLabel: "checkout:resumo-pedido",
+});
+```
+
+### Por que o custo do Gemini não é `input × preço + output × preço`
+
+A conta do Gemini tem três particularidades. Ignorar qualquer uma delas erra o
+valor de forma relevante, então o SDK trata as três:
+
+| Particularidade | O que acontece se ignorar |
+|---|---|
+| `promptTokenCount` **já inclui** os tokens servidos de cache, que custam ~10x menos | superfatura a parcela cacheada (1,65x a mais num prompt 80% cacheado) |
+| `thoughtsTokenCount` é separado de `candidatesTokenCount` e é cobrado como output | subfatura — 33x a menos num caso com 2000 thinking tokens |
+| 2.5 Pro dobra de preço acima de 200k tokens de prompt; áudio na entrada custa mais que texto | subfatura prompts longos e entrada de áudio |
+
+### Limitações declaradas
+
+- **O custo é estimado por tabela de preço local**, não lido de uma fatura. O
+  Gemini não expõe API de uso ou custo por chave — só o dashboard do AI Studio
+  e o console do Cloud Billing. Os preços são os do paid tier publicados em
+  `ai.google.dev/gemini-api/docs/pricing`, conferidos em 2026-08-02, e **não
+  foram calibrados contra fatura real**.
+- **Free tier sai com custo > 0.** A tabela é a do paid tier; quem está no free
+  tier vê o valor que *pagaria*, não o que paga.
+- **Modelo fora da tabela não recebe preço de outro modelo.** O evento vai com
+  `costUSD: null` e `unpriced: true`, preservando os tokens. Variante com sufixo
+  (`-preview-…`) é precificada pelo modelo base e marcada `approxPricing`.
+- **Armazenamento de contexto em cache não é cobrado aqui.** O Google cobra por
+  hora de cache ativo (US$ 1,00/h na maioria dos modelos); isso não aparece no
+  `usageMetadata` de uma chamada e não é modelado.
+- **Batch API não é modelada** — o Google cobra metade nesse modo.
+
 ## Streaming
 
 Chamadas com `stream: true` também são rastreadas — o SDK observa os chunks

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cloudbroker-sdk",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "CloudBroker SDK — Token Intelligence & Operational Financial Intelligence",
   "main": "src/index.js",
   "type": "module",
@@ -8,7 +8,7 @@
     ".": "./src/index.js"
   },
   "scripts": {
-    "test": "node src/test.js && node src/test-azure-real.js"
+    "test": "node src/test.js && node src/test-azure-real.js && node src/test-gemini-real.js"
   },
   "keywords": [
     "cloudbroker",
@@ -20,6 +20,7 @@
   "license": "MIT",
   "devDependencies": {
     "@azure/cosmos": "^4.10.0",
-    "@azure/storage-blob": "^12.33.0"
+    "@azure/storage-blob": "^12.33.0",
+    "@google/genai": "^2.15.0"
   }
 }

package/src/client.js

@@ -48,7 +48,7 @@ export class CloudBrokerClient {
     try {
       const payload = {
         ...event,
-        sdkVersion: "0.6.0",
+        sdkVersion: "0.7.0",
         sentAt: new Date().toISOString(),
       };
       if (this.#cloudQueue.length < MAX_QUEUE_SIZE) {
@@ -104,7 +104,7 @@ export class CloudBrokerClient {
     try {
       const payload = {
         ...event,
-        sdkVersion: "0.6.0",
+        sdkVersion: "0.7.0",
         sentAt: new Date().toISOString(),
       };
 

package/src/pricing.js

@@ -24,9 +24,167 @@ export const PRICING = {
     "claude-3-sonnet-20240229": { input: 0.000003,    output: 0.000015   },
     "claude-3-haiku-20240307":  { input: 0.00000025,  output: 0.00000125 },
   },
+  /**
+   * Gemini — preços do paid tier em ai.google.dev/gemini-api/docs/pricing,
+   * conferidos em 2026-08-02. A página publica por 1M de tokens; aqui, como no
+   * resto da tabela, o valor é por token.
+   *
+   * A conta do Gemini tem três particularidades que um par `{input, output}`
+   * plano não expressa — ignorar qualquer uma delas erra o custo de verdade:
+   *
+   *  - `cached`     — prompt servido de cache custa ~10x menos. Atenção:
+   *                   `promptTokenCount` JÁ INCLUI os tokens cacheados, então o
+   *                   input a preço cheio é `prompt - cached`. Cobrar o prompt
+   *                   inteiro a preço cheio superfatura em 10x essa parcela.
+   *  - `audioInput` — áudio na entrada custa mais que texto/imagem/vídeo nos
+   *                   Flash e Flash-Lite. A separação sai de
+   *                   `promptTokensDetails[].modality === "AUDIO"`.
+   *  - `tierOver`   — o 2.5 Pro dobra acima de 200k tokens de prompt.
+   *
+   * Os modelos 1.5/2.0 que existiam aqui foram removidos: a página oficial não
+   * os lista mais, e manter preço não verificável é fabricar custo. Eles caem
+   * agora no caminho de modelo desconhecido (`costUSD: null`), que é honesto.
+   *
+   * Thinking tokens não aparecem nesta tabela porque não têm preço próprio —
+   * a página diz "Output price (including thinking tokens)", ou seja, são
+   * cobrados como output. Quem soma é `priceGemini()`.
+   */
   gemini: {
-    "gemini-1.5-pro":           { input: 0.0000035,   output: 0.0000105  },
-    "gemini-1.5-flash":         { input: 0.00000035,  output: 0.00000105 },
-    "gemini-2.0-flash":         { input: 0.0000001,   output: 0.0000004  },
+    "gemini-3.6-flash":      { input: 0.0000015,  output: 0.0000075, cached: 0.00000015 },
+    "gemini-3.5-flash":      { input: 0.0000015,  output: 0.000009,  cached: 0.00000015 },
+    "gemini-3.5-flash-lite": { input: 0.0000003,  output: 0.0000025, cached: 0.00000003 },
+    "gemini-3.1-flash-lite": {
+      input: 0.00000025, output: 0.0000015, cached: 0.000000025,
+      audioInput: 0.0000005, audioCached: 0.00000005,
+    },
+    "gemini-2.5-pro": {
+      input: 0.00000125, output: 0.00001, cached: 0.000000125,
+      tierOver: {
+        promptTokens: 200000,
+        input: 0.0000025, output: 0.000015, cached: 0.00000025,
+      },
+    },
+    "gemini-2.5-flash": {
+      input: 0.0000003, output: 0.0000025, cached: 0.00000003,
+      audioInput: 0.000001, audioCached: 0.0000001,
+    },
+    "gemini-2.5-flash-lite": {
+      input: 0.0000001, output: 0.0000004, cached: 0.00000001,
+      audioInput: 0.0000003, audioCached: 0.00000003,
+    },
   },
 };
+
+/**
+ * Resolve a entrada de preço de um modelo Gemini.
+ *
+ * A API devolve `modelVersion` que muitas vezes carrega sufixo (`-preview-…`,
+ * data). Exigir igualdade exata deixaria quase toda resposta real sem preço;
+ * casar por prefixo sem avisar seria afirmar que preview custa o mesmo que GA,
+ * o que não é garantido. Então: exato é exato, prefixo é marcado `approx`, e o
+ * que não casa não recebe preço de outro modelo.
+ *
+ * @returns {{ id: string, rates: object, approx: boolean } | null}
+ */
+function resolveGeminiModel(model) {
+  if (!model) return null;
+  const table = PRICING.gemini;
+  if (table[model]) return { id: model, rates: table[model], approx: false };
+
+  // Prefixo mais longo primeiro: "gemini-3.5-flash-lite" tem que ganhar de
+  // "gemini-3.5-flash" para "gemini-3.5-flash-lite-preview-01".
+  const match = Object.keys(table)
+    .filter(id => model.startsWith(id))
+    .sort((a, b) => b.length - a.length)[0];
+
+  return match ? { id: match, rates: table[match], approx: true } : null;
+}
+
+/**
+ * Calcula o custo de uma chamada Gemini a partir do `usageMetadata` da resposta.
+ *
+ * Nomes de campo conferidos nos tipos do @google/genai@2.15.0 — a doc pública
+ * mostra um formato snake_case (`total_input_tokens`) que é de outra superfície
+ * da API; o `generateContent` devolve camelCase.
+ *
+ * @param {string} model — `modelVersion` da resposta, ou o pedido na chamada
+ * @param {object} usage — `response.usageMetadata`
+ * @returns {{
+ *   costUSD: number|null, inputTokens: number, outputTokens: number,
+ *   totalTokens: number, cachedTokens: number, thoughtsTokens: number,
+ *   audioInputTokens: number, pricedAs: string|null, approxPricing: boolean,
+ *   unpriced: boolean, reason: string|null
+ * }}
+ */
+export function priceGemini(model, usage = {}) {
+  const prompt   = usage.promptTokenCount        || 0;
+  const cached   = usage.cachedContentTokenCount || 0;
+  const output   = usage.candidatesTokenCount    || 0;
+  const thoughts = usage.thoughtsTokenCount      || 0;
+  const toolUse  = usage.toolUsePromptTokenCount || 0;
+
+  // `prompt` já inclui `cached` — o restante é que sai a preço cheio.
+  // Nunca deixar negativo: se a API mudar a semântica, subfaturar em silêncio
+  // é pior do que somar 0.
+  const fullPriceInput = Math.max(0, prompt - cached);
+
+  // Áudio na entrada tem preço próprio em parte dos modelos. O detalhamento
+  // por modalidade se refere ao prompt inteiro (cacheado incluso), então o
+  // recorte de áudio a preço cheio é proporcional ao que não veio de cache.
+  const audioDetail = (usage.promptTokensDetails || [])
+    .find(d => d?.modality === "AUDIO")?.tokenCount || 0;
+  const audioFullPrice = prompt > 0
+    ? Math.round(audioDetail * (fullPriceInput / prompt))
+    : 0;
+  const audioCached = Math.max(0, audioDetail - audioFullPrice);
+
+  const base = {
+    inputTokens:      prompt + toolUse,
+    outputTokens:     output + thoughts,
+    totalTokens:      usage.totalTokenCount || (prompt + output + thoughts + toolUse),
+    cachedTokens:     cached,
+    thoughtsTokens:   thoughts,
+    audioInputTokens: audioDetail,
+  };
+
+  const resolved = resolveGeminiModel(model);
+  if (!resolved) {
+    return {
+      ...base,
+      costUSD:       null,
+      pricedAs:      null,
+      approxPricing: false,
+      unpriced:      true,
+      reason:        `Modelo "${model || "desconhecido"}" não está na tabela de preço do Gemini — tokens registrados, custo não estimado.`,
+    };
+  }
+
+  // O 2.5 Pro troca de faixa pelo tamanho do prompt.
+  let rates = resolved.rates;
+  if (rates.tierOver && prompt > rates.tierOver.promptTokens) {
+    rates = { ...rates, ...rates.tierOver };
+  }
+
+  const textFullPrice = Math.max(0, fullPriceInput - audioFullPrice);
+  const textCached    = Math.max(0, cached - audioCached);
+
+  const costUSD =
+      textFullPrice  * rates.input
+    + audioFullPrice * (rates.audioInput  ?? rates.input)
+    + textCached     * (rates.cached      ?? rates.input)
+    + audioCached    * (rates.audioCached ?? rates.cached ?? rates.input)
+    + toolUse        * rates.input
+    // Thinking tokens são cobrados como output.
+    + (output + thoughts) * rates.output;
+
+  return {
+    ...base,
+    costUSD:       parseFloat(costUSD.toFixed(8)),
+    pricedAs:      resolved.id,
+    approxPricing: resolved.approx,
+    unpriced:      false,
+    reason:        resolved.approx
+      ? `Preço do modelo base "${resolved.id}" aplicado a "${model}" — variante não listada na tabela oficial.`
+      : null,
+  };
+}

package/src/test-gemini-real.js

@@ -0,0 +1,270 @@
+/**
+ * Teste do wrapGemini contra o cliente REAL do @google/genai — não contra uma
+ * fake escrita à mão.
+ *
+ * Por que existe: a mesma razão do test-azure-real.js. Uma fake desenhada pra
+ * casar com a implementação não reprova suposição errada sobre o SDK de
+ * verdade. E aqui havia uma suposição especialmente perigosa: a doc pública do
+ * Gemini mostra o usage em snake_case (`total_input_tokens`), que pertence a
+ * outra superfície da API — o `generateContent` devolve camelCase
+ * (`promptTokenCount`). Ter errado isso daria token zero em silêncio, sem
+ * nenhum erro. Este arquivo trava os nomes contra os tipos do pacote instalado.
+ *
+ * Não faz chamada de rede: a chave é sintética e o método original é
+ * substituído por um stub antes do wrap ser exercitado.
+ *
+ * Execute: node src/test-gemini-real.js
+ */
+import assert from "node:assert";
+import { readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { GoogleGenAI } from "@google/genai";
+import { CloudBrokerAI } from "./wrapper.js";
+import { priceGemini, PRICING } from "./pricing.js";
+
+const require = createRequire(import.meta.url);
+
+// O pacote não expõe "./package.json" em `exports`, então o caminho dos tipos
+// é derivado do entry point resolvido (.../dist/node/index.cjs → .../dist).
+function typingsPath() {
+  const entry = require.resolve("@google/genai");
+  return entry.slice(0, entry.indexOf("/dist/") + "/dist/".length) + "genai.d.ts";
+}
+
+let ok = 0, fail = 0;
+const t = (name, fn) => {
+  try { fn(); console.log(`✅ ${name}`); ok++; }
+  catch (e) { console.error(`❌ ${name}\n   ${e.message}`); fail++; }
+};
+const ta = async (name, fn) => {
+  try { await fn(); console.log(`✅ ${name}`); ok++; }
+  catch (e) { console.error(`❌ ${name}\n   ${e.message}`); fail++; }
+};
+
+console.log("🧪 wrapGemini contra o SDK real do Google (sem rede)\n");
+
+// ── O contrato de nomes que a implementação assume ───────────────────────────
+t("usageMetadata do @google/genai é camelCase, como a implementação assume", () => {
+  const dts = readFileSync(typingsPath(), "utf8");
+  const decl = dts.slice(dts.indexOf("declare class GenerateContentResponseUsageMetadata"));
+  const body = decl.slice(0, decl.indexOf("\n}"));
+  for (const field of [
+    "promptTokenCount", "candidatesTokenCount", "thoughtsTokenCount",
+    "cachedContentTokenCount", "toolUsePromptTokenCount", "totalTokenCount",
+    "promptTokensDetails",
+  ]) {
+    assert.ok(body.includes(`${field}?:`), `campo ${field} sumiu do SDK — a extração de token quebra em silêncio`);
+  }
+});
+
+t("promptTokenCount continua incluindo os tokens cacheados", () => {
+  // A fórmula subtrai `cached` de `prompt`. Se o SDK mudar essa semântica, a
+  // subtração passa a subfaturar — e nada mais no código avisaria.
+  const dts = readFileSync(typingsPath(), "utf8");
+  const i = dts.indexOf("promptTokenCount?:");
+  const doc = dts.slice(Math.max(0, i - 400), i);
+  assert.ok(
+    /also includes the number of tokens in the cached content/i.test(doc),
+    "a doc do campo mudou — revisar `fullPriceInput = prompt - cached` em pricing.js",
+  );
+});
+
+// ── Detecção do cliente real ─────────────────────────────────────────────────
+const raw = new GoogleGenAI({ apiKey: "cb-test-synthetic" });
+
+t("cliente real tem a forma que a detecção procura", () => {
+  assert.strictEqual(raw.constructor.name, "GoogleGenAI");
+  assert.strictEqual(typeof raw.models.generateContent, "function");
+  assert.strictEqual(typeof raw.models.generateContentStream, "function");
+});
+
+t("não colide com a detecção de OpenAI nem de Anthropic", () => {
+  assert.ok(!raw.chat?.completions, "cairia no ramo da OpenAI");
+  assert.ok(!raw.messages?.create,  "cairia no ramo da Anthropic");
+});
+
+// ── Instrumentação ───────────────────────────────────────────────────────────
+// Stub do método original: nenhuma rede, e devolve um usageMetadata realista.
+const tracked = [];
+function makeClient(usageMetadata, { modelVersion = "gemini-2.5-flash" } = {}) {
+  const c = new GoogleGenAI({ apiKey: "cb-test-synthetic" });
+  let seenParams = null;
+  c.models.generateContent = async (params) => {
+    seenParams = params;
+    return { modelVersion, usageMetadata, candidates: [] };
+  };
+  c.models.generateContentStream = async (params) => {
+    seenParams = params;
+    return (async function* () {
+      yield { modelVersion, candidates: [] };
+      yield { modelVersion, usageMetadata, candidates: [] };
+    })();
+  };
+  const wrapped = CloudBrokerAI.wrap(c, { apiKey: "cb-test-key", product: "checkout" });
+  // Intercepta o envio pra inspecionar o evento sem rede.
+  wrapped.trackDeploy = wrapped.trackDeploy; // preserva
+  return { wrapped, getParams: () => seenParams };
+}
+
+// O client.track empurra pra fila e tenta flush em background; aqui trocamos o
+// CloudBrokerClient por captura direta, via monkey-patch do fetch global.
+const realFetch = globalThis.fetch;
+globalThis.fetch = async (url, init) => {
+  try {
+    const body = JSON.parse(init?.body || "{}");
+    for (const ev of (body.events || [])) tracked.push(ev);
+  } catch { /* ignora */ }
+  return { ok: true, status: 200, json: async () => ({ ok: true }) };
+};
+
+await ta("generateContent registra tokens reais e não altera a resposta", async () => {
+  tracked.length = 0;
+  const { wrapped } = makeClient({
+    promptTokenCount: 1000, candidatesTokenCount: 500, totalTokenCount: 1500,
+  });
+  const res = await wrapped.models.generateContent({ model: "gemini-2.5-flash", contents: "oi" });
+  assert.strictEqual(res.modelVersion, "gemini-2.5-flash", "resposta original tem que passar intacta");
+  await new Promise(r => setTimeout(r, 30));
+  const ev = tracked.at(-1);
+  assert.ok(ev, "nenhum evento registrado");
+  assert.strictEqual(ev.provider, "gemini");
+  assert.strictEqual(ev.inputTokens, 1000);
+  assert.strictEqual(ev.outputTokens, 500);
+  assert.strictEqual(ev.costUSD, priceGemini("gemini-2.5-flash", { promptTokenCount: 1000, candidatesTokenCount: 500 }).costUSD);
+});
+
+await ta("thinking tokens entram no output (senão o custo sai muito menor)", async () => {
+  tracked.length = 0;
+  const { wrapped } = makeClient({
+    promptTokenCount: 100, candidatesTokenCount: 50, thoughtsTokenCount: 2000,
+  });
+  await wrapped.models.generateContent({ model: "gemini-2.5-flash", contents: "oi" });
+  await new Promise(r => setTimeout(r, 30));
+  const ev = tracked.at(-1);
+  assert.strictEqual(ev.outputTokens, 2050, "thoughts precisa somar ao output");
+  assert.strictEqual(ev.thoughtsTokens, 2000);
+  const ingenuo = 100 * PRICING.gemini["gemini-2.5-flash"].input + 50 * PRICING.gemini["gemini-2.5-flash"].output;
+  assert.ok(ev.costUSD > ingenuo * 10, "ignorar thoughts subfaturaria em mais de 10x");
+});
+
+await ta("tokens cacheados saem ao preço de cache, não ao preço cheio", async () => {
+  tracked.length = 0;
+  const { wrapped } = makeClient({
+    promptTokenCount: 1000, cachedContentTokenCount: 800, candidatesTokenCount: 100,
+  });
+  await wrapped.models.generateContent({ model: "gemini-2.5-flash", contents: "oi" });
+  await new Promise(r => setTimeout(r, 30));
+  const ev = tracked.at(-1);
+  const r = PRICING.gemini["gemini-2.5-flash"];
+  assert.strictEqual(ev.cachedTokens, 800);
+  assert.ok(Math.abs(ev.costUSD - (200 * r.input + 800 * r.cached + 100 * r.output)) < 1e-9);
+  const cheio = 1000 * r.input + 100 * r.output;
+  assert.ok(ev.costUSD < cheio, "cobrar o prompt inteiro a preço cheio superfaturaria");
+});
+
+await ta("modelo fora da tabela registra tokens sem inventar preço", async () => {
+  tracked.length = 0;
+  const { wrapped } = makeClient(
+    { promptTokenCount: 1000, candidatesTokenCount: 500 },
+    { modelVersion: "gemini-9.9-ultra" },
+  );
+  await wrapped.models.generateContent({ model: "gemini-9.9-ultra", contents: "oi" });
+  await new Promise(r => setTimeout(r, 30));
+  const ev = tracked.at(-1);
+  assert.strictEqual(ev.costUSD, null, "custo tem que ser null, nunca o preço de outro modelo");
+  assert.strictEqual(ev.unpriced, true);
+  assert.strictEqual(ev.inputTokens, 1000, "os tokens continuam sendo registrados");
+  assert.ok(ev.pricingNote?.includes("gemini-9.9-ultra"));
+});
+
+await ta("resposta sem usageMetadata não vira custo zero silencioso", async () => {
+  tracked.length = 0;
+  const { wrapped } = makeClient(undefined);
+  await wrapped.models.generateContent({ model: "gemini-2.5-flash", contents: "oi" });
+  await new Promise(r => setTimeout(r, 30));
+  const ev = tracked.at(-1);
+  assert.strictEqual(ev.totalTokens, 0);
+  assert.strictEqual(ev.costUSD, 0, "sem tokens, zero é o valor correto — o caso perigoso é o modelo desconhecido");
+});
+
+await ta("cbLabel é aceito no params e NÃO vaza pra API do provider", async () => {
+  tracked.length = 0;
+  const { wrapped, getParams } = makeClient({ promptTokenCount: 10, candidatesTokenCount: 5 });
+  await wrapped.models.generateContent({ model: "gemini-2.5-flash", contents: "oi", cbLabel: "checkout:resumo" });
+  await new Promise(r => setTimeout(r, 30));
+  assert.ok(!("cbLabel" in getParams()), "cbLabel vazou pro SDK do Google");
+  assert.strictEqual(tracked.at(-1).label, "checkout:resumo");
+});
+
+await ta("cbLabel também funciona no segundo argumento (convenção dos outros wrappers)", async () => {
+  tracked.length = 0;
+  const { wrapped } = makeClient({ promptTokenCount: 10, candidatesTokenCount: 5 });
+  await wrapped.models.generateContent({ model: "gemini-2.5-flash", contents: "oi" }, { cbLabel: "billing:fatura" });
+  await new Promise(r => setTimeout(r, 30));
+  assert.strictEqual(tracked.at(-1).label, "billing:fatura");
+});
+
+await ta("streaming acumula o usage do chunk final e entrega todos os chunks", async () => {
+  tracked.length = 0;
+  const { wrapped } = makeClient({
+    promptTokenCount: 300, candidatesTokenCount: 200, thoughtsTokenCount: 100,
+  });
+  const stream = await wrapped.models.generateContentStream({ model: "gemini-2.5-flash", contents: "oi" });
+  let chunks = 0;
+  for await (const _ of stream) chunks++;
+  await new Promise(r => setTimeout(r, 30));
+  const ev = tracked.at(-1);
+  assert.strictEqual(chunks, 2, "o consumidor tem que receber os chunks originais");
+  assert.strictEqual(ev.streaming, true);
+  assert.strictEqual(ev.inputTokens, 300);
+  assert.strictEqual(ev.outputTokens, 300, "200 candidates + 100 thoughts");
+});
+
+await ta("erro do provider passa intacto e não é engolido pela instrumentação", async () => {
+  const c = new GoogleGenAI({ apiKey: "cb-test-synthetic" });
+  c.models.generateContent = async () => { throw new Error("429 quota exceeded"); };
+  const wrapped = CloudBrokerAI.wrap(c, { apiKey: "cb-test-key" });
+  await assert.rejects(
+    () => wrapped.models.generateContent({ model: "gemini-2.5-flash", contents: "oi" }),
+    /429 quota exceeded/,
+  );
+});
+
+globalThis.fetch = realFetch;
+
+// ── Preço: casos que o wrapper não exercita ──────────────────────────────────
+const near = (a, b) => Math.abs(a - b) < 1e-9;
+
+t("2.5 Pro troca de faixa acima de 200k tokens de prompt", () => {
+  const base = priceGemini("gemini-2.5-pro", { promptTokenCount: 1000, candidatesTokenCount: 100 });
+  assert.ok(near(base.costUSD, 1000 * 0.00000125 + 100 * 0.00001), "abaixo do corte usa preço base");
+
+  const alto = priceGemini("gemini-2.5-pro", { promptTokenCount: 250000, candidatesTokenCount: 1000 });
+  assert.ok(near(alto.costUSD, 250000 * 0.0000025 + 1000 * 0.000015), "acima de 200k dobra");
+});
+
+t("áudio na entrada é cobrado à parte do texto", () => {
+  const r = PRICING.gemini["gemini-2.5-flash"];
+  const p = priceGemini("gemini-2.5-flash", {
+    promptTokenCount: 1000,
+    promptTokensDetails: [{ modality: "AUDIO", tokenCount: 400 }, { modality: "TEXT", tokenCount: 600 }],
+  });
+  assert.ok(near(p.costUSD, 600 * r.input + 400 * r.audioInput));
+  assert.ok(p.costUSD > 1000 * r.input, "tratar áudio como texto subfaturaria");
+});
+
+t("variante com sufixo casa pelo prefixo MAIS LONGO e é marcada aproximada", () => {
+  const p = priceGemini("gemini-2.5-flash-lite-preview-06", { promptTokenCount: 1000 });
+  assert.strictEqual(p.pricedAs, "gemini-2.5-flash-lite", "não pode cair no 'gemini-2.5-flash', que é mais caro");
+  assert.strictEqual(p.approxPricing, true, "preço de variante não listada tem que sair sinalizado");
+});
+
+t("modelos 1.5/2.0 removidos não são precificados por engano", () => {
+  // Saíram da página oficial; manter preço não verificável seria fabricar custo.
+  for (const legado of ["gemini-1.5-pro", "gemini-1.5-flash", "gemini-2.0-flash"]) {
+    assert.strictEqual(priceGemini(legado, { promptTokenCount: 100 }).costUSD, null, legado);
+  }
+});
+
+console.log(`\n${fail === 0 ? "🎉 TODOS PASSARAM" : "💥 FALHAS"}: ${ok} ok, ${fail} fail`);
+process.exitCode = fail === 0 ? 0 : 1;

package/src/wrapper.js

@@ -4,7 +4,7 @@
  */
 
 import { CloudBrokerClient } from "./client.js";
-import { PRICING } from "./pricing.js";
+import { PRICING, priceGemini } from "./pricing.js";
 import { cbStore } from "./context.js";
 
 export class CloudBrokerAI {
@@ -35,12 +35,18 @@ export class CloudBrokerAI {
     // Adiciona trackDeploy ao cliente wrappado
     client.trackDeploy = cb.trackDeploy.bind(cb);
 
-    // Detecta provider pelo tipo do cliente
+    // Detecta provider pelo tipo do cliente.
+    // O sinal do Gemini é `models.generateContent`, não `models`: o cliente da
+    // OpenAI também tem `.models` (list/retrieve), então checar só o objeto
+    // casaria com o cliente errado.
     const isOpenAI    = client?.constructor?.name === "OpenAI"    || !!client?.chat?.completions;
     const isAnthropic = client?.constructor?.name === "Anthropic" || !!client?.messages?.create;
+    const isGemini    = client?.constructor?.name === "GoogleGenAI"
+                     || typeof client?.models?.generateContent === "function";
 
     if (isOpenAI)    return CloudBrokerAI.#wrapOpenAI(client, cb, { product, team, debug });
     if (isAnthropic) return CloudBrokerAI.#wrapAnthropic(client, cb, { product, team, debug });
+    if (isGemini)    return CloudBrokerAI.#wrapGemini(client, cb, { product, team, debug });
 
     if (debug) console.warn("[CloudBroker] Provider não reconhecido — retornando cliente original.");
     return client;
@@ -254,6 +260,123 @@ export class CloudBrokerAI {
     return client;
   }
 
+  /**
+   * Instrumenta o cliente do @google/genai (`new GoogleGenAI({apiKey})`).
+   *
+   * Diferenças relevantes em relação a OpenAI/Anthropic:
+   *
+   *  - A API é de argumento único (`models.generateContent({model, contents})`),
+   *    sem segundo parâmetro de options. Por isso o `cbLabel` é aceito das duas
+   *    formas: no segundo argumento (convenção dos outros wrappers) e dentro do
+   *    próprio params — neste caso removido antes de repassar, pra nunca vazar
+   *    campo desconhecido para a API do provider.
+   *  - O usage vem em `usageMetadata` (camelCase). Os nomes foram conferidos nos
+   *    tipos do @google/genai@2.15.0, não na doc pública: a doc mostra um
+   *    formato snake_case que pertence a outra superfície da API, e usá-lo
+   *    daria token zero em silêncio.
+   *  - `costUSD` pode ser `null` (modelo fora da tabela de preço). Isso é
+   *    deliberado: registrar tokens sem inventar preço. Quem consome precisa
+   *    olhar `unpriced` — tratar `null` como zero vira "custo real zero".
+   */
+  static #wrapGemini(client, cb, { product, team, debug }) {
+    const models = client.models;
+    if (!models || typeof models.generateContent !== "function") return client;
+
+    // Extrai o cbLabel e devolve os params limpos pra repassar ao provider.
+    const splitLabel = (params, options) => {
+      let label = null, fwd = params;
+      try {
+        label = options?.cbLabel ?? null;
+        if (!label && params && typeof params === "object" && params.cbLabel != null) {
+          label = params.cbLabel;
+        }
+        if (!label) label = cbStore.getStore()?.label ?? null;
+        if (params && typeof params === "object" && "cbLabel" in params) {
+          const { cbLabel: _l, ...rest } = params;
+          fwd = rest;
+        }
+      } catch { /* instrumentação nunca altera a chamada do cliente */ }
+      return { label, fwd };
+    };
+
+    const buildEvent = (model, usage, { label, start, streaming, endpoint }) => {
+      const priced = priceGemini(model, usage || {});
+      return {
+        provider:       "gemini",
+        model,
+        product:        product || null,
+        team:           team    || null,
+        label,
+        inputTokens:    priced.inputTokens,
+        outputTokens:   priced.outputTokens,
+        totalTokens:    priced.totalTokens,
+        costUSD:        priced.costUSD,
+        // Só o Gemini separa esses dois, e são justamente os que mais mexem no
+        // valor: cache barateia ~10x, thinking é cobrado como output.
+        cachedTokens:   priced.cachedTokens,
+        thoughtsTokens: priced.thoughtsTokens,
+        unpriced:       priced.unpriced,
+        pricingNote:    priced.reason,
+        latencyMs:      Date.now() - start,
+        endpoint,
+        streaming:      !!streaming,
+      };
+    };
+
+    // ── generateContent (não-streaming) ───────────────────────────────────────
+    const originalGenerate = models.generateContent.bind(models);
+    models.generateContent = async (params, options) => {
+      const start = Date.now();
+      const { label, fwd } = splitLabel(params, options);
+
+      const res = await originalGenerate(fwd);
+
+      try {
+        const model = res?.modelVersion || params?.model || "unknown";
+        cb.track(buildEvent(model, res?.usageMetadata, {
+          label, start, streaming: false, endpoint: "models.generateContent",
+        }));
+      } catch (err) {
+        if (debug) console.warn("[CloudBroker] track error:", err.message);
+      }
+
+      return res;
+    };
+
+    // ── generateContentStream ────────────────────────────────────────────────
+    if (typeof models.generateContentStream === "function") {
+      const originalStream = models.generateContentStream.bind(models);
+      models.generateContentStream = async (params, options) => {
+        const start = Date.now();
+        const { label, fwd } = splitLabel(params, options);
+
+        const stream = await originalStream(fwd);
+
+        let model = params?.model || "unknown";
+        let usage = null;
+        const onChunk = (chunk) => {
+          if (chunk?.modelVersion) model = chunk.modelVersion;
+          // O usage do Gemini é cumulativo e chega no(s) chunk(s) final(is):
+          // o último que vier é o total da chamada.
+          if (chunk?.usageMetadata) usage = chunk.usageMetadata;
+        };
+        const onDone = () => {
+          try {
+            cb.track(buildEvent(model, usage, {
+              label, start, streaming: true, endpoint: "models.generateContentStream",
+            }));
+          } catch (err) {
+            if (debug) console.warn("[CloudBroker] track error:", err.message);
+          }
+        };
+
+        return CloudBrokerAI.#instrumentStream(stream, onChunk, onDone);
+      };
+    }
+
+    return client;
+  }
+
   /**
    * Registra um deploy para análise de custo
    * Atalho para CloudBrokerClient.trackDeploy() sem precisar envolver um cliente de IA