feat(llm): cost telemetry + per-user daily token budget [STORY-012]

packages/llm/src/anthropic.test.ts

@@ -7,6 +7,7 @@ import {
 } from "./anthropic.js";
 import { InMemoryLLMTelemetrySink } from "./telemetry.js";
 import { ANTHROPIC_HAIKU, ANTHROPIC_OPUS } from "./models.js";
+import { PRICING_VERSION } from "./pricing.js";
 import { LLMRequestError, NotImplementedError } from "./errors.js";
 
 class FakeTransport implements AnthropicTransport {
@@ -148,14 +149,15 @@ describe("AnthropicProvider.complete", () => {
     ).rejects.toBeInstanceOf(LLMRequestError);
   });
 
-  it("emits telemetry on success including role and prompt_version", async () => {
+  it("emits telemetry on success including role, prompt_version, and cost", async () => {
     const sink = new InMemoryLLMTelemetrySink();
     const transport = new FakeTransport(baseResponse);
     const provider = new AnthropicProvider({ transport, telemetry: sink });
     await provider.complete({
       messages: [{ role: "user", content: "hi" }],
       role: "tutor",
       user_id: "u1",
+      session_id: "sess-42",
       prompt_version: "tutor@v3",
       max_tokens: 16,
       temperature: 0,
@@ -166,9 +168,28 @@ describe("AnthropicProvider.complete", () => {
     expect(ev.role).toBe("tutor");
     expect(ev.prompt_version).toBe("tutor@v3");
     expect(ev.user_id).toBe("u1");
+    expect(ev.session_id).toBe("sess-42");
     expect(ev.input_tokens).toBe(11);
     expect(ev.output_tokens).toBe(7);
     expect(ev.ok).toBe(true);
+    // Haiku pricing: (11*1 + 7*5) / 1M = 0.000046
+    expect(ev.cost_usd).toBe(0.000046);
+    expect(ev.pricing_version).toBe(PRICING_VERSION);
+  });
+
+  it("emits cost=0 + known_model=false fallback for an unknown model", async () => {
+    const sink = new InMemoryLLMTelemetrySink();
+    const transport = new FakeTransport({ ...baseResponse, model: "made-up-model" });
+    const provider = new AnthropicProvider({ transport, telemetry: sink });
+    await provider.complete({
+      messages: [{ role: "user", content: "hi" }],
+      role: "tutor",
+      user_id: "u1",
+      max_tokens: 16,
+      temperature: 0,
+    });
+    expect(sink.events[0]?.cost_usd).toBe(0);
+    expect(sink.events[0]?.pricing_version).toBe(PRICING_VERSION);
   });
 });
 
@@ -226,6 +247,33 @@ describe("AnthropicProvider.toolCall", () => {
     expect(res.finish_reason).toBe("tool_use");
     expect(transport.lastParams?.tool_choice).toEqual({ type: "auto" });
   });
+
+  it("records tool_used in telemetry when a tool is invoked", async () => {
+    const sink = new InMemoryLLMTelemetrySink();
+    const transport = new FakeTransport({
+      model: ANTHROPIC_OPUS,
+      stop_reason: "tool_use",
+      usage: { input_tokens: 12, output_tokens: 4 },
+      content: [
+        {
+          type: "tool_use",
+          id: "tool_01",
+          name: "give-hint",
+          input: { rung: 1 },
+        },
+      ],
+    });
+    const provider = new AnthropicProvider({ transport, telemetry: sink });
+    await provider.toolCall({
+      messages: [{ role: "user", content: "stuck" }],
+      role: "tutor",
+      max_tokens: 64,
+      temperature: 0,
+      tools: [{ name: "give-hint", description: "x", input_schema: { type: "object" } }],
+      tool_choice: "auto",
+    });
+    expect(sink.events[0]?.tool_used).toBe("give-hint");
+  });
 });
 
 describe("AnthropicProvider.embed", () => {

packages/llm/src/anthropic.ts

@@ -1,6 +1,7 @@
 import { LLMRequestError, NotImplementedError } from "./errors.js";
 import type { LLMProvider } from "./provider.js";
 import { DEFAULT_ROLE_MODEL_MAP, resolveModel, type RoleModelMap } from "./models.js";
+import { costFor } from "./pricing.js";
 import { NullLLMTelemetrySink } from "./telemetry.js";
 import { DEFAULT_RETRY, withRetry, type RetryOptions } from "./retry.js";
 import {
@@ -219,6 +220,7 @@ export class AnthropicProvider implements LLMProvider {
         usage: out.usage,
         start,
         ok: true,
+        ...(tool_calls[0] !== undefined && { tool_used: tool_calls[0].name }),
       });
       return out;
     } catch (err) {
@@ -241,19 +243,29 @@ export class AnthropicProvider implements LLMProvider {
     usage: { input_tokens: number; output_tokens: number };
     start: number;
     ok: boolean;
+    tool_used?: string;
   }): void {
+    const cost = costFor({
+      model: opts.model,
+      input_tokens: opts.usage.input_tokens,
+      output_tokens: opts.usage.output_tokens,
+    });
     this.telemetry.record({
       provider: this.name,
       model: opts.model,
       task: opts.task,
       input_tokens: opts.usage.input_tokens,
       output_tokens: opts.usage.output_tokens,
+      cost_usd: cost.cost_usd,
+      pricing_version: cost.pricing_version,
       latency_ms: Math.max(0, this.now() - opts.start),
       ok: opts.ok,
       decided_at: new Date(this.now()).toISOString(),
       ...(opts.req.role !== undefined && { role: opts.req.role }),
       ...(opts.req.user_id !== undefined && { user_id: opts.req.user_id }),
+      ...(opts.req.session_id !== undefined && { session_id: opts.req.session_id }),
       ...(opts.req.prompt_version !== undefined && { prompt_version: opts.req.prompt_version }),
+      ...(opts.tool_used !== undefined && { tool_used: opts.tool_used }),
     });
   }
 }