@talkpilot/core-db 1.1.8 → 1.1.10

package/src/talkpilot/calls/__tests__/calls.spec.ts

@@ -8,12 +8,14 @@ import {
   countCalls,
   getCallsByClientAndDateRange,
   getCallsCollection,
-} from '../calls.getters';
-import { ObjectId } from 'mongodb';
-import { createOutGoingCallDoc } from '../../../test-utils/factories';
-
-describe('db.calls', () => {
-  it('should return calls by flow', async () => {
+  pushToolExecution,
+} from "../calls.getters";
+import type { ToolExecution } from '../calls.types';
+import { ObjectId } from "mongodb";
+import { createOutGoingCallDoc } from "../../../test-utils/factories";
+
+describe("db.calls", () => {
+  it("should return calls by flow", async () => {
     const flowId = new ObjectId();
     const call1 = createOutGoingCallDoc({ flowId });
     const call2 = createOutGoingCallDoc({ flowId });
@@ -26,11 +28,11 @@ describe('db.calls', () => {
     expect(result.length).toBe(2);
     expect(result).toMatchObject([
       { callSid: call1.callSid },
-      { callSid: call2.callSid }
+      { callSid: call2.callSid },
     ]);
   });
 
-  it('should get call by callSid', async () => {
+  it("should get call by callSid", async () => {
     const call = createOutGoingCallDoc();
     await createCallDoc(call);
 
@@ -40,39 +42,54 @@ describe('db.calls', () => {
     expect(result?.callSid).toBe(call.callSid);
   });
 
-  it('should get calls by client', async () => {
+  it("should get calls by client", async () => {
     const call = createOutGoingCallDoc();
     await createCallDoc(call);
 
     const result = await getCallsByClient(call.clientId);
 
-    expect(result.some(c => c.callSid === call.callSid)).toBe(true);
+    expect(result.some((c) => c.callSid === call.callSid)).toBe(true);
   });
 
-  it('should get calls by phone number', async () => {
+  it("should get calls by phone number", async () => {
     const call = createOutGoingCallDoc();
     await createCallDoc(call);
 
     const result = await getCallsByPhoneNumber(call.customerPhoneNumber);
 
-    expect(result.some(c => c.callSid === call.callSid)).toBe(true);
+    expect(result.some((c) => c.callSid === call.callSid)).toBe(true);
   });
 
-  describe('findCallsByQuery()', () => {
-    it('should find calls by status with limit and sort', async () => {
-      const clientId = 'client123';
-      const call1 = createOutGoingCallDoc({ clientId, status: 'completed' });
-      const call2 = createOutGoingCallDoc({ clientId, status: 'completed' });
-      const call3 = createOutGoingCallDoc({ clientId, status: 'busy' });
+  describe("findCallsByQuery()", () => {
+    it("should find calls by status with limit and sort", async () => {
+      const clientId = "client123";
+      const call1 = createOutGoingCallDoc({ clientId, status: "completed" });
+      const call2 = createOutGoingCallDoc({ clientId, status: "completed" });
+      const call3 = createOutGoingCallDoc({ clientId, status: "busy" });
 
       // We need to control createdAt to test sort. We'll insert directly.
-      await getCallsCollection().insertOne({ ...call1, createdAt: new Date('2023-01-01'), updatedAt: new Date(), env: 'test' });
-      await getCallsCollection().insertOne({ ...call2, createdAt: new Date('2023-01-02'), updatedAt: new Date(), env: 'test' });
-      await getCallsCollection().insertOne({ ...call3, createdAt: new Date(), updatedAt: new Date(), env: 'test' });
+      await getCallsCollection().insertOne({
+        ...call1,
+        createdAt: new Date("2023-01-01"),
+        updatedAt: new Date(),
+        env: "test",
+      });
+      await getCallsCollection().insertOne({
+        ...call2,
+        createdAt: new Date("2023-01-02"),
+        updatedAt: new Date(),
+        env: "test",
+      });
+      await getCallsCollection().insertOne({
+        ...call3,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+        env: "test",
+      });
 
       const result = await findCallsByQuery(
-        { clientId, status: 'completed' },
-        { sort: { createdAt: -1 }, limit: 1 }
+        { clientId, status: "completed" },
+        { sort: { createdAt: -1 }, limit: 1 },
       );
 
       expect(result.length).toBe(1);
@@ -80,33 +97,154 @@ describe('db.calls', () => {
     });
   });
 
-  describe('countCalls()', () => {
-    it('should count calls matching query', async () => {
-      const clientId = 'countClient';
-      await createCallDoc(createOutGoingCallDoc({ clientId, status: 'completed' }));
-      await createCallDoc(createOutGoingCallDoc({ clientId, status: 'completed' }));
-      await createCallDoc(createOutGoingCallDoc({ clientId, status: 'failed' }));
+  describe("countCalls()", () => {
+    it("should count calls matching query", async () => {
+      const clientId = "countClient";
+      await createCallDoc(
+        createOutGoingCallDoc({ clientId, status: "completed" }),
+      );
+      await createCallDoc(
+        createOutGoingCallDoc({ clientId, status: "completed" }),
+      );
+      await createCallDoc(
+        createOutGoingCallDoc({ clientId, status: "failed" }),
+      );
 
-      const count = await countCalls({ clientId, status: 'completed' });
+      const count = await countCalls({ clientId, status: "completed" });
       expect(count).toBe(2);
     });
   });
 
-  describe('getCallsByClientAndDateRange()', () => {
-    it('should return calls within date range', async () => {
-      const clientId = 'dateRangeClient';
-      const startDate = new Date('2023-05-01');
-      const endDate = new Date('2023-05-31');
+  describe('pushToolExecution()', () => {
+    let callSid: string;
+
+    beforeEach(async () => {
+      const call = createOutGoingCallDoc();
+      await createCallDoc(call);
+      callSid = call.callSid;
+    });
+
+    const makeHttpExecution = (overrides?: Partial<ToolExecution>): ToolExecution => ({
+      toolName: 'sendSms',
+      executedAt: new Date(),
+      durationMs: 120,
+      args: { to: '+1234567890', message: 'hello' },
+      meta: { kind: 'http', url: 'https://api.example.com/sms', method: 'POST' },
+      status: 'success',
+      httpStatus: 200,
+      ...overrides,
+    });
+
+    it('should append an execution to a call with none', async () => {
+      const execution = makeHttpExecution();
+      await pushToolExecution(callSid, execution);
+
+      const result = await getCallByCallSid(callSid);
+      expect(result?.toolExecutions).toHaveLength(1);
+      expect(result?.toolExecutions?.[0]).toMatchObject({
+        toolName: 'sendSms',
+        status: 'success',
+        httpStatus: 200,
+      });
+    });
+
+    it('should maintain insertion order across multiple pushes', async () => {
+      const first = makeHttpExecution({ toolName: 'first' });
+      const second = makeHttpExecution({ toolName: 'second' });
+      const third = makeHttpExecution({ toolName: 'third' });
+
+      await pushToolExecution(callSid, first);
+      await pushToolExecution(callSid, second);
+      await pushToolExecution(callSid, third);
+
+      const result = await getCallByCallSid(callSid);
+      expect(result?.toolExecutions?.map(e => e.toolName)).toEqual(['first', 'second', 'third']);
+    });
+
+    it('should store an internal tool execution', async () => {
+      const execution: ToolExecution = {
+        toolName: 'endFlow',
+        executedAt: new Date(),
+        durationMs: 5,
+        args: {},
+        meta: { kind: 'internal' },
+        status: 'success',
+      };
+
+      await pushToolExecution(callSid, execution);
+
+      const result = await getCallByCallSid(callSid);
+      expect(result?.toolExecutions?.[0]).toMatchObject({
+        toolName: 'endFlow',
+        meta: { kind: 'internal' },
+      });
+    });
+
+    it('should store redacted args for sensitive tools', async () => {
+      const execution = makeHttpExecution({ args: { _redacted: true } });
+      await pushToolExecution(callSid, execution);
+
+      const result = await getCallByCallSid(callSid);
+      expect(result?.toolExecutions?.[0].args).toEqual({ _redacted: true });
+    });
+
+    it('should store an error execution', async () => {
+      const execution = makeHttpExecution({ status: 'error', httpStatus: 500 });
+      await pushToolExecution(callSid, execution);
+
+      const result = await getCallByCallSid(callSid);
+      expect(result?.toolExecutions?.[0]).toMatchObject({ status: 'error', httpStatus: 500 });
+    });
+
+    it('should be a no-op for an unknown callSid', async () => {
+      await expect(pushToolExecution('nonexistent-sid', makeHttpExecution())).resolves.not.toThrow();
+    });
+
+    it('should store the response body', async () => {
+      const execution = makeHttpExecution({
+        response: { userId: '123', status: 'sent' },
+      });
+      await pushToolExecution(callSid, execution);
+
+      const result = await getCallByCallSid(callSid);
+      expect(result?.toolExecutions?.[0].response).toEqual({ userId: '123', status: 'sent' });
+    });
+  });
+
+  describe("getCallsByClientAndDateRange()", () => {
+    it("should return calls within date range", async () => {
+      const clientId = "dateRangeClient";
+      const startDate = new Date("2023-05-01");
+      const endDate = new Date("2023-05-31");
 
       const callInside = createOutGoingCallDoc({ clientId });
       const callBefore = createOutGoingCallDoc({ clientId });
       const callAfter = createOutGoingCallDoc({ clientId });
 
-      await getCallsCollection().insertOne({ ...callInside, createdAt: new Date('2023-05-15'), updatedAt: new Date(), env: 'test' });
-      await getCallsCollection().insertOne({ ...callBefore, createdAt: new Date('2023-04-30'), updatedAt: new Date(), env: 'test' });
-      await getCallsCollection().insertOne({ ...callAfter, createdAt: new Date('2023-06-01'), updatedAt: new Date(), env: 'test' });
-
-      const result = await getCallsByClientAndDateRange(clientId, startDate, endDate);
+      await getCallsCollection().insertOne({
+        ...callInside,
+        createdAt: new Date("2023-05-15"),
+        updatedAt: new Date(),
+        env: "test",
+      });
+      await getCallsCollection().insertOne({
+        ...callBefore,
+        createdAt: new Date("2023-04-30"),
+        updatedAt: new Date(),
+        env: "test",
+      });
+      await getCallsCollection().insertOne({
+        ...callAfter,
+        createdAt: new Date("2023-06-01"),
+        updatedAt: new Date(),
+        env: "test",
+      });
+
+      const result = await getCallsByClientAndDateRange(
+        clientId,
+        startDate,
+        endDate,
+      );
       expect(result.length).toBe(1);
       expect(result[0].callSid).toBe(callInside.callSid);
     });

package/src/talkpilot/calls/calls.getters.ts

@@ -1,11 +1,17 @@
-import { getDb, Call, CallDoc, CallUpdateParams, CallQueryOptions } from '../index';
-import type { CallsByHour, CountOpts, DateRange } from './calls.types';
-import { ObjectId, Filter } from 'mongodb';
-import * as process from 'node:process';
-import { applyQueryOptions } from '../utils/query.utils';
+import {
+  Call,
+  CallDoc,
+  CallQueryOptions,
+  CallUpdateParams,
+  getDb,
+} from "../index";
+import type { CallsByHour, CountOpts, DateRange, ToolExecution } from "./calls.types";
+import { Filter, ObjectId } from "mongodb";
+import * as process from "node:process";
+import { applyQueryOptions } from "../utils/query.utils";
 
 export const getCallsCollection = () => {
-  return getDb().collection<Call>('calls');
+  return getDb().collection<Call>("calls");
 };
 
 export const getCallByCallSid = (callSid: string) => {
@@ -13,7 +19,9 @@ export const getCallByCallSid = (callSid: string) => {
 };
 
 export const getCallsByPhoneNumber = (phoneNumber: string) => {
-  return getCallsCollection().find({ customerPhoneNumber: phoneNumber }).toArray();
+  return getCallsCollection()
+    .find({ customerPhoneNumber: phoneNumber })
+    .toArray();
 };
 
 export const getCallsByClient = (clientId: string) => {
@@ -24,20 +32,22 @@ export const getCallsByFlow = (flowId: ObjectId) => {
   return getCallsCollection().find({ flowId }).toArray();
 };
 
-export const createCallDoc = (call: Omit<Call, 'createdAt' | 'updatedAt' | 'env'>) => {
+export const createCallDoc = (
+  call: Omit<Call, "createdAt" | "updatedAt" | "env">,
+) => {
   return getCallsCollection().insertOne({
     ...call,
     createdAt: new Date(),
     updatedAt: new Date(),
-    env: process.env.ENV ?? 'unknown',
+    env: process.env.ENV ?? "unknown",
   });
 };
 
 export const updateCallByCallSid = async (
   callSid: string,
-  updates: CallUpdateParams
+  updates: CallUpdateParams,
 ): Promise<CallDoc | null> => {
-  const result = await getCallsCollection().findOneAndUpdate(
+  return await getCallsCollection().findOneAndUpdate(
     { callSid: callSid },
     {
       $set: {
@@ -45,15 +55,27 @@ export const updateCallByCallSid = async (
         updatedAt: new Date(),
       },
     },
-    { returnDocument: 'after' }
+    { returnDocument: "after" },
   );
+};
 
-  return result;
+export const pushToolExecution = async (
+  callSid: string,
+  execution: ToolExecution
+): Promise<void> => {
+  await getCallsCollection().updateOne(
+    { callSid },
+    { $push: { toolExecutions: execution } }
+  );
 };
 
 // get calls by client and date range
 //client here is the user id
-export const getCallsByClientAndDateRange = (clientId: string, startDate: Date, endDate: Date) => {
+export const getCallsByClientAndDateRange = (
+  clientId: string,
+  startDate: Date,
+  endDate: Date,
+) => {
   return getCallsCollection()
     .find({
       clientId,
@@ -67,7 +89,7 @@ export const getCallsByClientAndDateRange = (clientId: string, startDate: Date,
 
 export const findCallsByQuery = async (
   query: Filter<Call>,
-  options?: CallQueryOptions
+  options?: CallQueryOptions,
 ): Promise<CallDoc[]> => {
   const cursor = getCallsCollection().find(query);
   return await applyQueryOptions(cursor, options).toArray();
@@ -124,7 +146,7 @@ export const range = {
 
 export function startOfDay(d: Date = new Date()): Date {
   const x = new Date(d);
-  x.setHours(0, 0, 0, 0);
+  x.setUTCHours(0, 0, 0, 0);
   return x;
 }
 
@@ -142,21 +164,29 @@ export async function getCallsStatsForDateRange(
   clientId: string,
   startStr: string,
   endStr: string,
-  timezone: string
+  timezone: string,
 ): Promise<{ count: number; totalLen: number; completed: number }> {
   const coll = getCallsCollection();
   const out = await coll
-    .aggregate<{ _id: null; count: number; totalLen: number; completed: number }>([
+    .aggregate<{
+      _id: null;
+      count: number;
+      totalLen: number;
+      completed: number;
+    }>([
       // 1. Restrict to the given client
       { $match: { clientId } },
       // 2. Derive dateLocal (createdAt as YYYY-MM-DD in timezone) and isCompleted (agentHungUp or status='completed')
       {
         $addFields: {
           dateLocal: {
-            $dateToString: { format: '%Y-%m-%d', date: '$createdAt', timezone },
+            $dateToString: { format: "%Y-%m-%d", date: "$createdAt", timezone },
           },
           isCompleted: {
-            $or: [{ $eq: ['$agentHungUp', true] }, { $eq: ['$status', 'completed'] }],
+            $or: [
+              { $eq: ["$agentHungUp", true] },
+              { $eq: ["$status", "completed"] },
+            ],
           },
         },
       },
@@ -167,8 +197,8 @@ export async function getCallsStatsForDateRange(
         $group: {
           _id: null,
           count: { $sum: 1 },
-          totalLen: { $sum: '$callLength' },
-          completed: { $sum: { $cond: ['$isCompleted', 1, 0] } },
+          totalLen: { $sum: "$callLength" },
+          completed: { $sum: { $cond: ["$isCompleted", 1, 0] } },
         },
       },
     ])
@@ -186,7 +216,7 @@ export async function getCallsStatsForDateRange(
 export async function getCallsHourlyAggregation(
   clientId: string,
   dateStr: string,
-  timezone: string
+  timezone: string,
 ): Promise<CallsByHour[]> {
   const coll = getCallsCollection();
   const rows = await coll
@@ -197,22 +227,22 @@ export async function getCallsHourlyAggregation(
       {
         $addFields: {
           dateLocal: {
-            $dateToString: { format: '%Y-%m-%d', date: '$createdAt', timezone },
+            $dateToString: { format: "%Y-%m-%d", date: "$createdAt", timezone },
           },
-          hour: { $hour: { date: '$createdAt', timezone } },
+          hour: { $hour: { date: "$createdAt", timezone } },
         },
       },
       // 3. Keep only the requested date
       { $match: { dateLocal: dateStr } },
       // 4. Group by hour, sum calls per hour
-      { $group: { _id: '$hour', calls: { $sum: 1 } } },
+      { $group: { _id: "$hour", calls: { $sum: 1 } } },
       // 5. Order by hour ascending (0..23)
       { $sort: { _id: 1 } },
     ])
     .toArray();
 
   return rows.map((r: any) => ({
-    hour: `${String(r._id).padStart(2, '0')}:00`,
+    hour: `${String(r._id).padStart(2, "0")}:00`,
     calls: r.calls,
   }));
 }

package/src/talkpilot/calls/calls.types.ts

@@ -1,8 +1,8 @@
-import { ObjectId, Sort, WithId } from 'mongodb';
-import { TranscriptionSegment } from '../results/results.types';
+import { ObjectId, Sort, WithId } from "mongodb";
+import { TranscriptionSegment } from "../results";
 
-export const CONFERENCE_ROLE_CUSTOMER = 'customer' as const;
-export const CONFERENCE_ROLE_SUPERVISOR = 'supervisor' as const;
+export const CONFERENCE_ROLE_CUSTOMER = "customer" as const;
+export const CONFERENCE_ROLE_SUPERVISOR = "supervisor" as const;
 
 export type ConferenceRole =
   | typeof CONFERENCE_ROLE_CUSTOMER
@@ -38,8 +38,31 @@ export type Call = {
   isConferenceCall?: boolean;
   conferenceRole?: ConferenceRole;
   redirectedCall?: boolean;
+  toolExecutions?: ToolExecution[];
 };
 
+export type ToolExecution = {
+  toolName: string;
+  executedAt: Date;
+  durationMs: number;
+  args: Record<string, unknown> | { _redacted: true };
+  meta: ToolExecutionMeta;
+  status: 'success' | 'error';
+  httpStatus?: number;
+  response?: Record<string, unknown>;
+};
+
+export type ToolExecutionMeta =
+    | {
+  kind: 'http';
+  url: string;
+  method: string;
+  flowToolId?: string;
+  runInBackground?: boolean;
+  sensitive?: boolean;
+}
+    | { kind: 'internal' };
+
 export type CallQueryOptions = {
   sort?: Sort;
   skip?: number;
@@ -62,18 +85,18 @@ export type CallsFilterParams = {
 };
 
 export type ImmutableCallFields =
-  | 'customerPhoneNumber'
-  | 'agentPhoneNumber'
-  | 'isIncomingCall'
-  | 'isOutgoingCall'
-  | 'sessionId'
-  | 'callSid'
-  | 'flowId'
-  | 'clientId'
-  | 'runId'
-  | 'resultId'
-  | 'env'
-  | 'createdAt';
+  | "customerPhoneNumber"
+  | "agentPhoneNumber"
+  | "isIncomingCall"
+  | "isOutgoingCall"
+  | "sessionId"
+  | "callSid"
+  | "flowId"
+  | "clientId"
+  | "runId"
+  | "resultId"
+  | "env"
+  | "createdAt";
 
 export type CallUpdateParams = Partial<Omit<Call, ImmutableCallFields>>;
 

package/src/talkpilot/calls/index.ts

@@ -1,2 +1,2 @@
-export * from './calls.types';
-export * from './calls.getters';
+export * from "./calls.types";
+export * from "./calls.getters";