cloudbroker-sdk 0.5.0 → 0.7.0

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/test.js

@@ -225,5 +225,269 @@ await new Promise((r) => setTimeout(r, 50));
 assert.strictEqual(capturedAi[1].events[0].label, "finops-advisor:root-cause-agent");
 console.log("✅ CloudBrokerAI.wrap: label via contexto cbStore (sem cbLabel explícito)");
 
+// ─── AZURE (wrapAzure — Blob Storage + Cosmos DB) ──────────────────────────────
+console.log("\n☁️  Testando wrapAzure (Blob + Cosmos)...");
+
+// 5) Tabela de preços Azure
+const blobW = estimateCloudCost({ provider: "azure", service: "blob", operation: "uploadData", requests: 1 });
+assert.strictEqual(blobW.billingUnit, "blob-write");
+assert.ok(Math.abs(blobW.costUSD - 0.055 / 10_000) < 1e-12, `blob write veio ${blobW.costUSD}`);
+
+const blobR = estimateCloudCost({ provider: "azure", service: "blob", operation: "download", requests: 1, bytesOut: 1024 * 1024 * 1024 });
+assert.strictEqual(blobR.billingUnit, "blob-read");
+assert.ok(Math.abs(blobR.costUSD - (0.0044 / 10_000 + 0.087)) < 1e-9, `blob read+transfer veio ${blobR.costUSD}`);
+
+const blobDel = estimateCloudCost({ provider: "azure", service: "blob", operation: "delete", requests: 1 });
+assert.strictEqual(blobDel.billingUnit, "blob-free");
+assert.strictEqual(blobDel.costUSD, 0);
+
+const blobList = estimateCloudCost({ provider: "azure", service: "blob", operation: "listBlobsFlat", requests: 1 });
+assert.strictEqual(blobList.billingUnit, "blob-list");
+
+const cosmosReal = estimateCloudCost({ provider: "azure", service: "cosmosdb", operation: "items.create", requestCharge: 7.43 });
+assert.strictEqual(cosmosReal.billingUnit, "cosmos-ru");
+assert.ok(Math.abs(cosmosReal.costUSD - 7.43 * 0.25 / 1_000_000) < 1e-15, `cosmos RU real veio ${cosmosReal.costUSD}`);
+
+const cosmosEst = estimateCloudCost({ provider: "azure", service: "cosmosdb", operation: "items.create" });
+assert.strictEqual(cosmosEst.billingUnit, "cosmos-ru-est");
+assert.ok(Math.abs(cosmosEst.costUSD - 5 * 0.25 / 1_000_000) < 1e-15, `cosmos RU fallback veio ${cosmosEst.costUSD}`);
+console.log("✅ estimateCloudCost azure: blob write/read+transfer/delete-free/list, cosmos RU real/fallback");
+
+// 5b) Região sem tabela de preço NÃO pode ser precificada como eastus2 — um app
+// em brazilsouth receberia o custo de outra região apresentado como o dele.
+const brs = estimateCloudCost({ provider: "azure", service: "blob", operation: "uploadData", region: "brazilsouth" });
+assert.strictEqual(brs.costUSD, null, `região sem preço deve dar custo null, veio ${brs.costUSD}`);
+assert.strictEqual(brs.billingUnit, "blob-region-unpriced");
+console.log("✅ região Azure sem tabela: custo null + unidade explícita (não finge eastus2)");
+
+// 6) Blob — cadeia de fábricas, cbLabel não vaza, bytes medidos do argumento certo
+captured.length = 0;
+globalThis.fetch = async (url, opts) => {
+  if (String(url).includes("/api/cloud/events")) captured.push(JSON.parse(opts.body));
+  return { ok: true, status: 200, json: async () => ({}) };
+};
+
+let sawBlobOptions, sawUploadArgs;
+class BlockBlobClient {
+  async uploadData(data, options) { sawBlobOptions = options; return { etag: "0x1" }; }
+  async download() { return { contentLength: 4096 }; }
+  // getProperties devolve o TAMANHO DO BLOB, mas não transfere o blob.
+  async getProperties() { return { contentLength: 5 * 1024 * 1024 * 1024 }; }
+  async uploadBlockBlob(...args) { sawUploadArgs = args; return { etag: "0x2" }; }
+  async setMetadata(meta, options) { return { meta, options }; }
+}
+class ContainerClient {
+  getBlockBlobClient(_name) { return new BlockBlobClient(); }
+  listBlobsFlat() {
+    let i = 0;
+    return { async next() { return i++ < 2 ? { done: false, value: { name: `b${i}` } } : { done: true }; },
+             [Symbol.asyncIterator]() { return this; } };
+  }
+  async uploadBlockBlob(...args) { sawUploadArgs = args; return { etag: "0x2" }; }
+}
+class BlobServiceClient {
+  getContainerClient(_name) { return new ContainerClient(); }
+}
+
+const blobSvc = CloudBrokerCloud.wrapAzure(new BlobServiceClient(), {
+  apiKey: "cb-test-key", product: "checkout", team: "mobile", debug: true,
+});
+const blockBlob = blobSvc.getContainerClient("docs").getBlockBlobClient("nf.pdf");
+const upRes = await blockBlob.uploadData(Buffer.from("hello azure"), { cbLabel: "upload-nf-azure" });
+assert.strictEqual(upRes.etag, "0x1", "resultado original deve ser preservado");
+// O argumento NUNCA é removido: setMetadata() sem argumento apaga os metadados
+// do blob. O options segue existindo, só sem as chaves cb*.
+assert.deepStrictEqual(sawBlobOptions, {}, "options deve chegar sem cb*, mas deve chegar");
+
+const dlRes = await blockBlob.download();
+assert.strictEqual(dlRes.contentLength, 4096);
+
+await new Promise(r => setTimeout(r, 50));
+const azEvents = captured.flatMap(c => c.events);
+assert.strictEqual(azEvents.length, 2, `esperado 2 eventos (upload+download), veio ${azEvents.length}`);
+const [evUp, evDl] = azEvents;
+assert.strictEqual(evUp.provider, "azure");
+assert.strictEqual(evUp.service, "blob");
+assert.strictEqual(evUp.operation, "uploadData");
+assert.strictEqual(evUp.label, "upload-nf-azure");
+assert.strictEqual(evUp.product, "checkout");
+assert.strictEqual(evUp.bytesIn, Buffer.byteLength("hello azure"));
+assert.strictEqual(evUp.billingUnit, "blob-write");
+assert.strictEqual(evDl.operation, "download");
+assert.strictEqual(evDl.bytesOut, 4096);
+assert.strictEqual(evDl.billingUnit, "blob-read");
+console.log("✅ wrapAzure blob: cadeia de fábricas, cb* sem vazar, options preservado, bytes in/out");
+
+// 6b) getProperties NÃO pode cobrar egress do tamanho do blob (custo inflado)
+captured.length = 0;
+await blockBlob.getProperties();
+await new Promise(r => setTimeout(r, 50));
+const evProps = captured.flatMap(c => c.events)[0];
+assert.strictEqual(evProps.operation, "getProperties");
+assert.strictEqual(evProps.bytesOut, 0, `getProperties não transfere o blob; bytesOut veio ${evProps.bytesOut}`);
+assert.ok(evProps.costUSD < 1e-6, `custo de metadado deve ser desprezível, veio ${evProps.costUSD}`);
+console.log("✅ getProperties: sem egress do tamanho do blob (custo de metadado, não de 5 GB)");
+
+// 6c) bytesIn vem do argumento de CORPO declarado, não da primeira string
+// (em uploadBlockBlob a primeira string é o NOME do blob)
+captured.length = 0;
+await blobSvc.getContainerClient("docs").uploadBlockBlob("relatorio-financeiro-2026-07.pdf", Buffer.alloc(10 * 1024 * 1024), 10 * 1024 * 1024);
+await new Promise(r => setTimeout(r, 50));
+const evBlockUp = captured.flatMap(c => c.events)[0];
+assert.strictEqual(evBlockUp.bytesIn, 10 * 1024 * 1024, `bytesIn deve ser o corpo (10MB), veio ${evBlockUp.bytesIn}`);
+console.log("✅ bytesIn: medido do argumento de corpo, não do nome do blob");
+
+// 6d) list é LAZY — nenhum HTTP na criação do iterator. Evento só quando a
+// página é de fato buscada (senão emitia custo de operação que nunca ocorreu).
+captured.length = 0;
+const neverUsed = blobSvc.getContainerClient("docs").listBlobsFlat();
+await new Promise(r => setTimeout(r, 50));
+assert.strictEqual(captured.length, 0, "iterator criado e não consumido não pode gerar custo");
+for await (const _b of neverUsed) { /* consome */ }
+await new Promise(r => setTimeout(r, 50));
+const listEvents = captured.flatMap(c => c.events);
+assert.ok(listEvents.length >= 1, "consumir o iterator deve gerar evento de list");
+assert.strictEqual(listEvents[0].billingUnit, "blob-list");
+console.log("✅ list: sem custo fabricado — evento só quando a página é buscada");
+
+// 7) Cosmos — requestCharge REAL vira custo; iterator de query rastreado
+captured.length = 0;
+let sawCreateArgs;
+class Item {
+  async read() { return { requestCharge: 1.0, resource: { id: "x" } }; }
+}
+class Container {
+  constructor() {
+    this.items = {
+      create: async (...args) => { sawCreateArgs = args; return { requestCharge: 7.43, resource: { id: "y" } }; },
+      query:  (_q) => ({ fetchAll: async () => ({ requestCharge: 3.2, resources: [] }) }),
+      bulk:   async (_ops) => ([{ requestCharge: 5 }, { requestCharge: 6 }]),
+    };
+  }
+  item(_id, _pk) { return new Item(); }
+  // control-plane: lê a definição do CONTAINER, não de um item
+  async read() { return { requestCharge: 2.0, resource: { id: "orders" } }; }
+}
+class Database {
+  container(_id) { return new Container(); }
+  async read() { return { requestCharge: 1.5, resource: { id: "db" } }; }
+}
+class CosmosClient { database(_id) { return new Database(); } }
+
+const cosmos = CloudBrokerCloud.wrapAzure(new CosmosClient(), {
+  apiKey: "cb-test-key", product: "checkout", team: "mobile",
+});
+const cont = cosmos.database("db").container("orders");
+const createRes = await cont.items.create({ id: "y" }, { cbLabel: "criar-pedido" });
+assert.strictEqual(createRes.resource.id, "y");
+await cont.item("x", "pk").read();
+await cont.items.query("SELECT * FROM c").fetchAll();
+
+await new Promise(r => setTimeout(r, 50));
+const cosmosEvents = captured.flatMap(c => c.events);
+assert.strictEqual(cosmosEvents.length, 3, `esperado 3 eventos cosmos, veio ${cosmosEvents.length}`);
+const [evCreate, evRead, evQuery] = cosmosEvents;
+assert.strictEqual(evCreate.service, "cosmosdb");
+assert.strictEqual(evCreate.operation, "items.create");
+assert.strictEqual(evCreate.label, "criar-pedido");
+assert.strictEqual(evCreate.billingUnit, "cosmos-ru");
+assert.ok(Math.abs(evCreate.costUSD - 7.43 * 0.25 / 1_000_000) < 1e-15, `custo RU real veio ${evCreate.costUSD}`);
+assert.strictEqual(evRead.operation, "item.read");
+assert.strictEqual(evQuery.operation, "items.query.fetchAll");
+assert.ok(Math.abs(evQuery.costUSD - 3.2 * 0.25 / 1_000_000) < 1e-15, `custo do query veio ${evQuery.costUSD}`);
+console.log("✅ wrapAzure cosmos: requestCharge real → custo, item.read, query iterator");
+
+// 7b) O DOCUMENTO do cliente nunca é inspecionado nem alterado — um campo
+// chamado cbLabel no corpo tem que ser gravado como veio.
+captured.length = 0;
+const docComCampoColidindo = { id: "z", cbLabel: "campo-de-negocio-do-cliente", valor: 10 };
+await cont.items.create(docComCampoColidindo);
+assert.deepStrictEqual(
+  sawCreateArgs[0],
+  { id: "z", cbLabel: "campo-de-negocio-do-cliente", valor: 10 },
+  "documento do cliente não pode perder campo por colisão de nome",
+);
+await new Promise(r => setTimeout(r, 50));
+assert.strictEqual(captured.flatMap(c => c.events)[0].label, null, "campo do corpo não vira label");
+console.log("✅ documento do cliente intacto: cb* no corpo não é lido nem removido");
+
+// 7c) Container.read()/Database.read() são control-plane — não podem sair
+// rotulados como item.read (operação errada na tela de custo por trecho).
+captured.length = 0;
+await cont.read();
+await cosmos.database("db").read();
+await new Promise(r => setTimeout(r, 50));
+const cpEvents = captured.flatMap(c => c.events);
+assert.strictEqual(cpEvents[0].operation, "container.read", `veio ${cpEvents[0].operation}`);
+assert.strictEqual(cpEvents[1].operation, "database.read", `veio ${cpEvents[1].operation}`);
+console.log("✅ cosmos: container.read/database.read não são confundidos com item.read");
+
+// 7d) bulk soma o requestCharge de cada operação (senão 1000 escritas = 1 leitura)
+captured.length = 0;
+await cont.items.bulk([{ operationType: "Create" }, { operationType: "Create" }]);
+await new Promise(r => setTimeout(r, 50));
+const evBulk = captured.flatMap(c => c.events)[0];
+assert.strictEqual(evBulk.operation, "items.bulk");
+assert.strictEqual(evBulk.billingUnit, "cosmos-ru", "bulk deve usar RU medida, não estimativa");
+assert.ok(Math.abs(evBulk.costUSD - 11 * 0.25 / 1_000_000) < 1e-15, `bulk deve somar 5+6 RU, veio ${evBulk.costUSD}`);
+console.log("✅ cosmos bulk: RUs somadas por operação");
+
+// 8) Robustez — a instrumentação NUNCA pode quebrar a aplicação do cliente.
+// Este é o requisito mais importante: o SDK roda dentro da produção dele.
+captured.length = 0;
+class BlobQuebrado {
+  async uploadData() {
+    // Resposta com propriedade lazy que lança ao ser lida (padrão em SDKs
+    // de streaming). A operação JÁ ACONTECEU no Azure quando isso é lido.
+    return { etag: "ok", get contentLength() { throw new Error("propriedade lazy do SDK lançou"); } };
+  }
+}
+class ContainerQuebrado { getBlockBlobClient() { return new BlobQuebrado(); } }
+class BlobServiceClient2 { getContainerClient() { return new ContainerQuebrado(); } }
+Object.defineProperty(BlobServiceClient2, "name", { value: "BlobServiceClient" });
+Object.defineProperty(ContainerQuebrado, "name", { value: "ContainerClient" });
+Object.defineProperty(BlobQuebrado, "name", { value: "BlockBlobClient" });
+
+const svcQuebrado = CloudBrokerCloud.wrapAzure(new BlobServiceClient2(), { apiKey: "cb-test-key" });
+const r8 = await svcQuebrado.getContainerClient("c").getBlockBlobClient("b").uploadData(Buffer.from("x"));
+assert.strictEqual(r8.etag, "ok", "erro na instrumentação não pode virar erro da aplicação do cliente");
+console.log("✅ robustez: exceção na leitura do resultado não vaza pro app do cliente");
+
+// options com getter que lança, ANTES da chamada real
+class BlobGetterRuim {
+  async uploadData(_d, _o) { return { etag: "ok2" }; }
+}
+Object.defineProperty(BlobGetterRuim, "name", { value: "BlockBlobClient" });
+const bad = CloudBrokerCloud.wrapAzure(new BlobGetterRuim(), { apiKey: "cb-test-key" });
+const optsRuim = Object.defineProperty({}, "cbLabel", { get() { throw new Error("getter ruim"); }, enumerable: true });
+const r8b = await bad.uploadData(Buffer.from("x"), optsRuim);
+assert.strictEqual(r8b.etag, "ok2", "erro ao extrair label não pode impedir a operação real");
+console.log("✅ robustez: falha na extração de label não impede a chamada Azure");
+
+// 8b) Client congelado pelo cliente: a atribuição in-place lançaria (strict
+// mode). Instrumentação nunca pode derrubar a app — avisa e devolve original.
+class BlobCongelado { async uploadData() { return { etag: "frozen-ok" }; } }
+Object.defineProperty(BlobCongelado, "name", { value: "BlockBlobClient" });
+const congelado = Object.freeze(new BlobCongelado());
+const warnsFrozen = [];
+const warnFrozenOrig = console.warn;
+console.warn = (...a) => warnsFrozen.push(a.join(" "));
+const wrappedFrozen = CloudBrokerCloud.wrapAzure(congelado, { apiKey: "cb-test-key" });
+console.warn = warnFrozenOrig;
+const rFrozen = await wrappedFrozen.uploadData(Buffer.from("x"));
+assert.strictEqual(rFrozen.etag, "frozen-ok", "client congelado deve seguir funcionando");
+assert.ok(warnsFrozen.some(w => w.includes("congelado")), "deve avisar que não vai rastrear");
+console.log("✅ robustez: client congelado não quebra a aplicação (avisa e não rastreia)");
+
+// 9) Client não reconhecido → retorna original intocado (e avisa alto)
+class MinhaClasseQualquer { async foo() { return 42; } }
+const warns = [];
+const origWarn = console.warn;
+console.warn = (...a) => warns.push(a.join(" "));
+const untouched = CloudBrokerCloud.wrapAzure(new MinhaClasseQualquer(), { apiKey: "cb-test-key" });
+console.warn = origWarn;
+assert.strictEqual(await untouched.foo(), 42);
+assert.ok(warns.some(w => w.includes("não reconhecido")), "deve avisar mesmo sem debug:true");
+console.log("✅ wrapAzure: client não reconhecido passa intocado, com aviso incondicional");
 globalThis.fetch = realFetch;
 console.log("\n🎉 Todos os testes passaram.");