@talkpilot/core-db 1.1.6 → 1.1.8

package/src/talkpilot/clientsConfig/clientsConfig.types.ts

@@ -1,4 +1,4 @@
-import { WithId } from "mongodb";
+import { WithId } from 'mongodb';
 
 export type InitiateCallForShortSlaConfig = {
   active: boolean;
@@ -35,16 +35,16 @@ export type Products = {
 export type ClinicsProduct = {
   api_key_secret_name: string;
   base_api_url: string;
-  provider: "clinix" | (string & {});
+  provider: 'clinix' | (string & {});
   description?: string;
 };
 
 export type ClientLanguageName =
-  | "Hebrew"
-  | "English"
-  | "Russian"
-  | "French"
-  | "Spanish"
+  | 'Hebrew'
+  | 'English'
+  | 'Russian'
+  | 'French'
+  | 'Spanish'
   | (string & {});
 
 export type SendGridConfig = {
@@ -72,6 +72,4 @@ export type ClientConfig<P extends Products = Products> = {
   communications?: CommunicationsConfig;
 };
 
-export type ClientConfigDoc<P extends Products = Products> = WithId<
-  ClientConfig<P>
->;
+export type ClientConfigDoc<P extends Products = Products> = WithId<ClientConfig<P>>;

package/src/talkpilot/clientsConfig/index.ts

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

package/src/talkpilot/flows/__tests__/flows.schema.spec.ts

@@ -1,64 +1,63 @@
-import { flowMongoSchema } from "../flows.schema";
+import { flowMongoSchema } from '../flows.schema';
 
-describe("flowMongoSchema", () => {
-  it("defines conversationSettings as optional object or null", () => {
+describe('flowMongoSchema', () => {
+  it('defines conversationSettings as optional object or null', () => {
     const schema: any = flowMongoSchema;
 
-    expect(schema.properties).toHaveProperty("conversationSettings");
-    expect(schema.properties.conversationSettings.bsonType).toEqual([
-      "object",
-      "null",
-    ]);
-    expect(schema.required).not.toContain("conversationSettings");
+    expect(schema.properties).toHaveProperty('conversationSettings');
+    expect(schema.properties.conversationSettings.bsonType).toEqual(['object', 'null']);
+    expect(schema.required).not.toContain('conversationSettings');
     expect(schema.additionalProperties).toBe(false);
   });
 
-  it("defines conversationSettings with expected nested properties", () => {
+  it('defines conversationSettings with expected nested properties', () => {
     const schema: any = flowMongoSchema;
     const convSettings = schema.properties.conversationSettings.properties;
 
-    expect(convSettings).toHaveProperty("interruptions");
-    expect(convSettings.interruptions.bsonType).toEqual(["object", "null"]);
+    expect(convSettings).toHaveProperty('interruptions');
+    expect(convSettings.interruptions.bsonType).toEqual(['object', 'null']);
 
     const interruptions = convSettings.interruptions.properties;
-    expect(interruptions.enableInterruptionDetection.bsonType).toEqual("bool");
-    expect(interruptions.interruptionWindowSeconds.bsonType).toEqual("number");
-    expect(interruptions.interruptionThresholdSeconds.bsonType).toEqual(
-      "number",
-    );
-    expect(interruptions.interruptionInstruction.bsonType).toEqual("string");
+    expect(interruptions.enableInterruptionDetection.bsonType).toEqual('bool');
+    expect(interruptions.interruptionWindowSeconds.bsonType).toEqual('number');
+    expect(interruptions.interruptionThresholdSeconds.bsonType).toEqual('number');
+    expect(interruptions.interruptionInstruction.bsonType).toEqual('string');
 
-    expect(convSettings).toHaveProperty("silence");
-    expect(convSettings.silence.bsonType).toEqual(["object", "null"]);
+    expect(convSettings).toHaveProperty('silence');
+    expect(convSettings.silence.bsonType).toEqual(['object', 'null']);
 
     const silence = convSettings.silence.properties;
-    expect(silence.enableSilenceDetection.bsonType).toEqual("bool");
-    expect(silence.firstWarningSilenceSeconds.bsonType).toEqual("number");
-    expect(silence.firstWarningInstruction.bsonType).toEqual("string");
-    expect(silence.secondWarningSilenceSeconds.bsonType).toEqual("number");
-    expect(silence.secondWarningInstruction.bsonType).toEqual("string");
-    expect(silence.disconnectSilenceSeconds.bsonType).toEqual("number");
-    expect(convSettings).toHaveProperty("liveTimeUpdates");
-    expect(convSettings.liveTimeUpdates.bsonType).toEqual("bool");
+    expect(silence.enableSilenceDetection.bsonType).toEqual('bool');
+    expect(silence.firstWarningSilenceSeconds.bsonType).toEqual('number');
+    expect(silence.firstWarningInstruction.bsonType).toEqual('string');
+    expect(silence.secondWarningSilenceSeconds.bsonType).toEqual('number');
+    expect(silence.secondWarningInstruction.bsonType).toEqual('string');
+    expect(silence.disconnectSilenceSeconds.bsonType).toEqual('number');
+    expect(convSettings).toHaveProperty('liveTimeUpdates');
+    expect(convSettings.liveTimeUpdates.bsonType).toEqual('bool');
   });
 
-  it("should define tools schema and return a backgroundToolType enum with allowed values", () => {
+  it('should define tools schema and return a backgroundToolType enum with allowed values', () => {
     const schema: any = flowMongoSchema;
 
-    expect(schema.properties).toHaveProperty("tools");
-    expect(schema.properties.tools.bsonType).toEqual(["array", "null"]);
+    expect(schema.properties).toHaveProperty('tools');
+    expect(schema.properties.tools.bsonType).toEqual(['array', 'null']);
 
     const toolItem = schema.properties.tools.items;
-    expect(toolItem.bsonType).toBe("object");
+    expect(toolItem.bsonType).toBe('object');
 
-    expect(toolItem.properties).toHaveProperty("runInBackground");
-    expect(toolItem.properties.runInBackground.bsonType).toBe("bool");
+    expect(toolItem.properties).toHaveProperty('runInBackground');
+    expect(toolItem.properties.runInBackground.bsonType).toBe('bool');
 
-    expect(toolItem.properties).toHaveProperty("backgroundToolType");
-    expect(toolItem.properties.backgroundToolType.bsonType).toBe("string");
+    expect(toolItem.properties).toHaveProperty('backgroundToolType');
+    expect(toolItem.properties.backgroundToolType.bsonType).toBe('string');
     expect(toolItem.properties.backgroundToolType.enum).toEqual([
-      "backgroundToolAlways",
-      "backgroundToolOnce",
+      'backgroundToolAlways',
+      'backgroundToolOnce',
     ]);
+
+    expect(toolItem.properties).toHaveProperty('backgroundContinuationInstructions');
+    expect(toolItem.properties.backgroundContinuationInstructions.bsonType).toBe('string');
   });
 });
+

package/src/talkpilot/flows/flows.getter.ts

@@ -1,14 +1,11 @@
-import type { Collection, ObjectId, WithId } from "mongodb";
-import { getDb } from "../index";
-import type { Flow } from "./flows.types";
+import type { Collection, ObjectId, WithId } from 'mongodb';
+import { getDb } from '../index';
+import type { Flow } from './flows.types';
 
 export const getFlowsCollection = (): Collection<Flow> => {
-  return getDb().collection<Flow>("flows");
+  return getDb().collection<Flow>('flows');
 };
 
-export const findFlowById = (
-  flowId: ObjectId,
-  clientId: string,
-): Promise<WithId<Flow> | null> => {
+export const findFlowById = (flowId: ObjectId, clientId: string): Promise<WithId<Flow> | null> => {
   return getFlowsCollection().findOne({ _id: flowId, clientId });
 };

package/src/talkpilot/flows/flows.schema.ts

@@ -1,148 +1,141 @@
 export const flowMongoSchema = {
-  bsonType: "object",
-  required: [
-    "flowName",
-    "systemInstructions",
-    "initialSentence",
-    "interactions",
-  ],
+  bsonType: 'object',
+  required: ['flowName', 'systemInstructions', 'initialSentence', 'interactions'],
   properties: {
-    _id: { bsonType: "objectId" },
-    flowName: { bsonType: "string" },
-    clientId: { bsonType: "string" },
-    systemInstructions: { bsonType: "string" },
-    initialSentence: { bsonType: "string" },
-    voice: { bsonType: ["string", "null"] },
+    _id: { bsonType: 'objectId' },
+    flowName: { bsonType: 'string' },
+    clientId: { bsonType: 'string' },
+    systemInstructions: { bsonType: 'string' },
+    initialSentence: { bsonType: 'string' },
+    voice: { bsonType: ['string', 'null'] },
     conversationSettings: {
-      bsonType: ["object", "null"],
+      bsonType: ['object', 'null'],
       properties: {
         interruptions: {
-          bsonType: ["object", "null"],
+          bsonType: ['object', 'null'],
           properties: {
-            enableInterruptionDetection: { bsonType: "bool" },
-            interruptionWindowSeconds: { bsonType: "number" },
-            interruptionThresholdSeconds: { bsonType: "number" },
-            interruptionInstruction: { bsonType: "string" },
+            enableInterruptionDetection: { bsonType: 'bool' },
+            interruptionWindowSeconds: { bsonType: 'number' },
+            interruptionThresholdSeconds: { bsonType: 'number' },
+            interruptionInstruction: { bsonType: 'string' },
           },
           additionalProperties: false,
         },
         silence: {
-          bsonType: ["object", "null"],
+          bsonType: ['object', 'null'],
           properties: {
-            enableSilenceDetection: { bsonType: "bool" },
-            firstWarningSilenceSeconds: { bsonType: "number" },
-            firstWarningInstruction: { bsonType: "string" },
-            secondWarningSilenceSeconds: { bsonType: "number" },
-            secondWarningInstruction: { bsonType: "string" },
-            disconnectSilenceSeconds: { bsonType: "number" },
+            enableSilenceDetection: { bsonType: 'bool' },
+            firstWarningSilenceSeconds: { bsonType: 'number' },
+            firstWarningInstruction: { bsonType: 'string' },
+            secondWarningSilenceSeconds: { bsonType: 'number' },
+            secondWarningInstruction: { bsonType: 'string' },
+            disconnectSilenceSeconds: { bsonType: 'number' },
           },
           additionalProperties: false,
         },
-        liveTimeUpdates: { bsonType: "bool" },
+        liveTimeUpdates: { bsonType: 'bool' },
       },
       additionalProperties: false,
     },
     interactions: {
-      bsonType: "array",
+      bsonType: 'array',
       items: {
-        bsonType: "object",
-        required: ["id", "type", "text", "position"],
+        bsonType: 'object',
+        required: ['id', 'type', 'text', 'position'],
         properties: {
-          id: { bsonType: "string" },
-          type: { bsonType: "string" },
-          text: { bsonType: "string" },
-          successStatus: { bsonType: ["string", "null"] },
+          id: { bsonType: 'string' },
+          type: { bsonType: 'string' },
+          text: { bsonType: 'string' },
+          successStatus: { bsonType: ['string', 'null'] },
           conditions: {
-            bsonType: ["array", "null"],
+            bsonType: ['array', 'null'],
             items: {
-              bsonType: "object",
-              required: ["conditionString"],
+              bsonType: 'object',
+              required: ['conditionString'],
               properties: {
-                conditionString: { bsonType: "string" },
-                nodeType: { bsonType: ["string", "null"] },
-                id: { bsonType: ["string", "null"] },
+                conditionString: { bsonType: 'string' },
+                nodeType: { bsonType: ['string', 'null'] },
+                id: { bsonType: ['string', 'null'] },
               },
             },
           },
-          defaultNodeType: { bsonType: ["string", "null"] },
+          defaultNodeType: { bsonType: ['string', 'null'] },
           defaultChild: {
-            bsonType: ["object", "null"],
-            properties: { id: { bsonType: "string" } },
+            bsonType: ['object', 'null'],
+            properties: { id: { bsonType: 'string' } },
           },
           position: {
-            bsonType: "object",
-            required: ["x", "y"],
+            bsonType: 'object',
+            required: ['x', 'y'],
             properties: {
-              x: { bsonType: "number" },
-              y: { bsonType: "number" },
+              x: { bsonType: 'number' },
+              y: { bsonType: 'number' },
             },
           },
-          name: { bsonType: ["string", "null"] },
-          children: {
-            bsonType: ["array", "null"],
-            items: { bsonType: "string" },
-          },
-          resultsLabel: { bsonType: ["string", "null"] },
-          resultsColor: { bsonType: ["string", "null"] },
+          name: { bsonType: ['string', 'null'] },
+          children: { bsonType: ['array', 'null'], items: { bsonType: 'string' } },
+          resultsLabel: { bsonType: ['string', 'null'] },
+          resultsColor: { bsonType: ['string', 'null'] },
         },
       },
     },
     edges: {
-      bsonType: ["array", "null"],
+      bsonType: ['array', 'null'],
       items: {
-        bsonType: "object",
-        required: ["id", "source", "target"],
+        bsonType: 'object',
+        required: ['id', 'source', 'target'],
         properties: {
-          id: { bsonType: "string" },
-          source: { bsonType: "string" },
-          target: { bsonType: "string" },
-          label: { bsonType: ["string", "null"] },
+          id: { bsonType: 'string' },
+          source: { bsonType: 'string' },
+          target: { bsonType: 'string' },
+          label: { bsonType: ['string', 'null'] },
         },
       },
     },
     metaKeys: {
-      bsonType: ["array", "null"],
+      bsonType: ['array', 'null'],
       items: {
-        bsonType: "object",
-        required: ["key"],
+        bsonType: 'object',
+        required: ['key'],
         properties: {
-          key: { bsonType: "string" },
-          required: { bsonType: "bool" },
+          key: { bsonType: 'string' },
+          required: { bsonType: 'bool' },
         },
       },
     },
     userProperties: {
-      bsonType: ["array", "null"],
+      bsonType: ['array', 'null'],
       items: {
-        bsonType: "object",
-        required: ["name", "description"],
+        bsonType: 'object',
+        required: ['name', 'description'],
         properties: {
-          name: { bsonType: "string" },
-          description: { bsonType: "string" },
+          name: { bsonType: 'string' },
+          description: { bsonType: 'string' },
         },
       },
     },
     tools: {
-      bsonType: ["array", "null"],
+      bsonType: ['array', 'null'],
       items: {
-        bsonType: "object",
-        required: ["id", "name", "url", "method", "parameters"],
+        bsonType: 'object',
+        required: ['id', 'name', 'url', 'method', 'parameters'],
         properties: {
-          id: { bsonType: "string" },
-          name: { bsonType: "string" },
-          description: { bsonType: "string" },
-          url: { bsonType: "string" },
-          method: { bsonType: "string" },
-          headers: { bsonType: "object" },
-          parameters: { bsonType: "object" },
-          bodyFormat: { bsonType: "string", enum: ["json", "form-data"] },
-          preventAudioDuringTool: { bsonType: "bool" },
-          sendUserAuthToken: { bsonType: "bool" },
-          runInBackground: { bsonType: "bool" },
+          id: { bsonType: 'string' },
+          name: { bsonType: 'string' },
+          description: { bsonType: 'string' },
+          url: { bsonType: 'string' },
+          method: { bsonType: 'string' },
+          headers: { bsonType: 'object' },
+          parameters: { bsonType: 'object' },
+          bodyFormat: { bsonType: 'string', enum: ['json', 'form-data'] },
+          preventAudioDuringTool: { bsonType: 'bool' },
+          sendUserAuthToken: { bsonType: 'bool' },
+          runInBackground: { bsonType: 'bool' },
           backgroundToolType: {
-            bsonType: "string",
-            enum: ["backgroundToolAlways", "backgroundToolOnce"],
+            bsonType: 'string',
+            enum: ['backgroundToolAlways', 'backgroundToolOnce'],
           },
+          backgroundContinuationInstructions: { bsonType: 'string' },
         },
         additionalProperties: false,
       },

package/src/talkpilot/flows/flows.types.ts

@@ -1,12 +1,12 @@
-import { ObjectId } from "mongodb";
+import { ObjectId } from 'mongodb';
 
 /* ----------  Basic helpers  ---------- */
 
 export type Position = { x: number; y: number };
-export type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
 
-export type QuestionType = "open" | "multiple" | "table";
-export type SelectionType = "single" | "multiple";
+export type QuestionType = 'open' | 'multiple' | 'table';
+export type SelectionType = 'single' | 'multiple';
 
 export type Question = {
   id: string;
@@ -24,14 +24,14 @@ export type Question = {
 };
 
 export type NodeKind =
-  | "start"
-  | "say"
-  | "condition"
-  | "improvise"
-  | "tool"
-  | "sendMessage"
-  | "questionsList"
-  | "end";
+  | 'start'
+  | 'say'
+  | 'condition'
+  | 'improvise'
+  | 'tool'
+  | 'sendMessage'
+  | 'questionsList'
+  | 'end';
 type BaseNode = {
   id: string;
   type: NodeKind;
@@ -44,12 +44,12 @@ type BaseNode = {
   questions?: Question[] | null;
 };
 
-export type StartNode = BaseNode & { type: "start" };
+export type StartNode = BaseNode & { type: 'start' };
 
-export type SayNode = BaseNode & { type: "say" };
+export type SayNode = BaseNode & { type: 'say' };
 
 export type ConditionNode = BaseNode & {
-  type: "condition";
+  type: 'condition';
   conditions: Array<{
     conditionString: string;
     nodeType?: string | null;
@@ -59,7 +59,7 @@ export type ConditionNode = BaseNode & {
   defaultChild?: { id?: string } | null;
 };
 
-export type ImproviseNode = BaseNode & { type: "improvise" };
+export type ImproviseNode = BaseNode & { type: 'improvise' };
 
 export type FlowTool = {
   id: string;
@@ -69,17 +69,18 @@ export type FlowTool = {
   method: HttpMethod;
   headers?: Record<string, string>;
   parameters: Record<string, unknown>;
-  bodyFormat?: "json" | "form-data";
+  bodyFormat?: 'json' | 'form-data';
   preventAudioDuringTool?: boolean;
   sendUserAuthToken?: boolean;
   runInBackground?: boolean;
-  backgroundToolType?: "backgroundToolAlways" | "backgroundToolOnce";
+  backgroundToolType?: 'backgroundToolAlways' | 'backgroundToolOnce';
+  backgroundContinuationInstructions?: string;
 };
 
-export type SendMethod = "sms" | "whatsapp";
+export type SendMethod = 'sms' | 'whatsapp';
 
 export type SendMessageNode = BaseNode & {
-  type: "sendMessage";
+  type: 'sendMessage';
   /** Which channel to use. If omitted, decide at runtime (e.g., default to whatsapp). */
   send_method: SendMethod;
   /** Destination phone (E.164 or templated string like "{{userPhone}}"). */
@@ -87,17 +88,17 @@ export type SendMessageNode = BaseNode & {
 };
 
 export type ToolNode = BaseNode & {
-  type: "tool";
+  type: 'tool';
   name: string;
   text: string;
 };
 
 export type QuestionsListNode = BaseNode & {
-  type: "questionsList";
+  type: 'questionsList';
   questions: Question[];
 };
 
-export type EndNode = BaseNode & { type: "end" };
+export type EndNode = BaseNode & { type: 'end' };
 
 export type Interaction =
   | StartNode

package/src/talkpilot/flows/index.ts

@@ -1,2 +1,2 @@
-export { getFlowsCollection, findFlowById } from "./flows.getter";
-export type * from "./flows.types";
+export { getFlowsCollection, findFlowById } from './flows.getter';
+export type * from './flows.types';

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

@@ -1,30 +1,27 @@
-import { ObjectId } from "mongodb";
-import { faker } from "@faker-js/faker";
+import { ObjectId } from 'mongodb';
+import { faker } from '@faker-js/faker';
 import {
   getGroupsCollection,
   findGroups,
   createGroup,
   updateGroup,
   removeGroup,
-} from "../groups.getters";
-import { createGroup as createGroupDoc } from "../../../test-utils/factories";
+} from '../groups.getters';
+import { createGroup as createGroupDoc } from '../../../test-utils/factories';
 
-describe("db.groups", () => {
-  describe("getGroupsCollection", () => {
+describe('db.groups', () => {
+  describe('getGroupsCollection', () => {
     it('returns the "groups" collection', () => {
-      expect(getGroupsCollection().collectionName).toBe("groups");
+      expect(getGroupsCollection().collectionName).toBe('groups');
     });
   });
 
-  describe("findGroups", () => {
-    it("returns groups matching the provided filter", async () => {
+  describe('findGroups', () => {
+    it('returns groups matching the provided filter', async () => {
       const clientId = faker.string.uuid();
-      const g1 = createGroupDoc({ clientId, name: "Group A" });
-      const g2 = createGroupDoc({ clientId, name: "Group B" });
-      const gOther = createGroupDoc({
-        clientId: faker.string.uuid(),
-        name: "Group C",
-      });
+      const g1 = createGroupDoc({ clientId, name: 'Group A' });
+      const g2 = createGroupDoc({ clientId, name: 'Group B' });
+      const gOther = createGroupDoc({ clientId: faker.string.uuid(), name: 'Group C' });
 
       await getGroupsCollection().insertMany([g1, g2, gOther]);
 
@@ -32,29 +29,26 @@ describe("db.groups", () => {
       const names = result.map((g) => g.name).sort();
 
       expect(result).toHaveLength(2);
-      expect(names).toEqual(["Group A", "Group B"]);
+      expect(names).toEqual(['Group A', 'Group B']);
     });
   });
 
-  describe("createGroup", () => {
-    it("inserts a group and returns insertedId", async () => {
-      const toInsert = createGroupDoc({ name: "New Group" });
+  describe('createGroup', () => {
+    it('inserts a group and returns insertedId', async () => {
+      const toInsert = createGroupDoc({ name: 'New Group' });
 
       const insertedId = await createGroup(toInsert);
       expect(insertedId).toBeInstanceOf(ObjectId);
 
       const fromDb = await getGroupsCollection().findOne({ _id: insertedId });
-      expect(fromDb?.name).toBe("New Group");
+      expect(fromDb?.name).toBe('New Group');
       expect(fromDb?.clientId).toBe(toInsert.clientId);
     });
   });
 
-  describe("updateGroup", () => {
-    it("updates the group and sets updatedAt, returning the updated document", async () => {
-      const original = createGroupDoc({
-        name: "Before",
-        description: "Old desc",
-      });
+  describe('updateGroup', () => {
+    it('updates the group and sets updatedAt, returning the updated document', async () => {
+      const original = createGroupDoc({ name: 'Before', description: 'Old desc' });
       const { insertedId } = await getGroupsCollection().insertOne(original);
       const before = await getGroupsCollection().findOne({ _id: insertedId });
 
@@ -63,22 +57,21 @@ describe("db.groups", () => {
 
       const res = await updateGroup(
         { _id: insertedId },
-        { name: "After", description: "New desc" },
+        { name: 'After', description: 'New desc' }
       );
 
       expect(res?._id).toEqual(insertedId);
-      expect(res?.name).toBe("After");
-      expect(res?.description).toBe("New desc");
+      expect(res?.name).toBe('After');
+      expect(res?.description).toBe('New desc');
       expect(new Date(res!.updatedAt).getTime()).toBeGreaterThan(
-        new Date(before!.updatedAt).getTime(),
+        new Date(before!.updatedAt).getTime()
       );
     });
   });
 
-  describe("removeGroup", () => {
-    it("removes a group by string id", async () => {
-      const { insertedId } =
-        await getGroupsCollection().insertOne(createGroupDoc());
+  describe('removeGroup', () => {
+    it('removes a group by string id', async () => {
+      const { insertedId } = await getGroupsCollection().insertOne(createGroupDoc());
 
       const result = await removeGroup(insertedId.toHexString());
       expect(result.deletedCount).toBe(1);