@talkpilot/core-db 1.3.74 → 1.3.76

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

@@ -1,147 +1,147 @@
-import {
-  getBackgroundToolResultsCollection,
-  upsertBackgroundToolResult,
-  findBackgroundToolResult,
-  findBackgroundToolResultsByCallSid,
-} from "../backgroundToolResults.getters";
-import { BackgroundToolStatus } from "../backgroundToolResults.types";
-
-describe("backgroundToolResults getters", () => {
-  it('should return the "backgroundToolResults" collection', () => {
-    const collection = getBackgroundToolResultsCollection();
-    expect(collection.collectionName).toBe("backgroundToolResults");
-  });
-
-  it("should create a new background tool result with correct fields and default TTL", async () => {
-    const callSid = "CA-background-call-1";
-    const toolName = "exampleTool";
-    const status: BackgroundToolStatus = "pending";
-    const result = null;
-
-    const before = new Date();
-    const doc = await upsertBackgroundToolResult({
-      callSid,
-      toolName,
-      status,
-      result,
-    });
-    const after = new Date();
-
-    expect(doc).not.toBeNull();
-    expect(doc?.callSid).toBe(callSid);
-    expect(doc?.toolName).toBe(toolName);
-    expect(doc?.status).toBe(status);
-    expect(doc?.result).toBe(result);
-    expect(doc?.createdAt).toBeInstanceOf(Date);
-    expect(doc?.updatedAt).toBeInstanceOf(Date);
-    expect(doc?.expiredAt).toBeInstanceOf(Date);
-
-    const createdAt = doc!.createdAt.getTime();
-    const expiredAt = doc!.expiredAt.getTime();
-    const ttlMs = expiredAt - createdAt;
-
-    expect(ttlMs).toBeGreaterThanOrEqual(60 * 60_000 - 1000);
-    expect(ttlMs).toBeLessThanOrEqual(60 * 60_000 + 1000);
-
-    expect(doc!.createdAt.getTime()).toBeGreaterThanOrEqual(before.getTime());
-    expect(doc!.updatedAt.getTime()).toBeLessThanOrEqual(after.getTime());
-  });
-
-  it("should upsert by callSid + toolName and keep createdAt while updating other fields", async () => {
-    const callSid = "CA-background-call-2";
-    const toolName = "aggregationTool";
-
-    const first = await upsertBackgroundToolResult({
-      callSid,
-      toolName,
-      status: "pending",
-      result: null,
-    });
-
-    expect(first).not.toBeNull();
-
-    const firstCreatedAt = first!.createdAt;
-    const firstUpdatedAt = first!.updatedAt;
-    const firstExpiredAt = first!.expiredAt;
-
-    const customTtlMs = 5 * 60_000;
-    const secondResultPayload = { value: 42 };
-
-    const second = await upsertBackgroundToolResult({
-      callSid,
-      toolName,
-      status: "success",
-      result: secondResultPayload,
-      ttlMs: customTtlMs,
-    });
-
-    expect(second).not.toBeNull();
-    expect(second!._id.toHexString()).toBe(first!._id.toHexString());
-    expect(second!.callSid).toBe(callSid);
-    expect(second!.toolName).toBe(toolName);
-    expect(second!.status).toBe("success");
-    expect(second!.result).toEqual(secondResultPayload);
-
-    expect(second!.createdAt.getTime()).toBe(firstCreatedAt.getTime());
-
-    expect(second!.updatedAt.getTime()).toBeGreaterThanOrEqual(
-      firstUpdatedAt.getTime(),
-    );
-    expect(second!.expiredAt.getTime()).not.toBe(firstExpiredAt.getTime());
-
-    const ttlMs = second!.expiredAt.getTime() - second!.updatedAt.getTime();
-    expect(ttlMs).toBeGreaterThanOrEqual(customTtlMs - 1000);
-    expect(ttlMs).toBeLessThanOrEqual(customTtlMs + 1000);
-  });
-
-  it("should find background tool result by callSid and toolName", async () => {
-    const callSid = "CA-background-call-3";
-    const toolName = "fetchUserData";
-
-    await upsertBackgroundToolResult({
-      callSid,
-      toolName,
-      status: "success",
-      result: { foo: "bar" },
-    });
-
-    const found = await findBackgroundToolResult(callSid, toolName);
-    expect(found).not.toBeNull();
-    expect(found?.callSid).toBe(callSid);
-    expect(found?.toolName).toBe(toolName);
-  });
-
-  it("should return null when background tool result does not exist", async () => {
-    const found = await findBackgroundToolResult(
-      "non-existing-callSid",
-      "nonExistingTool",
-    );
-    expect(found).toBeNull();
-  });
-
-  it("should return all background tool results for a callSid ordered by createdAt", async () => {
-    const callSid = "CA-background-call-4";
-
-    await upsertBackgroundToolResult({
-      callSid,
-      toolName: "toolA",
-      status: "pending",
-      result: null,
-    });
-
-    await new Promise((resolve) => setTimeout(resolve, 10));
-
-    await upsertBackgroundToolResult({
-      callSid,
-      toolName: "toolB",
-      status: "success",
-      result: { ok: true },
-    });
-
-    const results = await findBackgroundToolResultsByCallSid(callSid);
-    expect(results).toHaveLength(2);
-    expect(results[0].createdAt.getTime()).toBeLessThanOrEqual(
-      results[1].createdAt.getTime(),
-    );
-  });
-});
+import {
+  getBackgroundToolResultsCollection,
+  upsertBackgroundToolResult,
+  findBackgroundToolResult,
+  findBackgroundToolResultsByCallSid,
+} from "../backgroundToolResults.getters";
+import { BackgroundToolStatus } from "../backgroundToolResults.types";
+
+describe("backgroundToolResults getters", () => {
+  it('should return the "backgroundToolResults" collection', () => {
+    const collection = getBackgroundToolResultsCollection();
+    expect(collection.collectionName).toBe("backgroundToolResults");
+  });
+
+  it("should create a new background tool result with correct fields and default TTL", async () => {
+    const callSid = "CA-background-call-1";
+    const toolName = "exampleTool";
+    const status: BackgroundToolStatus = "pending";
+    const result = null;
+
+    const before = new Date();
+    const doc = await upsertBackgroundToolResult({
+      callSid,
+      toolName,
+      status,
+      result,
+    });
+    const after = new Date();
+
+    expect(doc).not.toBeNull();
+    expect(doc?.callSid).toBe(callSid);
+    expect(doc?.toolName).toBe(toolName);
+    expect(doc?.status).toBe(status);
+    expect(doc?.result).toBe(result);
+    expect(doc?.createdAt).toBeInstanceOf(Date);
+    expect(doc?.updatedAt).toBeInstanceOf(Date);
+    expect(doc?.expiredAt).toBeInstanceOf(Date);
+
+    const createdAt = doc!.createdAt.getTime();
+    const expiredAt = doc!.expiredAt.getTime();
+    const ttlMs = expiredAt - createdAt;
+
+    expect(ttlMs).toBeGreaterThanOrEqual(60 * 60_000 - 1000);
+    expect(ttlMs).toBeLessThanOrEqual(60 * 60_000 + 1000);
+
+    expect(doc!.createdAt.getTime()).toBeGreaterThanOrEqual(before.getTime());
+    expect(doc!.updatedAt.getTime()).toBeLessThanOrEqual(after.getTime());
+  });
+
+  it("should upsert by callSid + toolName and keep createdAt while updating other fields", async () => {
+    const callSid = "CA-background-call-2";
+    const toolName = "aggregationTool";
+
+    const first = await upsertBackgroundToolResult({
+      callSid,
+      toolName,
+      status: "pending",
+      result: null,
+    });
+
+    expect(first).not.toBeNull();
+
+    const firstCreatedAt = first!.createdAt;
+    const firstUpdatedAt = first!.updatedAt;
+    const firstExpiredAt = first!.expiredAt;
+
+    const customTtlMs = 5 * 60_000;
+    const secondResultPayload = { value: 42 };
+
+    const second = await upsertBackgroundToolResult({
+      callSid,
+      toolName,
+      status: "success",
+      result: secondResultPayload,
+      ttlMs: customTtlMs,
+    });
+
+    expect(second).not.toBeNull();
+    expect(second!._id.toHexString()).toBe(first!._id.toHexString());
+    expect(second!.callSid).toBe(callSid);
+    expect(second!.toolName).toBe(toolName);
+    expect(second!.status).toBe("success");
+    expect(second!.result).toEqual(secondResultPayload);
+
+    expect(second!.createdAt.getTime()).toBe(firstCreatedAt.getTime());
+
+    expect(second!.updatedAt.getTime()).toBeGreaterThanOrEqual(
+      firstUpdatedAt.getTime(),
+    );
+    expect(second!.expiredAt.getTime()).not.toBe(firstExpiredAt.getTime());
+
+    const ttlMs = second!.expiredAt.getTime() - second!.updatedAt.getTime();
+    expect(ttlMs).toBeGreaterThanOrEqual(customTtlMs - 1000);
+    expect(ttlMs).toBeLessThanOrEqual(customTtlMs + 1000);
+  });
+
+  it("should find background tool result by callSid and toolName", async () => {
+    const callSid = "CA-background-call-3";
+    const toolName = "fetchUserData";
+
+    await upsertBackgroundToolResult({
+      callSid,
+      toolName,
+      status: "success",
+      result: { foo: "bar" },
+    });
+
+    const found = await findBackgroundToolResult(callSid, toolName);
+    expect(found).not.toBeNull();
+    expect(found?.callSid).toBe(callSid);
+    expect(found?.toolName).toBe(toolName);
+  });
+
+  it("should return null when background tool result does not exist", async () => {
+    const found = await findBackgroundToolResult(
+      "non-existing-callSid",
+      "nonExistingTool",
+    );
+    expect(found).toBeNull();
+  });
+
+  it("should return all background tool results for a callSid ordered by createdAt", async () => {
+    const callSid = "CA-background-call-4";
+
+    await upsertBackgroundToolResult({
+      callSid,
+      toolName: "toolA",
+      status: "pending",
+      result: null,
+    });
+
+    await new Promise((resolve) => setTimeout(resolve, 10));
+
+    await upsertBackgroundToolResult({
+      callSid,
+      toolName: "toolB",
+      status: "success",
+      result: { ok: true },
+    });
+
+    const results = await findBackgroundToolResultsByCallSid(callSid);
+    expect(results).toHaveLength(2);
+    expect(results[0].createdAt.getTime()).toBeLessThanOrEqual(
+      results[1].createdAt.getTime(),
+    );
+  });
+});

package/src/talkpilot/backgroundToolResults/backgroundToolResults.getters.ts

@@ -1,65 +1,65 @@
-import { Collection } from "mongodb";
-import { getDb } from "../index";
-import {
-  BackgroundToolResult,
-  BackgroundToolResultDoc,
-  UpsertBackgroundToolResultInput,
-} from "./backgroundToolResults.types";
-
-const getBackgroundToolResultsCollection =
-  (): Collection<BackgroundToolResult> => {
-    return getDb().collection<BackgroundToolResult>("backgroundToolResults");
-  };
-
-const upsertBackgroundToolResult = async (
-  input: UpsertBackgroundToolResultInput,
-): Promise<BackgroundToolResultDoc | null> => {
-  const collection = getBackgroundToolResultsCollection();
-  const now = new Date();
-  const ttlMs = input.ttlMs ?? 60 * 60_000;
-  const expiredAt = new Date(now.getTime() + ttlMs);
-
-  const filter = { callSid: input.callSid, toolName: input.toolName };
-
-  await collection.updateOne(
-    filter,
-    {
-      $set: {
-        result: input.result,
-        status: input.status,
-        updatedAt: now,
-        expiredAt,
-      },
-      $setOnInsert: {
-        callSid: input.callSid,
-        toolName: input.toolName,
-        createdAt: now,
-      },
-    },
-    { upsert: true },
-  );
-
-  return collection.findOne(filter);
-};
-
-const findBackgroundToolResult = async (
-  callSid: string,
-  toolName: string,
-): Promise<BackgroundToolResultDoc | null> => {
-  const collection = getBackgroundToolResultsCollection();
-  return collection.findOne({ callSid, toolName });
-};
-
-const findBackgroundToolResultsByCallSid = async (
-  callSid: string,
-): Promise<BackgroundToolResultDoc[]> => {
-  const collection = getBackgroundToolResultsCollection();
-  return collection.find({ callSid }).sort({ createdAt: 1 }).toArray();
-};
-
-export {
-  getBackgroundToolResultsCollection,
-  upsertBackgroundToolResult,
-  findBackgroundToolResult,
-  findBackgroundToolResultsByCallSid,
-};
+import { Collection } from "mongodb";
+import { getDb } from "../index";
+import {
+  BackgroundToolResult,
+  BackgroundToolResultDoc,
+  UpsertBackgroundToolResultInput,
+} from "./backgroundToolResults.types";
+
+const getBackgroundToolResultsCollection =
+  (): Collection<BackgroundToolResult> => {
+    return getDb().collection<BackgroundToolResult>("backgroundToolResults");
+  };
+
+const upsertBackgroundToolResult = async (
+  input: UpsertBackgroundToolResultInput,
+): Promise<BackgroundToolResultDoc | null> => {
+  const collection = getBackgroundToolResultsCollection();
+  const now = new Date();
+  const ttlMs = input.ttlMs ?? 60 * 60_000;
+  const expiredAt = new Date(now.getTime() + ttlMs);
+
+  const filter = { callSid: input.callSid, toolName: input.toolName };
+
+  await collection.updateOne(
+    filter,
+    {
+      $set: {
+        result: input.result,
+        status: input.status,
+        updatedAt: now,
+        expiredAt,
+      },
+      $setOnInsert: {
+        callSid: input.callSid,
+        toolName: input.toolName,
+        createdAt: now,
+      },
+    },
+    { upsert: true },
+  );
+
+  return collection.findOne(filter);
+};
+
+const findBackgroundToolResult = async (
+  callSid: string,
+  toolName: string,
+): Promise<BackgroundToolResultDoc | null> => {
+  const collection = getBackgroundToolResultsCollection();
+  return collection.findOne({ callSid, toolName });
+};
+
+const findBackgroundToolResultsByCallSid = async (
+  callSid: string,
+): Promise<BackgroundToolResultDoc[]> => {
+  const collection = getBackgroundToolResultsCollection();
+  return collection.find({ callSid }).sort({ createdAt: 1 }).toArray();
+};
+
+export {
+  getBackgroundToolResultsCollection,
+  upsertBackgroundToolResult,
+  findBackgroundToolResult,
+  findBackgroundToolResultsByCallSid,
+};

package/src/talkpilot/backgroundToolResults/backgroundToolResults.types.ts

@@ -1,23 +1,23 @@
-import { WithId } from "mongodb";
-
-export type BackgroundToolStatus = "success" | "pending" | "error";
-
-export interface BackgroundToolResult {
-  callSid: string;
-  toolName: string;
-  result: unknown | null;
-  status: BackgroundToolStatus;
-  createdAt: Date;
-  updatedAt: Date;
-  expiredAt: Date;
-}
-
-export type BackgroundToolResultDoc = WithId<BackgroundToolResult>;
-
-export interface UpsertBackgroundToolResultInput {
-  callSid: string;
-  toolName: string;
-  result: unknown | null;
-  status: BackgroundToolStatus;
-  ttlMs?: number;
-}
+import { WithId } from "mongodb";
+
+export type BackgroundToolStatus = "success" | "pending" | "error";
+
+export interface BackgroundToolResult {
+  callSid: string;
+  toolName: string;
+  result: unknown | null;
+  status: BackgroundToolStatus;
+  createdAt: Date;
+  updatedAt: Date;
+  expiredAt: Date;
+}
+
+export type BackgroundToolResultDoc = WithId<BackgroundToolResult>;
+
+export interface UpsertBackgroundToolResultInput {
+  callSid: string;
+  toolName: string;
+  result: unknown | null;
+  status: BackgroundToolStatus;
+  ttlMs?: number;
+}

package/src/talkpilot/backgroundToolResults/index.ts

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

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

@@ -1,57 +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");
-  });
-});
+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");
+  });
+});