@talkpilot/core-db 1.3.62 → 1.3.64

package/README.md

@@ -181,6 +181,7 @@ Refer to `DEVELOPMENT.md` for the full walkthrough, token instructions, and fact
 | 1.3.57  | Phone-number bind getters: list by client, exclusive flow assign, unbind, and `flow_id` match for ObjectId or leftover string. `getClientByClientId`. |
 | 1.3.61  | Optional `activeFlowId` on `WebsiteTalkProduct` (CP-1849). WebsiteTalk updates this flow instead of the flow on a phone number. |
 | 1.3.62  | Pause/Resume support for WebsiteTalk scans (CP-1752): `PAUSED` and `CANCELED` added to `SCAN_STATUSES` (`PAUSED` deliberately excluded from `FINISHED_SCAN_STATUSES` — pausing isn't done, `CANCELED` is). Added `Scan.pausedAt`, tracked across pause/resume so elapsed-time display can freeze correctly instead of counting the paused duration. |
+| 1.3.64  | New `callTokenUsage` collection with `incrementCallTokenUsage` (CP-1810): per-call realtime token usage, one document per `callSid`. |
 
 ### 1.1.9
 

package/dist/talkpilot/callTokenUsage/callTokenUsage.getters.d.ts

@@ -0,0 +1,4 @@
+import { CallTokenUsage, CallTokenUsageDoc } from "./callTokenUsage.types";
+export declare const getCallTokenUsageCollection: () => import("mongodb").Collection<CallTokenUsageDoc>;
+export declare const incrementCallTokenUsage: (callSid: string, { provider, model, ...counters }: CallTokenUsage) => Promise<void>;
+//# sourceMappingURL=callTokenUsage.getters.d.ts.map

package/dist/talkpilot/callTokenUsage/callTokenUsage.getters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"callTokenUsage.getters.d.ts","sourceRoot":"","sources":["../../../src/talkpilot/callTokenUsage/callTokenUsage.getters.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAE3E,eAAO,MAAM,2BAA2B,uDAEvC,CAAC;AAkBF,eAAO,MAAM,uBAAuB,GAClC,SAAS,MAAM,EACf,kCAAkC,cAAc,KAC/C,OAAO,CAAC,IAAI,CAcd,CAAC"}

package/dist/talkpilot/callTokenUsage/callTokenUsage.getters.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.incrementCallTokenUsage = exports.getCallTokenUsageCollection = void 0;
+const index_1 = require("../index");
+const getCallTokenUsageCollection = () => {
+    return (0, index_1.getDb)().collection("callTokenUsage");
+};
+exports.getCallTokenUsageCollection = getCallTokenUsageCollection;
+// Unique callSid, so concurrent first reports of a call upsert one document, not several.
+const callSidIndexByDb = new WeakMap();
+const ensureCallSidIndex = () => {
+    const db = (0, index_1.getDb)();
+    let index = callSidIndexByDb.get(db);
+    if (!index) {
+        index = (0, exports.getCallTokenUsageCollection)().createIndex({ callSid: 1 }, { unique: true });
+        callSidIndexByDb.set(db, index);
+    }
+    return index;
+};
+const incrementCallTokenUsage = async (callSid, { provider, model, ...counters }) => {
+    await ensureCallSidIndex();
+    const now = new Date();
+    await (0, exports.getCallTokenUsageCollection)().updateOne({ callSid }, {
+        $inc: Object.fromEntries(Object.entries(counters).filter(([, value]) => (value ?? 0) > 0)),
+        $set: { provider, ...(model && { model }), updatedAt: now },
+        $setOnInsert: { createdAt: now },
+    }, { upsert: true });
+};
+exports.incrementCallTokenUsage = incrementCallTokenUsage;
+//# sourceMappingURL=callTokenUsage.getters.js.map

package/dist/talkpilot/callTokenUsage/callTokenUsage.getters.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"callTokenUsage.getters.js","sourceRoot":"","sources":["../../../src/talkpilot/callTokenUsage/callTokenUsage.getters.ts"],"names":[],"mappings":";;;AACA,oCAAiC;AAG1B,MAAM,2BAA2B,GAAG,GAAG,EAAE;IAC9C,OAAO,IAAA,aAAK,GAAE,CAAC,UAAU,CAAoB,gBAAgB,CAAC,CAAC;AACjE,CAAC,CAAC;AAFW,QAAA,2BAA2B,+BAEtC;AAEF,0FAA0F;AAC1F,MAAM,gBAAgB,GAAG,IAAI,OAAO,EAAuB,CAAC;AAE5D,MAAM,kBAAkB,GAAG,GAAoB,EAAE;IAC/C,MAAM,EAAE,GAAG,IAAA,aAAK,GAAE,CAAC;IACnB,IAAI,KAAK,GAAG,gBAAgB,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IACrC,IAAI,CAAC,KAAK,EAAE,CAAC;QACX,KAAK,GAAG,IAAA,mCAA2B,GAAE,CAAC,WAAW,CAC/C,EAAE,OAAO,EAAE,CAAC,EAAE,EACd,EAAE,MAAM,EAAE,IAAI,EAAE,CACjB,CAAC;QACF,gBAAgB,CAAC,GAAG,CAAC,EAAE,EAAE,KAAK,CAAC,CAAC;IAClC,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC,CAAC;AAEK,MAAM,uBAAuB,GAAG,KAAK,EAC1C,OAAe,EACf,EAAE,QAAQ,EAAE,KAAK,EAAE,GAAG,QAAQ,EAAkB,EACjC,EAAE;IACjB,MAAM,kBAAkB,EAAE,CAAC;IAC3B,MAAM,GAAG,GAAG,IAAI,IAAI,EAAE,CAAC;IACvB,MAAM,IAAA,mCAA2B,GAAE,CAAC,SAAS,CAC3C,EAAE,OAAO,EAAE,EACX;QACE,IAAI,EAAE,MAAM,CAAC,WAAW,CACtB,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CACjE;QACD,IAAI,EAAE,EAAE,QAAQ,EAAE,GAAG,CAAC,KAAK,IAAI,EAAE,KAAK,EAAE,CAAC,EAAE,SAAS,EAAE,GAAG,EAAE;QAC3D,YAAY,EAAE,EAAE,SAAS,EAAE,GAAG,EAAE;KACE,EACpC,EAAE,MAAM,EAAE,IAAI,EAAE,CACjB,CAAC;AACJ,CAAC,CAAC;AAjBW,QAAA,uBAAuB,2BAiBlC"}

package/dist/talkpilot/callTokenUsage/callTokenUsage.types.d.ts

@@ -0,0 +1,28 @@
+export type CallTokenUsage = {
+    provider: string;
+    model?: string;
+    responsesCount?: number;
+    inputTokens?: number;
+    outputTokens?: number;
+    totalTokens?: number;
+    inputTextTokens?: number;
+    inputAudioTokens?: number;
+    inputImageTokens?: number;
+    cachedInputTokens?: number;
+    cachedInputTextTokens?: number;
+    cachedInputAudioTokens?: number;
+    cachedInputImageTokens?: number;
+    outputTextTokens?: number;
+    outputAudioTokens?: number;
+    thoughtsTokens?: number;
+    toolUseTokens?: number;
+    billableAudioSeconds?: number;
+    sessionSeconds?: number;
+    textInputsCount?: number;
+};
+export type CallTokenUsageDoc = CallTokenUsage & {
+    callSid: string;
+    createdAt: Date;
+    updatedAt: Date;
+};
+//# sourceMappingURL=callTokenUsage.types.d.ts.map

package/dist/talkpilot/callTokenUsage/callTokenUsage.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"callTokenUsage.types.d.ts","sourceRoot":"","sources":["../../../src/talkpilot/callTokenUsage/callTokenUsage.types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,cAAc,GAAG;IAC3B,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG,cAAc,GAAG;IAC/C,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,IAAI,CAAC;IAChB,SAAS,EAAE,IAAI,CAAC;CACjB,CAAC"}

package/dist/talkpilot/callTokenUsage/callTokenUsage.types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=callTokenUsage.types.js.map

package/dist/talkpilot/callTokenUsage/callTokenUsage.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"callTokenUsage.types.js","sourceRoot":"","sources":["../../../src/talkpilot/callTokenUsage/callTokenUsage.types.ts"],"names":[],"mappings":""}

package/dist/talkpilot/callTokenUsage/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./callTokenUsage.getters";
+export type * from "./callTokenUsage.types";
+//# sourceMappingURL=index.d.ts.map

package/dist/talkpilot/callTokenUsage/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/talkpilot/callTokenUsage/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC;AACzC,mBAAmB,wBAAwB,CAAC"}

package/dist/talkpilot/callTokenUsage/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./callTokenUsage.getters"), exports);
+//# sourceMappingURL=index.js.map

package/dist/talkpilot/callTokenUsage/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/talkpilot/callTokenUsage/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,2DAAyC"}

package/dist/talkpilot/index.d.ts

@@ -12,6 +12,7 @@ export * from "./plans";
 export * from "./subscriptions";
 export * from "./groups";
 export * from "./calls";
+export * from "./callTokenUsage";
 export * from "./clientAudioBuffers";
 export * from "./clientsConfig";
 export * from "./backgroundToolResults";

package/dist/talkpilot/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/talkpilot/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,QAAQ,IAAI,aAAa,EAAE,MAAM,SAAS,CAAC;AAExD,cAAc,SAAS,CAAC;AACxB,cAAc,gBAAgB,CAAC;AAC/B,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC;AAC1B,cAAc,YAAY,CAAC;AAC3B,cAAc,iBAAiB,CAAC;AAChC,cAAc,SAAS,CAAC;AACxB,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC;AACxB,cAAc,iBAAiB,CAAC;AAChC,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC;AACxB,cAAc,sBAAsB,CAAC;AACrC,cAAc,iBAAiB,CAAC;AAChC,cAAc,yBAAyB,CAAC;AACxC,cAAc,iBAAiB,CAAC;AAChC,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAGjD,eAAO,MAAM,KAAK,GAAI,GAAG,EAAE,SAE1B,CAAC;AACF,eAAO,MAAM,KAAK,QAAO,EAGxB,CAAC;AAEF,eAAO,MAAM,QAAQ,sBAAgB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/talkpilot/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,QAAQ,IAAI,aAAa,EAAE,MAAM,SAAS,CAAC;AAExD,cAAc,SAAS,CAAC;AACxB,cAAc,gBAAgB,CAAC;AAC/B,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC;AAC1B,cAAc,YAAY,CAAC;AAC3B,cAAc,iBAAiB,CAAC;AAChC,cAAc,SAAS,CAAC;AACxB,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC;AACxB,cAAc,iBAAiB,CAAC;AAChC,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC;AACxB,cAAc,kBAAkB,CAAC;AACjC,cAAc,sBAAsB,CAAC;AACrC,cAAc,iBAAiB,CAAC;AAChC,cAAc,yBAAyB,CAAC;AACxC,cAAc,iBAAiB,CAAC;AAChC,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAGjD,eAAO,MAAM,KAAK,GAAI,GAAG,EAAE,SAE1B,CAAC;AACF,eAAO,MAAM,KAAK,QAAO,EAGxB,CAAC;AAEF,eAAO,MAAM,QAAQ,sBAAgB,CAAC"}

package/dist/talkpilot/index.js

@@ -29,6 +29,7 @@ __exportStar(require("./plans"), exports);
 __exportStar(require("./subscriptions"), exports);
 __exportStar(require("./groups"), exports);
 __exportStar(require("./calls"), exports);
+__exportStar(require("./callTokenUsage"), exports);
 __exportStar(require("./clientAudioBuffers"), exports);
 __exportStar(require("./clientsConfig"), exports);
 __exportStar(require("./backgroundToolResults"), exports);

package/dist/talkpilot/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/talkpilot/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAAA,qCAAwD;AAExD,0CAAwB;AACxB,iDAA+B;AAC/B,6CAA2B;AAC3B,4CAA0B;AAC1B,6CAA2B;AAC3B,kDAAgC;AAChC,0CAAwB;AACxB,4CAA0B;AAC1B,2CAAyB;AACzB,0CAAwB;AACxB,kDAAgC;AAChC,2CAAyB;AACzB,0CAAwB;AACxB,uDAAqC;AACrC,kDAAgC;AAChC,0DAAwC;AACxC,kDAAgC;AAChC,mDAAiD;AAAxC,+GAAA,aAAa,OAAA;AAEtB,IAAI,EAAM,CAAC;AACJ,MAAM,KAAK,GAAG,CAAC,CAAK,EAAE,EAAE;IAC7B,EAAE,GAAG,CAAC,CAAC;AACT,CAAC,CAAC;AAFW,QAAA,KAAK,SAEhB;AACK,MAAM,KAAK,GAAG,GAAO,EAAE;IAC5B,IAAI,CAAC,EAAE;QAAE,MAAM,IAAI,KAAK,CAAC,oBAAoB,CAAC,CAAC;IAC/C,OAAO,EAAE,CAAC;AACZ,CAAC,CAAC;AAHW,QAAA,KAAK,SAGhB;AAEW,QAAA,QAAQ,GAAG,kBAAa,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/talkpilot/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAAA,qCAAwD;AAExD,0CAAwB;AACxB,iDAA+B;AAC/B,6CAA2B;AAC3B,4CAA0B;AAC1B,6CAA2B;AAC3B,kDAAgC;AAChC,0CAAwB;AACxB,4CAA0B;AAC1B,2CAAyB;AACzB,0CAAwB;AACxB,kDAAgC;AAChC,2CAAyB;AACzB,0CAAwB;AACxB,mDAAiC;AACjC,uDAAqC;AACrC,kDAAgC;AAChC,0DAAwC;AACxC,kDAAgC;AAChC,mDAAiD;AAAxC,+GAAA,aAAa,OAAA;AAEtB,IAAI,EAAM,CAAC;AACJ,MAAM,KAAK,GAAG,CAAC,CAAK,EAAE,EAAE;IAC7B,EAAE,GAAG,CAAC,CAAC;AACT,CAAC,CAAC;AAFW,QAAA,KAAK,SAEhB;AACK,MAAM,KAAK,GAAG,GAAO,EAAE;IAC5B,IAAI,CAAC,EAAE;QAAE,MAAM,IAAI,KAAK,CAAC,oBAAoB,CAAC,CAAC;IAC/C,OAAO,EAAE,CAAC;AACZ,CAAC,CAAC;AAHW,QAAA,KAAK,SAGhB;AAEW,QAAA,QAAQ,GAAG,kBAAa,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@talkpilot/core-db",
-  "version": "1.3.62",
+  "version": "1.3.64",
   "description": "Core database package for centralized connections and ORM integration.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/talkpilot/callTokenUsage/__tests__/callTokenUsage.getters.spec.ts

@@ -0,0 +1,57 @@
+import {
+  getCallTokenUsageCollection,
+  incrementCallTokenUsage,
+} from "../callTokenUsage.getters";
+
+describe("callTokenUsage getters", () => {
+  it("should add each report to the call totals and keep provider and model", async () => {
+    await incrementCallTokenUsage("CA-usage-1", {
+      provider: "openai",
+      model: "gpt-realtime",
+      inputTokens: 10,
+    });
+    await incrementCallTokenUsage("CA-usage-1", {
+      provider: "openai",
+      inputTokens: 5,
+    });
+
+    const usage = await getCallTokenUsageCollection().findOne({
+      callSid: "CA-usage-1",
+    });
+    expect(usage).toMatchObject({
+      provider: "openai",
+      model: "gpt-realtime",
+      inputTokens: 15,
+    });
+  });
+
+  it("should create a single document when first reports arrive together", async () => {
+    await Promise.all(
+      Array.from({ length: 10 }, () =>
+        incrementCallTokenUsage("CA-usage-2", {
+          provider: "xai",
+          textInputsCount: 1,
+        }),
+      ),
+    );
+
+    const docs = await getCallTokenUsageCollection()
+      .find({ callSid: "CA-usage-2" })
+      .toArray();
+    expect(docs).toHaveLength(1);
+    expect(docs[0].textInputsCount).toBe(10);
+  });
+
+  it("should not write zero counters", async () => {
+    await incrementCallTokenUsage("CA-usage-3", {
+      provider: "gemini",
+      inputTokens: 3,
+      outputTokens: 0,
+    });
+
+    const usage = await getCallTokenUsageCollection().findOne({
+      callSid: "CA-usage-3",
+    });
+    expect(usage).not.toHaveProperty("outputTokens");
+  });
+});

package/src/talkpilot/callTokenUsage/callTokenUsage.getters.ts

@@ -0,0 +1,42 @@
+import { Db, UpdateFilter } from "mongodb";
+import { getDb } from "../index";
+import { CallTokenUsage, CallTokenUsageDoc } from "./callTokenUsage.types";
+
+export const getCallTokenUsageCollection = () => {
+  return getDb().collection<CallTokenUsageDoc>("callTokenUsage");
+};
+
+// Unique callSid, so concurrent first reports of a call upsert one document, not several.
+const callSidIndexByDb = new WeakMap<Db, Promise<string>>();
+
+const ensureCallSidIndex = (): Promise<string> => {
+  const db = getDb();
+  let index = callSidIndexByDb.get(db);
+  if (!index) {
+    index = getCallTokenUsageCollection().createIndex(
+      { callSid: 1 },
+      { unique: true },
+    );
+    callSidIndexByDb.set(db, index);
+  }
+  return index;
+};
+
+export const incrementCallTokenUsage = async (
+  callSid: string,
+  { provider, model, ...counters }: CallTokenUsage,
+): Promise<void> => {
+  await ensureCallSidIndex();
+  const now = new Date();
+  await getCallTokenUsageCollection().updateOne(
+    { callSid },
+    {
+      $inc: Object.fromEntries(
+        Object.entries(counters).filter(([, value]) => (value ?? 0) > 0),
+      ),
+      $set: { provider, ...(model && { model }), updatedAt: now },
+      $setOnInsert: { createdAt: now },
+    } as UpdateFilter<CallTokenUsageDoc>,
+    { upsert: true },
+  );
+};

package/src/talkpilot/callTokenUsage/callTokenUsage.types.ts

@@ -0,0 +1,28 @@
+export type CallTokenUsage = {
+  provider: string;
+  model?: string;
+  responsesCount?: number;
+  inputTokens?: number;
+  outputTokens?: number;
+  totalTokens?: number;
+  inputTextTokens?: number;
+  inputAudioTokens?: number;
+  inputImageTokens?: number;
+  cachedInputTokens?: number;
+  cachedInputTextTokens?: number;
+  cachedInputAudioTokens?: number;
+  cachedInputImageTokens?: number;
+  outputTextTokens?: number;
+  outputAudioTokens?: number;
+  thoughtsTokens?: number;
+  toolUseTokens?: number;
+  billableAudioSeconds?: number;
+  sessionSeconds?: number;
+  textInputsCount?: number;
+};
+
+export type CallTokenUsageDoc = CallTokenUsage & {
+  callSid: string;
+  createdAt: Date;
+  updatedAt: Date;
+};

package/src/talkpilot/callTokenUsage/index.ts

@@ -0,0 +1,2 @@
+export * from "./callTokenUsage.getters";
+export type * from "./callTokenUsage.types";

package/src/talkpilot/index.ts

@@ -13,6 +13,7 @@ export * from "./plans";
 export * from "./subscriptions";
 export * from "./groups";
 export * from "./calls";
+export * from "./callTokenUsage";
 export * from "./clientAudioBuffers";
 export * from "./clientsConfig";
 export * from "./backgroundToolResults";

package/src/websitalk/scans/__tests__/scans.spec.ts

@@ -1,362 +1,362 @@
-import {
-  getScansCollection,
-  getScansByClientAndDateRange,
-  getScanFieldsByClientAndDateRange,
-  findScansByQuery,
-  countScans,
-  createScanDoc,
-  updateScanDoc,
-  findInProgressScansByClient,
-  getScansByWebsiteUrl,
-  getLatestScanByWebsiteUrl,
-  getInProgressScanByWebsiteUrl,
-  getLatestCompletedScanByWebsiteUrl,
-  deleteScansByWebsiteUrl,
-  deleteScanById,
-} from "../scans.getters";
-import { FINISHED_SCAN_STATUSES, SCAN_STATUSES } from "../scans.constants";
-import { createScanFixture } from "../../../test-utils/factories";
-import { ObjectId } from "mongodb";
-
-describe("db.websitalk.scans", () => {
-  describe("getScansByClientAndDateRange()", () => {
-    it("should return full scan documents within the date range", async () => {
-      const clientId = "dateRangeClient";
-      const startDate = new Date("2023-05-01");
-      const endDate = new Date("2023-05-31");
-
-      const scanInside = createScanFixture({ clientId, status: "COMPLETED" });
-      const scanBefore = createScanFixture({ clientId });
-      const scanAfter = createScanFixture({ clientId });
-
-      await getScansCollection().insertMany([
-        { ...scanInside, createdAt: new Date("2023-05-15") },
-        { ...scanBefore, createdAt: new Date("2023-04-30") },
-        { ...scanAfter, createdAt: new Date("2023-06-01") },
-      ]);
-
-      const result = await getScansByClientAndDateRange(
-        clientId,
-        startDate,
-        endDate,
-      );
-
-      expect(result.length).toBe(1);
-      expect(result[0]).toMatchObject({
-        clientId,
-        websiteUrlId: scanInside.websiteUrlId,
-        status: "COMPLETED",
-      });
-      expect(result[0]).toHaveProperty("siteChrome");
-      expect(result[0]).toHaveProperty("skipped");
-    });
-
-    it("should respect the date range boundaries (inclusive)", async () => {
-      const clientId = "boundaryClient";
-      const onStart = createScanFixture({ clientId });
-      const onEnd = createScanFixture({ clientId });
-
-      await getScansCollection().insertMany([
-        { ...onStart, createdAt: new Date("2023-05-01") },
-        { ...onEnd, createdAt: new Date("2023-05-31") },
-      ]);
-
-      const result = await getScansByClientAndDateRange(
-        clientId,
-        new Date("2023-05-01"),
-        new Date("2023-05-31"),
-      );
-
-      expect(result.length).toBe(2);
-    });
-  });
-
-  describe("getScanFieldsByClientAndDateRange()", () => {
-    it("should return only the requested fields (plus _id)", async () => {
-      const clientId = "projectionClient";
-      const scan = createScanFixture({
-        clientId,
-        status: "COMPLETED",
-        siteChrome: { url: "https://example.com", sourceType: "site_chrome" },
-        skipped: [{ path: "/broken", reason: "HTTP 500" }],
-      });
-
-      await getScansCollection().insertOne({
-        ...scan,
-        createdAt: new Date("2023-05-15"),
-      });
-
-      const [result] = await getScanFieldsByClientAndDateRange(
-        clientId,
-        new Date("2023-05-01"),
-        new Date("2023-05-31"),
-        ["clientId", "websiteUrlId", "status"],
-      );
-
-      expect(result).toMatchObject({
-        clientId,
-        websiteUrlId: scan.websiteUrlId,
-        status: "COMPLETED",
-      });
-      expect(result).toHaveProperty("_id");
-      expect(result).not.toHaveProperty("siteChrome");
-      expect(result).not.toHaveProperty("skipped");
-      expect(result).not.toHaveProperty("createdAt");
-    });
-  });
-
-  describe("findScansByQuery() / countScans()", () => {
-    it("should find scans matching a raw filter and count them", async () => {
-      const clientId = "queryClient";
-      const completed = createScanFixture({ clientId, status: "COMPLETED" });
-      const scanning = createScanFixture({ clientId, status: "SCANNING" });
-
-      await getScansCollection().insertMany([completed, scanning]);
-
-      const result = await findScansByQuery({ clientId, status: "COMPLETED" });
-      const count = await countScans({ clientId });
-
-      expect(result.length).toBe(1);
-      expect(result[0].websiteUrlId).toBe(completed.websiteUrlId);
-      expect(count).toBe(2);
-    });
-  });
-
-  describe("createScanDoc()", () => {
-    it("should insert a scan with default values for the rest of the fields", async () => {
-      const clientId = "createClient";
-      const websiteUrlId = new ObjectId().toString();
-
-      const { insertedId } = await createScanDoc({ clientId, websiteUrlId });
-
-      const result = await getScansCollection().findOne({ _id: insertedId });
-
-      expect(result).toMatchObject({
-        clientId,
-        websiteUrlId,
-        status: "CHECKING",
-        activeTasksCount: 0,
-        pagesScanned: 0,
-        pagesSkipped: 0,
-        skipped: [],
-        siteChrome: {},
-        pausedAt: null,
-      });
-      expect(result?.createdAt).toBeInstanceOf(Date);
-      expect(result?.updatedAt).toBeInstanceOf(Date);
-    });
-  });
-
-  describe("pausedAt", () => {
-    it("is set on pause and cleared back to null on resume, via updateScanDoc", async () => {
-      const scan = createScanFixture({ status: "SCANNING", pausedAt: null });
-      const { insertedId } = await getScansCollection().insertOne(scan);
-
-      const pausedAt = new Date();
-      const paused = await updateScanDoc(insertedId, {
-        status: "PAUSED",
-        pausedAt,
-      });
-      expect(paused?.pausedAt).toEqual(pausedAt);
-
-      const resumed = await updateScanDoc(insertedId, {
-        status: "SCANNING",
-        pausedAt: null,
-      });
-      expect(resumed?.pausedAt).toBeNull();
-    });
-  });
-
-  describe("updateScanDoc()", () => {
-    it("should update the given fields and bump updatedAt", async () => {
-      const scan = createScanFixture({ status: "SCANNING", pagesScanned: 0 });
-      const { insertedId } = await getScansCollection().insertOne(scan);
-
-      const result = await updateScanDoc(insertedId, {
-        status: "COMPLETED",
-        pagesScanned: 10,
-      });
-
-      expect(result).toMatchObject({
-        _id: insertedId,
-        status: "COMPLETED",
-        pagesScanned: 10,
-      });
-      expect(result?.updatedAt.getTime()).toBeGreaterThan(
-        scan.updatedAt.getTime(),
-      );
-    });
-
-    it("should return null when the scan does not exist", async () => {
-      const result = await updateScanDoc(new ObjectId(), { status: "FAILED" });
-
-      expect(result).toBeNull();
-    });
-  });
-
-  describe("in-progress scan helpers", () => {
-    const websiteUrlId = "website-123";
-
-    it("should return website scan history newest first", async () => {
-      await getScansCollection().insertMany([
-        createScanFixture({
-          websiteUrlId,
-          status: "COMPLETED",
-          createdAt: new Date("2023-05-01"),
-        }),
-        createScanFixture({
-          websiteUrlId,
-          status: "COMPLETED",
-          createdAt: new Date("2023-05-15"),
-        }),
-      ]);
-
-      const scans = await getScansByWebsiteUrl(websiteUrlId);
-      expect(scans).toHaveLength(2);
-      expect(scans[0].createdAt.getTime()).toBeGreaterThan(
-        scans[1].createdAt.getTime(),
-      );
-    });
-
-    it("should return the newest scan for a website", async () => {
-      await getScansCollection().insertMany([
-        createScanFixture({
-          websiteUrlId,
-          status: "COMPLETED",
-          createdAt: new Date("2023-05-01"),
-        }),
-        createScanFixture({
-          websiteUrlId,
-          status: "FAILED",
-          createdAt: new Date("2023-05-15"),
-        }),
-      ]);
-
-      const latest = await getLatestScanByWebsiteUrl(websiteUrlId);
-      expect(latest?.status).toBe("FAILED");
-    });
-
-    it("should return in-progress scan and return null when only completed exists", async () => {
-      await getScansCollection().insertMany([
-        createScanFixture({
-          websiteUrlId,
-          status: "COMPLETED",
-          createdAt: new Date("2023-05-01"),
-        }),
-        createScanFixture({
-          websiteUrlId,
-          status: "SCANNING",
-          createdAt: new Date("2023-05-15"),
-        }),
-      ]);
-
-      const inProgressScan = await getInProgressScanByWebsiteUrl(websiteUrlId);
-      expect(inProgressScan?.status).toBe("SCANNING");
-
-      await getScansCollection().deleteMany({ websiteUrlId });
-      await getScansCollection().insertOne(
-        createScanFixture({
-          websiteUrlId,
-          status: "COMPLETED",
-          createdAt: new Date("2023-05-20"),
-        }),
-      );
-
-      expect(await getInProgressScanByWebsiteUrl(websiteUrlId)).toBeNull();
-    });
-
-    it("should return all in-progress scans across websites for a client", async () => {
-      const clientId = "multiScanClient";
-      await getScansCollection().insertMany([
-        createScanFixture({
-          clientId,
-          websiteUrlId: "website-a",
-          status: "SCANNING",
-        }),
-        createScanFixture({
-          clientId,
-          websiteUrlId: "website-b",
-          status: "PROCESSING",
-        }),
-        createScanFixture({
-          clientId,
-          websiteUrlId: "website-c",
-          status: "COMPLETED",
-        }),
-      ]);
-
-      const scans = await findInProgressScansByClient(clientId);
-      expect(scans).toHaveLength(2);
-      expect(scans.map((s) => s.websiteUrlId).sort()).toEqual([
-        "website-a",
-        "website-b",
-      ]);
-    });
-  });
-
-  describe("website delete helpers", () => {
-    it("should return the newest completed scan only", async () => {
-      const websiteUrlId = new ObjectId().toString();
-      await getScansCollection().insertMany([
-        createScanFixture({
-          websiteUrlId,
-          status: "FAILED",
-          createdAt: new Date("2023-05-25"),
-        }),
-        createScanFixture({
-          websiteUrlId,
-          status: "COMPLETED",
-          createdAt: new Date("2023-05-20"),
-        }),
-        createScanFixture({
-          websiteUrlId,
-          status: "COMPLETED",
-          createdAt: new Date("2023-05-22"),
-        }),
-      ]);
-
-      const latest = await getLatestCompletedScanByWebsiteUrl(websiteUrlId);
-      expect(latest?.status).toBe("COMPLETED");
-      expect(latest?.createdAt).toEqual(new Date("2023-05-22"));
-    });
-
-    it("should delete all scans for the website and return count", async () => {
-      const websiteUrlId = new ObjectId().toString();
-      await getScansCollection().insertMany([
-        createScanFixture({ websiteUrlId }),
-        createScanFixture({ websiteUrlId }),
-        createScanFixture({ websiteUrlId: new ObjectId().toString() }),
-      ]);
-
-      const deleted = await deleteScansByWebsiteUrl(websiteUrlId);
-      expect(deleted).toBe(2);
-      expect(await countScans({ websiteUrlId })).toBe(0);
-    });
-  });
-
-  describe("deleteScanById()", () => {
-    it("should delete the scan and return true", async () => {
-      const { insertedId } =
-        await getScansCollection().insertOne(createScanFixture());
-
-      expect(await deleteScanById(insertedId)).toBe(true);
-      expect(
-        await getScansCollection().findOne({ _id: insertedId }),
-      ).toBeNull();
-    });
-
-    it("should return false when the scan does not exist", async () => {
-      expect(await deleteScanById(new ObjectId())).toBe(false);
-    });
-  });
-
-  describe("FINISHED_SCAN_STATUSES", () => {
-    it("should include CANCELED — canceling is final, not resumable", () => {
-      expect(FINISHED_SCAN_STATUSES).toContain(SCAN_STATUSES.CANCELED);
-    });
-
-    it("should NOT include PAUSED — pausing is reversible", () => {
-      expect(FINISHED_SCAN_STATUSES).not.toContain(SCAN_STATUSES.PAUSED);
-    });
-  });
-});
+import {
+  getScansCollection,
+  getScansByClientAndDateRange,
+  getScanFieldsByClientAndDateRange,
+  findScansByQuery,
+  countScans,
+  createScanDoc,
+  updateScanDoc,
+  findInProgressScansByClient,
+  getScansByWebsiteUrl,
+  getLatestScanByWebsiteUrl,
+  getInProgressScanByWebsiteUrl,
+  getLatestCompletedScanByWebsiteUrl,
+  deleteScansByWebsiteUrl,
+  deleteScanById,
+} from "../scans.getters";
+import { FINISHED_SCAN_STATUSES, SCAN_STATUSES } from "../scans.constants";
+import { createScanFixture } from "../../../test-utils/factories";
+import { ObjectId } from "mongodb";
+
+describe("db.websitalk.scans", () => {
+  describe("getScansByClientAndDateRange()", () => {
+    it("should return full scan documents within the date range", async () => {
+      const clientId = "dateRangeClient";
+      const startDate = new Date("2023-05-01");
+      const endDate = new Date("2023-05-31");
+
+      const scanInside = createScanFixture({ clientId, status: "COMPLETED" });
+      const scanBefore = createScanFixture({ clientId });
+      const scanAfter = createScanFixture({ clientId });
+
+      await getScansCollection().insertMany([
+        { ...scanInside, createdAt: new Date("2023-05-15") },
+        { ...scanBefore, createdAt: new Date("2023-04-30") },
+        { ...scanAfter, createdAt: new Date("2023-06-01") },
+      ]);
+
+      const result = await getScansByClientAndDateRange(
+        clientId,
+        startDate,
+        endDate,
+      );
+
+      expect(result.length).toBe(1);
+      expect(result[0]).toMatchObject({
+        clientId,
+        websiteUrlId: scanInside.websiteUrlId,
+        status: "COMPLETED",
+      });
+      expect(result[0]).toHaveProperty("siteChrome");
+      expect(result[0]).toHaveProperty("skipped");
+    });
+
+    it("should respect the date range boundaries (inclusive)", async () => {
+      const clientId = "boundaryClient";
+      const onStart = createScanFixture({ clientId });
+      const onEnd = createScanFixture({ clientId });
+
+      await getScansCollection().insertMany([
+        { ...onStart, createdAt: new Date("2023-05-01") },
+        { ...onEnd, createdAt: new Date("2023-05-31") },
+      ]);
+
+      const result = await getScansByClientAndDateRange(
+        clientId,
+        new Date("2023-05-01"),
+        new Date("2023-05-31"),
+      );
+
+      expect(result.length).toBe(2);
+    });
+  });
+
+  describe("getScanFieldsByClientAndDateRange()", () => {
+    it("should return only the requested fields (plus _id)", async () => {
+      const clientId = "projectionClient";
+      const scan = createScanFixture({
+        clientId,
+        status: "COMPLETED",
+        siteChrome: { url: "https://example.com", sourceType: "site_chrome" },
+        skipped: [{ path: "/broken", reason: "HTTP 500" }],
+      });
+
+      await getScansCollection().insertOne({
+        ...scan,
+        createdAt: new Date("2023-05-15"),
+      });
+
+      const [result] = await getScanFieldsByClientAndDateRange(
+        clientId,
+        new Date("2023-05-01"),
+        new Date("2023-05-31"),
+        ["clientId", "websiteUrlId", "status"],
+      );
+
+      expect(result).toMatchObject({
+        clientId,
+        websiteUrlId: scan.websiteUrlId,
+        status: "COMPLETED",
+      });
+      expect(result).toHaveProperty("_id");
+      expect(result).not.toHaveProperty("siteChrome");
+      expect(result).not.toHaveProperty("skipped");
+      expect(result).not.toHaveProperty("createdAt");
+    });
+  });
+
+  describe("findScansByQuery() / countScans()", () => {
+    it("should find scans matching a raw filter and count them", async () => {
+      const clientId = "queryClient";
+      const completed = createScanFixture({ clientId, status: "COMPLETED" });
+      const scanning = createScanFixture({ clientId, status: "SCANNING" });
+
+      await getScansCollection().insertMany([completed, scanning]);
+
+      const result = await findScansByQuery({ clientId, status: "COMPLETED" });
+      const count = await countScans({ clientId });
+
+      expect(result.length).toBe(1);
+      expect(result[0].websiteUrlId).toBe(completed.websiteUrlId);
+      expect(count).toBe(2);
+    });
+  });
+
+  describe("createScanDoc()", () => {
+    it("should insert a scan with default values for the rest of the fields", async () => {
+      const clientId = "createClient";
+      const websiteUrlId = new ObjectId().toString();
+
+      const { insertedId } = await createScanDoc({ clientId, websiteUrlId });
+
+      const result = await getScansCollection().findOne({ _id: insertedId });
+
+      expect(result).toMatchObject({
+        clientId,
+        websiteUrlId,
+        status: "CHECKING",
+        activeTasksCount: 0,
+        pagesScanned: 0,
+        pagesSkipped: 0,
+        skipped: [],
+        siteChrome: {},
+        pausedAt: null,
+      });
+      expect(result?.createdAt).toBeInstanceOf(Date);
+      expect(result?.updatedAt).toBeInstanceOf(Date);
+    });
+  });
+
+  describe("pausedAt", () => {
+    it("is set on pause and cleared back to null on resume, via updateScanDoc", async () => {
+      const scan = createScanFixture({ status: "SCANNING", pausedAt: null });
+      const { insertedId } = await getScansCollection().insertOne(scan);
+
+      const pausedAt = new Date();
+      const paused = await updateScanDoc(insertedId, {
+        status: "PAUSED",
+        pausedAt,
+      });
+      expect(paused?.pausedAt).toEqual(pausedAt);
+
+      const resumed = await updateScanDoc(insertedId, {
+        status: "SCANNING",
+        pausedAt: null,
+      });
+      expect(resumed?.pausedAt).toBeNull();
+    });
+  });
+
+  describe("updateScanDoc()", () => {
+    it("should update the given fields and bump updatedAt", async () => {
+      const scan = createScanFixture({ status: "SCANNING", pagesScanned: 0 });
+      const { insertedId } = await getScansCollection().insertOne(scan);
+
+      const result = await updateScanDoc(insertedId, {
+        status: "COMPLETED",
+        pagesScanned: 10,
+      });
+
+      expect(result).toMatchObject({
+        _id: insertedId,
+        status: "COMPLETED",
+        pagesScanned: 10,
+      });
+      expect(result?.updatedAt.getTime()).toBeGreaterThan(
+        scan.updatedAt.getTime(),
+      );
+    });
+
+    it("should return null when the scan does not exist", async () => {
+      const result = await updateScanDoc(new ObjectId(), { status: "FAILED" });
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe("in-progress scan helpers", () => {
+    const websiteUrlId = "website-123";
+
+    it("should return website scan history newest first", async () => {
+      await getScansCollection().insertMany([
+        createScanFixture({
+          websiteUrlId,
+          status: "COMPLETED",
+          createdAt: new Date("2023-05-01"),
+        }),
+        createScanFixture({
+          websiteUrlId,
+          status: "COMPLETED",
+          createdAt: new Date("2023-05-15"),
+        }),
+      ]);
+
+      const scans = await getScansByWebsiteUrl(websiteUrlId);
+      expect(scans).toHaveLength(2);
+      expect(scans[0].createdAt.getTime()).toBeGreaterThan(
+        scans[1].createdAt.getTime(),
+      );
+    });
+
+    it("should return the newest scan for a website", async () => {
+      await getScansCollection().insertMany([
+        createScanFixture({
+          websiteUrlId,
+          status: "COMPLETED",
+          createdAt: new Date("2023-05-01"),
+        }),
+        createScanFixture({
+          websiteUrlId,
+          status: "FAILED",
+          createdAt: new Date("2023-05-15"),
+        }),
+      ]);
+
+      const latest = await getLatestScanByWebsiteUrl(websiteUrlId);
+      expect(latest?.status).toBe("FAILED");
+    });
+
+    it("should return in-progress scan and return null when only completed exists", async () => {
+      await getScansCollection().insertMany([
+        createScanFixture({
+          websiteUrlId,
+          status: "COMPLETED",
+          createdAt: new Date("2023-05-01"),
+        }),
+        createScanFixture({
+          websiteUrlId,
+          status: "SCANNING",
+          createdAt: new Date("2023-05-15"),
+        }),
+      ]);
+
+      const inProgressScan = await getInProgressScanByWebsiteUrl(websiteUrlId);
+      expect(inProgressScan?.status).toBe("SCANNING");
+
+      await getScansCollection().deleteMany({ websiteUrlId });
+      await getScansCollection().insertOne(
+        createScanFixture({
+          websiteUrlId,
+          status: "COMPLETED",
+          createdAt: new Date("2023-05-20"),
+        }),
+      );
+
+      expect(await getInProgressScanByWebsiteUrl(websiteUrlId)).toBeNull();
+    });
+
+    it("should return all in-progress scans across websites for a client", async () => {
+      const clientId = "multiScanClient";
+      await getScansCollection().insertMany([
+        createScanFixture({
+          clientId,
+          websiteUrlId: "website-a",
+          status: "SCANNING",
+        }),
+        createScanFixture({
+          clientId,
+          websiteUrlId: "website-b",
+          status: "PROCESSING",
+        }),
+        createScanFixture({
+          clientId,
+          websiteUrlId: "website-c",
+          status: "COMPLETED",
+        }),
+      ]);
+
+      const scans = await findInProgressScansByClient(clientId);
+      expect(scans).toHaveLength(2);
+      expect(scans.map((s) => s.websiteUrlId).sort()).toEqual([
+        "website-a",
+        "website-b",
+      ]);
+    });
+  });
+
+  describe("website delete helpers", () => {
+    it("should return the newest completed scan only", async () => {
+      const websiteUrlId = new ObjectId().toString();
+      await getScansCollection().insertMany([
+        createScanFixture({
+          websiteUrlId,
+          status: "FAILED",
+          createdAt: new Date("2023-05-25"),
+        }),
+        createScanFixture({
+          websiteUrlId,
+          status: "COMPLETED",
+          createdAt: new Date("2023-05-20"),
+        }),
+        createScanFixture({
+          websiteUrlId,
+          status: "COMPLETED",
+          createdAt: new Date("2023-05-22"),
+        }),
+      ]);
+
+      const latest = await getLatestCompletedScanByWebsiteUrl(websiteUrlId);
+      expect(latest?.status).toBe("COMPLETED");
+      expect(latest?.createdAt).toEqual(new Date("2023-05-22"));
+    });
+
+    it("should delete all scans for the website and return count", async () => {
+      const websiteUrlId = new ObjectId().toString();
+      await getScansCollection().insertMany([
+        createScanFixture({ websiteUrlId }),
+        createScanFixture({ websiteUrlId }),
+        createScanFixture({ websiteUrlId: new ObjectId().toString() }),
+      ]);
+
+      const deleted = await deleteScansByWebsiteUrl(websiteUrlId);
+      expect(deleted).toBe(2);
+      expect(await countScans({ websiteUrlId })).toBe(0);
+    });
+  });
+
+  describe("deleteScanById()", () => {
+    it("should delete the scan and return true", async () => {
+      const { insertedId } =
+        await getScansCollection().insertOne(createScanFixture());
+
+      expect(await deleteScanById(insertedId)).toBe(true);
+      expect(
+        await getScansCollection().findOne({ _id: insertedId }),
+      ).toBeNull();
+    });
+
+    it("should return false when the scan does not exist", async () => {
+      expect(await deleteScanById(new ObjectId())).toBe(false);
+    });
+  });
+
+  describe("FINISHED_SCAN_STATUSES", () => {
+    it("should include CANCELED — canceling is final, not resumable", () => {
+      expect(FINISHED_SCAN_STATUSES).toContain(SCAN_STATUSES.CANCELED);
+    });
+
+    it("should NOT include PAUSED — pausing is reversible", () => {
+      expect(FINISHED_SCAN_STATUSES).not.toContain(SCAN_STATUSES.PAUSED);
+    });
+  });
+});