cloudbroker-sdk 0.8.0 → 0.8.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cloudbroker-sdk",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "description": "CloudBroker SDK — Token Intelligence & Operational Financial Intelligence",
   "repository": {
     "type": "git",

package/src/client.js

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

package/src/pricing.js

@@ -1,7 +1,7 @@
 /**
  * Tabela de preços por provider/modelo
  * Preços em USD por token
- * Atualizado: Mai/2026
+ * Atualizado: Mai/2026 (Anthropic conferida em Out/2026)
  */
 export const PRICING = {
   openai: {
@@ -16,10 +16,13 @@ export const PRICING = {
     "text-embedding-3-large":   { input: 0.00000013,  output: 0          },
   },
   anthropic: {
-    "claude-opus-4-6":          { input: 0.000015,    output: 0.000075   },
+    // Conferidos em 2026-10-12 contra a tabela oficial da Anthropic. Até essa
+    // data o Haiku 4.5 estava com o preço do Haiku 3 (4x abaixo do real) e o
+    // Opus 4.6 com o do Opus 4/4.1 (3x acima).
+    "claude-opus-4-6":          { input: 0.000005,    output: 0.000025   },
     "claude-sonnet-4-6":        { input: 0.000003,    output: 0.000015   },
     "claude-sonnet-4-5":        { input: 0.000003,    output: 0.000015   },
-    "claude-haiku-4-5-20251001":{ input: 0.00000025,  output: 0.00000125 },
+    "claude-haiku-4-5-20251001":{ input: 0.000001,    output: 0.000005   },
     "claude-3-opus-20240229":   { input: 0.000015,    output: 0.000075   },
     "claude-3-sonnet-20240229": { input: 0.000003,    output: 0.000015   },
     "claude-3-haiku-20240307":  { input: 0.00000025,  output: 0.00000125 },
@@ -188,3 +191,83 @@ export function priceGemini(model, usage = {}) {
       : null,
   };
 }
+
+// ── Anthropic ────────────────────────────────────────────────────────────────
+
+/**
+ * Prompt caching da Anthropic: gravação no cache custa um múltiplo do preço de
+ * ENTRADA (1,25x com validade de 5 min, 2x com 1 h) e leitura, 0,1x. Os tokens
+ * de cache NÃO aparecem em `usage.input_tokens` — vêm em campos próprios.
+ * Calcular só sobre `input_tokens` subconta o custo assim que o cache é ligado.
+ */
+export const ANTHROPIC_CACHE_MULTIPLIERS = Object.freeze({ write5m: 1.25, write1h: 2, read: 0.1 });
+
+// Snapshot datado da Anthropic: `claude-haiku-4-5-20251001`.
+const ANTHROPIC_VERSION_SUFFIX = /-\d{8}$/;
+
+const nonNeg = (v) => (Number.isFinite(Number(v)) && Number(v) > 0 ? Number(v) : 0);
+
+/**
+ * Custo de uma chamada da Messages API da Anthropic a partir do `usage`.
+ *
+ * Modelo fora da tabela sai com `costUSD: null` + `unpriced: true` — nunca o
+ * preço de outro modelo (antes caía no do Sonnet 4.6, o que superfaturava um
+ * Haiku em 3x e subfaturava um Opus). Snapshot com sufixo de data não listado
+ * usa o preço do modelo-base, declarado em `approxPricing`.
+ *
+ * `inputTokens` é o total de entrada processada (sem cache + gravado + lido),
+ * mesma semântica do Gemini (`promptTokenCount` já inclui o cache). A parte de
+ * cache vai também separada em `cacheWriteTokens`/`cacheReadTokens`.
+ */
+export function priceAnthropic(model, usage = {}) {
+  const u = usage || {};
+  const plain  = nonNeg(u.input_tokens);
+  const output = nonNeg(u.output_tokens);
+  const read   = nonNeg(u.cache_read_input_tokens);
+  const br = u.cache_creation;
+  let write5m, write1h;
+  if (br && typeof br === "object" && ("ephemeral_5m_input_tokens" in br || "ephemeral_1h_input_tokens" in br)) {
+    write5m = nonNeg(br.ephemeral_5m_input_tokens);
+    write1h = nonNeg(br.ephemeral_1h_input_tokens);
+  } else {
+    write5m = nonNeg(u.cache_creation_input_tokens);
+    write1h = 0;
+  }
+  const inputTokens = plain + write5m + write1h + read;
+  const base = {
+    inputTokens,
+    outputTokens:     output,
+    totalTokens:      inputTokens + output,
+    cacheWriteTokens: write5m + write1h,
+    cacheReadTokens:  read,
+  };
+
+  const table = PRICING.anthropic;
+  const name = typeof model === "string" ? model : "";
+  let id = null, approx = false;
+  if (name && Object.hasOwn(table, name)) {
+    id = name;
+  } else {
+    const b = name.replace(ANTHROPIC_VERSION_SUFFIX, "");
+    if (b !== name && Object.hasOwn(table, b)) { id = b; approx = true; }
+  }
+  if (!id) {
+    return {
+      ...base, costUSD: null, pricedAs: null, approxPricing: false, unpriced: true,
+      reason: `Modelo "${name.slice(0, 60) || "desconhecido"}" não está na tabela de preço da Anthropic — tokens registrados, custo não estimado.`,
+    };
+  }
+  const r = table[id];
+  const m = ANTHROPIC_CACHE_MULTIPLIERS;
+  const costUSD = plain * r.input
+    + (write5m * m.write5m + write1h * m.write1h + read * m.read) * r.input
+    + output * r.output;
+  return {
+    ...base,
+    costUSD:       parseFloat(costUSD.toFixed(8)),
+    pricedAs:      id,
+    approxPricing: approx,
+    unpriced:      false,
+    reason:        approx ? `Preço do modelo base "${id}" aplicado a "${name.slice(0, 60)}" — snapshot não listado na tabela.` : null,
+  };
+}

package/src/test.js

@@ -489,5 +489,75 @@ 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");
+// 10) Anthropic: preço conferido (2026-10-12), tokens de cache e modelo
+// desconhecido sem preço fabricado.
+{
+  const { priceAnthropic, PRICING: P } = await import("./pricing.js");
+  assert.strictEqual(P.anthropic["claude-haiku-4-5-20251001"].input, 0.000001, "Haiku 4.5 entrada = US$ 1/M (não o preço do Haiku 3)");
+  assert.strictEqual(P.anthropic["claude-haiku-4-5-20251001"].output, 0.000005, "Haiku 4.5 saída = US$ 5/M");
+  assert.strictEqual(P.anthropic["claude-opus-4-6"].input, 0.000005, "Opus 4.6 entrada = US$ 5/M");
+  assert.strictEqual(P.anthropic["claude-opus-4-6"].output, 0.000025, "Opus 4.6 saída = US$ 25/M");
+
+  const h = priceAnthropic("claude-haiku-4-5-20251001", { input_tokens: 1_000_000, output_tokens: 1_000_000 });
+  assert.ok(Math.abs(h.costUSD - 6) < 1e-9, `1M+1M no Haiku 4.5 = US$ 6, veio ${h.costUSD}`);
+
+  const c = priceAnthropic("claude-haiku-4-5-20251001", {
+    input_tokens: 1000, output_tokens: 100, cache_creation_input_tokens: 10000, cache_read_input_tokens: 20000,
+  });
+  const esperado = 1000 * 1e-6 + 100 * 5e-6 + 10000 * 1e-6 * 1.25 + 20000 * 1e-6 * 0.1;
+  assert.ok(Math.abs(c.costUSD - esperado) < 1e-9, `gravação 1,25x e leitura 0,1x, esperado ${esperado}, veio ${c.costUSD}`);
+  assert.strictEqual(c.inputTokens, 31000, "inputTokens = sem cache + gravado + lido");
+  assert.strictEqual(c.cacheWriteTokens, 10000);
+  assert.strictEqual(c.cacheReadTokens, 20000);
+
+  const h1 = priceAnthropic("claude-haiku-4-5-20251001", {
+    cache_creation_input_tokens: 1000, cache_creation: { ephemeral_5m_input_tokens: 0, ephemeral_1h_input_tokens: 1000 },
+  });
+  assert.ok(Math.abs(h1.costUSD - 1000 * 1e-6 * 2) < 1e-12, "gravação com validade de 1 h custa 2x");
+
+  const d = priceAnthropic("claude-modelo-inventado", { input_tokens: 10, output_tokens: 10 });
+  assert.strictEqual(d.costUSD, null, "modelo desconhecido não recebe o preço de outro modelo");
+  assert.strictEqual(d.unpriced, true);
+  assert.strictEqual(d.totalTokens, 20, "tokens registrados mesmo sem preço");
+
+  const a = priceAnthropic("claude-sonnet-4-6-20991231", { input_tokens: 1000 });
+  assert.ok(a.approxPricing === true && a.pricedAs === "claude-sonnet-4-6", "snapshot datado não listado usa o modelo-base, declarado");
+
+  for (const nome of ["constructor", "__proto__", "toString", "hasOwnProperty"]) {
+    const v = priceAnthropic(nome, { input_tokens: 10 });
+    assert.strictEqual(v.costUSD, null, `nome venenoso "${nome}" não vira tabela de preço`);
+  }
+  const lixo = priceAnthropic("claude-haiku-4-5-20251001", { input_tokens: -5, output_tokens: "x", cache_read_input_tokens: NaN });
+  assert.strictEqual(lixo.costUSD, 0, "valor negativo ou não numérico conta como 0, nunca NaN");
+  assert.strictEqual(priceAnthropic(undefined, undefined).costUSD, null, "sem modelo e sem usage não lança");
+  console.log("✅ priceAnthropic: preço conferido, cache 1,25x/2x/0,1x, desconhecido = null");
+
+  // wrap: o evento enviado leva o custo com cache e o sinal de sem preço
+  const capt = [];
+  globalThis.fetch = async (url, opts) => {
+    if (String(url).includes("/api/ai/events")) capt.push(...JSON.parse(opts.body).events);
+    return { ok: true, status: 200, json: async () => ({}) };
+  };
+  const mockAnthropic = {
+    messages: {
+      create: async (params) => ({
+        model: params.model, content: [],
+        usage: { input_tokens: 1000, output_tokens: 100, cache_creation_input_tokens: 10000, cache_read_input_tokens: 20000 },
+      }),
+    },
+  };
+  const wa = CloudBrokerAI.wrap(mockAnthropic, { apiKey: "cb-test-key", product: "FinOps Advisor" });
+  await wa.messages.create({ model: "claude-haiku-4-5-20251001", max_tokens: 10, messages: [] }, { cbLabel: "finops-advisor:agent" });
+  await wa.messages.create({ model: "claude-modelo-inventado", max_tokens: 10, messages: [] });
+  await new Promise((r) => setTimeout(r, 50));
+  assert.strictEqual(capt.length, 2, `esperado 2 eventos de IA, veio ${capt.length}`);
+  assert.ok(Math.abs(capt[0].costUSD - esperado) < 1e-9, `evento leva o custo com cache, veio ${capt[0].costUSD}`);
+  assert.strictEqual(capt[0].cacheReadTokens, 20000);
+  assert.strictEqual(capt[0].label, "finops-advisor:agent");
+  assert.strictEqual(capt[1].costUSD, null, "evento de modelo desconhecido sai com costUSD null");
+  assert.strictEqual(capt[1].unpriced, true);
+  console.log("✅ CloudBrokerAI.wrap (Anthropic): custo com cache no evento, desconhecido = null");
+}
+
 globalThis.fetch = realFetch;
 console.log("\n🎉 Todos os testes passaram.");

package/src/wrapper.js

@@ -4,9 +4,37 @@
  */
 
 import { CloudBrokerClient } from "./client.js";
-import { PRICING, priceGemini } from "./pricing.js";
+import { PRICING, priceGemini, priceAnthropic } from "./pricing.js";
 import { cbStore } from "./context.js";
 
+/**
+ * Evento de uma chamada da Anthropic. O preço vem de `priceAnthropic`: inclui
+ * os tokens de cache e devolve `costUSD: null` + `unpriced` para modelo fora
+ * da tabela (nunca o preço de outro modelo).
+ */
+function anthropicEvent(model, usage, { product, team, label, start, latencyMs, streaming }) {
+  const p = priceAnthropic(model, usage || {});
+  const ev = {
+    provider:         "anthropic",
+    model,
+    product:          product || null,
+    team:             team    || null,
+    label,
+    inputTokens:      p.inputTokens,
+    outputTokens:     p.outputTokens,
+    totalTokens:      p.totalTokens,
+    costUSD:          p.costUSD,
+    cacheWriteTokens: p.cacheWriteTokens,
+    cacheReadTokens:  p.cacheReadTokens,
+    unpriced:         p.unpriced,
+    pricingNote:      p.reason,
+    latencyMs:        latencyMs ?? (Date.now() - start),
+    endpoint:         "messages",
+  };
+  if (streaming) ev.streaming = true;
+  return ev;
+}
+
 export class CloudBrokerAI {
   /**
    * Envolve um cliente OpenAI ou Anthropic
@@ -189,35 +217,20 @@ export class CloudBrokerAI {
         const stream = await originalCreate(params, fwdOptions);
 
         let model = params.model || "unknown";
-        let inputTokens = 0, outputTokens = 0;
+        // usage de entrada (incl. tokens de cache) vem no message_start;
+        // message_delta traz o total acumulado de output_tokens.
+        let usage = {};
         const onChunk = (event) => {
           if (event?.type === "message_start" && event.message) {
-            model        = event.message.model || model;
-            inputTokens  = event.message.usage?.input_tokens  || inputTokens;
-            outputTokens = event.message.usage?.output_tokens || outputTokens;
+            model = event.message.model || model;
+            if (event.message.usage) usage = { ...event.message.usage };
           } else if (event?.type === "message_delta" && event.usage) {
-            // message_delta traz o total acumulado de output_tokens
-            outputTokens = event.usage.output_tokens || outputTokens;
+            if (event.usage.output_tokens != null) usage.output_tokens = event.usage.output_tokens;
           }
         };
         const onDone = () => {
           try {
-            const pricing = PRICING.anthropic[model] || PRICING.anthropic["claude-sonnet-4-6"];
-            const costUSD = (inputTokens * pricing.input) + (outputTokens * pricing.output);
-            cb.track({
-              provider:    "anthropic",
-              model,
-              product:     product || null,
-              team:        team    || null,
-              label:       cbLabel,
-              inputTokens,
-              outputTokens,
-              totalTokens: inputTokens + outputTokens,
-              costUSD:     parseFloat(costUSD.toFixed(6)),
-              latencyMs:   Date.now() - start,
-              endpoint:    "messages",
-              streaming:   true,
-            });
+            cb.track(anthropicEvent(model, usage, { product, team, label: cbLabel, start, streaming: true }));
           } catch (err) {
             if (debug) console.warn("[CloudBroker] track error:", err.message);
           }
@@ -231,25 +244,8 @@ export class CloudBrokerAI {
       const ms  = Date.now() - start;
 
       try {
-        const model        = res.model || params.model || "unknown";
-        const inputTokens  = res.usage?.input_tokens  || 0;
-        const outputTokens = res.usage?.output_tokens || 0;
-        const pricing      = PRICING.anthropic[model] || PRICING.anthropic["claude-sonnet-4-6"];
-        const costUSD      = (inputTokens * pricing.input) + (outputTokens * pricing.output);
-
-        cb.track({
-          provider:      "anthropic",
-          model,
-          product:       product || null,
-          team:          team    || null,
-          label:         cbLabel,
-          inputTokens,
-          outputTokens,
-          totalTokens:   inputTokens + outputTokens,
-          costUSD:       parseFloat(costUSD.toFixed(6)),
-          latencyMs:     ms,
-          endpoint:      "messages",
-        });
+        const model = res.model || params.model || "unknown";
+        cb.track(anthropicEvent(model, res.usage, { product, team, label: cbLabel, start, latencyMs: ms }));
       } catch (err) {
         if (debug) console.warn("[CloudBroker] track error:", err.message);
       }