@nyaruka/temba-components 0.129.10 → 0.129.11

package/src/live/ContactChat.ts

@@ -27,6 +27,7 @@ import {
   ContactGroupsEvent,
   ContactHistoryPage,
   ContactLanguageChangedEvent,
+  ContactStatusChangedEvent,
   MsgEvent,
   NameChangedEvent,
   OptInEvent,
@@ -61,6 +62,7 @@ export enum Events {
   CONTACT_GROUPS_CHANGED = 'contact_groups_changed',
   CONTACT_LANGUAGE_CHANGED = 'contact_language_changed',
   CONTACT_NAME_CHANGED = 'contact_name_changed',
+  CONTACT_STATUS_CHANGED = 'contact_status_changed',
   CONTACT_URNS_CHANGED = 'contact_urns_changed',
   IVR_CREATED = 'ivr_created',
   MSG_CREATED = 'msg_created',
@@ -97,28 +99,10 @@ const renderInfoList = (singular: string, plural: string, items: any[]) => {
 };
 
 const renderChannelEvent = (event: ChannelEvent): string => {
-  if (event.event.type === 'mt_miss') {
-    return 'Missed outgoing call';
-  } else if (event.event.type === 'mo_miss') {
-    return 'Missed incoming call';
-  } else if (event.event.type === 'new_conversation') {
-    return 'Started conversation';
-  } else if (event.channel_event_type === 'welcome_message') {
-    return 'Welcome Message Sent';
-  } else if (event.event.type === 'referral') {
-    return 'Referred';
-  } else if (event.event.type === 'follow') {
-    return 'Followed';
+  if (event.channel_event_type === 'welcome_message') {
+    return 'Welcome message sent';
   } else if (event.event.type === 'stop_contact') {
     return 'Stopped';
-  } else if (event.event.type === 'mt_call') {
-    return 'Outgoing Phone Call'; // deprecated
-  } else if (event.event.type == 'mo_call') {
-    return 'Incoming Phone call'; // deprecated
-  } else if (event.event.type == 'optin') {
-    return `Opted in to **${event.event.optin?.name}**`; // deprecated
-  } else if (event.event.type == 'optout') {
-    return `Opted out of **${event.event.optin?.name}**`; // deprecated
   }
 };
 
@@ -220,6 +204,12 @@ export const renderContactLanguageChangedEvent = (
   return `Language updated to **${event.language}**`;
 };
 
+export const renderContactStatusChangedEvent = (
+  event: ContactStatusChangedEvent
+): string => {
+  return `Status updated to **${event.status}**`;
+};
+
 export const renderCallEvent = (event: CallEvent): string => {
   if (event.type === Events.CALL_CREATED) {
     return `Call started`;
@@ -232,7 +222,7 @@ export const renderCallEvent = (event: CallEvent): string => {
 
 export const renderOptInEvent = (event: OptInEvent): string => {
   if (event.type === Events.OPTIN_REQUESTED) {
-    return `Requested opt-in for ${event.optin.name}`;
+    return `Requested opt-in for **${event.optin.name}**`;
   } else if (event.type === Events.OPTIN_STARTED) {
     return `Opted in to **${event.optin.name}**`;
   } else if (event.type === Events.OPTIN_STOPPED) {
@@ -632,53 +622,58 @@ export class ContactChat extends ContactStoreElement {
   public getEventMessage(event: ContactEvent): ChatEvent {
     let message = null;
     switch (event.type) {
-      case Events.TICKET_OPENED:
+      case Events.AIRTIME_TRANSFERRED:
         message = {
           type: MessageType.Inline,
-          text: renderTicketAction(event as TicketEvent, 'opened')
+          text: renderAirtimeTransferredEvent(event as AirtimeTransferredEvent)
         };
         break;
-      case Events.TICKET_ASSIGNED:
+      case Events.CALL_CREATED:
+      case Events.CALL_MISSED:
+      case Events.CALL_RECEIVED:
         message = {
           type: MessageType.Inline,
-          text: renderTicketAssigned(event as TicketEvent)
+          text: renderCallEvent(event as CallEvent)
         };
         break;
-      case Events.TICKET_REOPENED:
+      case Events.CHAT_STARTED:
         message = {
           type: MessageType.Inline,
-          text: renderTicketAction(event as TicketEvent, 'reopened')
+          text: renderChatStartedEvent(event as ChatStartedEvent)
         };
         break;
-      case Events.TICKET_CLOSED:
+      case Events.CONTACT_FIELD_CHANGED:
         message = {
           type: MessageType.Inline,
-          text: renderTicketAction(event as TicketEvent, 'closed')
+          text: renderUpdateEvent(event as UpdateFieldEvent)
         };
         break;
-      case Events.TICKET_TOPIC_CHANGED:
+      case Events.CONTACT_GROUPS_CHANGED:
         message = {
           type: MessageType.Inline,
-          text: `Topic changed to **${(event as TicketEvent).topic.name}**`
+          text: renderContactGroupsEvent(event as ContactGroupsEvent)
         };
         break;
-      case Events.RUN_STARTED:
-      case Events.RUN_ENDED:
+      case Events.CONTACT_LANGUAGE_CHANGED:
         message = {
           type: MessageType.Inline,
-          text: renderRunEvent(event as RunEvent)
+          text: renderContactLanguageChangedEvent(
+            event as ContactLanguageChangedEvent
+          )
         };
         break;
-      case Events.CONTACT_FIELD_CHANGED:
+      case Events.CONTACT_NAME_CHANGED:
         message = {
           type: MessageType.Inline,
-          text: renderUpdateEvent(event as UpdateFieldEvent)
+          text: renderNameChanged(event as NameChangedEvent)
         };
         break;
-      case Events.CONTACT_NAME_CHANGED:
+      case Events.CONTACT_STATUS_CHANGED:
         message = {
           type: MessageType.Inline,
-          text: renderNameChanged(event as NameChangedEvent)
+          text: renderContactStatusChangedEvent(
+            event as ContactStatusChangedEvent
+          )
         };
         break;
       case Events.CONTACT_URNS_CHANGED:
@@ -687,52 +682,55 @@ export class ContactChat extends ContactStoreElement {
           text: renderContactURNsChanged(event as URNsChangedEvent)
         };
         break;
-      case Events.CONTACT_GROUPS_CHANGED:
+      case Events.OPTIN_REQUESTED:
+      case Events.OPTIN_STARTED:
+      case Events.OPTIN_STOPPED:
         message = {
           type: MessageType.Inline,
-          text: renderContactGroupsEvent(event as ContactGroupsEvent)
+          text: renderOptInEvent(event as OptInEvent)
         };
         break;
-      case Events.AIRTIME_TRANSFERRED:
+      case Events.RUN_STARTED:
+      case Events.RUN_ENDED:
         message = {
           type: MessageType.Inline,
-          text: renderAirtimeTransferredEvent(event as AirtimeTransferredEvent)
+          text: renderRunEvent(event as RunEvent)
         };
         break;
-      case Events.CALL_CREATED:
-      case Events.CALL_MISSED:
-      case Events.CALL_RECEIVED:
+      case Events.TICKET_ASSIGNED:
         message = {
           type: MessageType.Inline,
-          text: renderCallEvent(event as CallEvent)
+          text: renderTicketAssigned(event as TicketEvent)
         };
         break;
-      case Events.CHANNEL_EVENT:
+      case Events.TICKET_CLOSED:
         message = {
           type: MessageType.Inline,
-          text: renderChannelEvent(event as ChannelEvent)
+          text: renderTicketAction(event as TicketEvent, 'closed')
         };
         break;
-      case Events.CHAT_STARTED:
+      case Events.TICKET_OPENED:
         message = {
           type: MessageType.Inline,
-          text: renderChatStartedEvent(event as ChatStartedEvent)
+          text: renderTicketAction(event as TicketEvent, 'opened')
         };
         break;
-      case Events.CONTACT_LANGUAGE_CHANGED:
+      case Events.TICKET_REOPENED:
         message = {
           type: MessageType.Inline,
-          text: renderContactLanguageChangedEvent(
-            event as ContactLanguageChangedEvent
-          )
+          text: renderTicketAction(event as TicketEvent, 'reopened')
         };
         break;
-      case Events.OPTIN_REQUESTED:
-      case Events.OPTIN_STARTED:
-      case Events.OPTIN_STOPPED:
+      case Events.TICKET_TOPIC_CHANGED:
         message = {
           type: MessageType.Inline,
-          text: renderOptInEvent(event as OptInEvent)
+          text: `Topic changed to **${(event as TicketEvent).topic.name}**`
+        };
+        break;
+      case Events.CHANNEL_EVENT: // deprecated
+        message = {
+          type: MessageType.Inline,
+          text: renderChannelEvent(event as ChannelEvent)
         };
         break;
     }

package/src/store/flow-definition.d.ts

@@ -175,7 +175,8 @@ export interface CallLLM extends Action {
   llm: NamedObject;
   instructions: string;
   input: string;
-  result_name: string;
+  result_name?: string;
+  output_local?: string;
 }
 
 export interface OpenTicket extends Action {

package/src/utils.ts

@@ -932,3 +932,195 @@ export const getMiddle = (a: DOMRect, b: DOMRect) => {
 
 // Export the UUID function from the uuid package
 export { generateUUID };
+
+// Helper types for router creation
+export interface RouterCategory {
+  uuid: string;
+  name: string;
+  exit_uuid: string;
+}
+
+export interface RouterExit {
+  uuid: string;
+  destination_uuid: string | null;
+}
+
+export interface RouterCase {
+  uuid: string;
+  type: string;
+  arguments: string[];
+  category_uuid: string;
+}
+
+export interface CreateCategoryParams {
+  name: string;
+  existingCategories: any[];
+  existingExits: any[];
+  existingCases?: any[];
+  caseConfig?: {
+    type: string;
+    arguments: string[];
+  };
+}
+
+// Helper function to create or preserve a category with its exit and case
+export const createOrPreserveCategory = (
+  params: CreateCategoryParams
+): {
+  category: RouterCategory;
+  exit: RouterExit;
+  case?: RouterCase;
+} => {
+  const { name, existingCategories, existingExits, existingCases, caseConfig } =
+    params;
+
+  // Find existing category
+  const existingCategory = existingCategories.find((cat) => cat.name === name);
+  const existingExit = existingCategory
+    ? existingExits.find((exit) => exit.uuid === existingCategory.exit_uuid)
+    : null;
+  const existingCase =
+    existingCategory && existingCases
+      ? existingCases.find(
+          (case_) => case_.category_uuid === existingCategory.uuid
+        )
+      : null;
+
+  // Use existing UUIDs or generate new ones
+  const categoryUuid = existingCategory?.uuid || generateUUID();
+  const exitUuid = existingExit?.uuid || generateUUID();
+  const caseUuid = existingCase?.uuid || generateUUID();
+
+  const category: RouterCategory = {
+    uuid: categoryUuid,
+    name: name,
+    exit_uuid: exitUuid
+  };
+
+  const exit: RouterExit = {
+    uuid: exitUuid,
+    destination_uuid: existingExit?.destination_uuid || null
+  };
+
+  const result: {
+    category: RouterCategory;
+    exit: RouterExit;
+    case?: RouterCase;
+  } = { category, exit };
+
+  if (caseConfig) {
+    result.case = {
+      uuid: caseUuid,
+      type: caseConfig.type,
+      arguments: caseConfig.arguments,
+      category_uuid: categoryUuid
+    };
+  }
+
+  return result;
+};
+
+// Helper function to create a complete router with standard Success/Failure categories
+export const createSuccessFailureRouter = (
+  operand: string,
+  successCaseConfig: { type: string; arguments: string[] },
+  existingCategories: any[] = [],
+  existingExits: any[] = [],
+  existingCases: any[] = []
+) => {
+  const success = createOrPreserveCategory({
+    name: 'Success',
+    existingCategories,
+    existingExits,
+    existingCases,
+    caseConfig: successCaseConfig
+  });
+
+  const failure = createOrPreserveCategory({
+    name: 'Failure',
+    existingCategories,
+    existingExits
+  });
+
+  return {
+    router: {
+      type: 'switch' as const,
+      categories: [success.category, failure.category],
+      default_category_uuid: failure.category.uuid,
+      operand: operand,
+      cases: success.case ? [success.case] : []
+    },
+    exits: [success.exit, failure.exit]
+  };
+};
+
+// Helper function to create a multi-category router with Other/Failure defaults
+export const createMultiCategoryRouter = (
+  operand: string,
+  userCategories: string[],
+  categoryToCaseMap: (categoryName: string) => {
+    type: string;
+    arguments: string[];
+  },
+  existingCategories: any[] = [],
+  existingExits: any[] = [],
+  existingCases: any[] = []
+) => {
+  const categories: RouterCategory[] = [];
+  const exits: RouterExit[] = [];
+  const cases: RouterCase[] = [];
+
+  // Add user categories
+  userCategories.forEach((categoryName) => {
+    const result = createOrPreserveCategory({
+      name: categoryName,
+      existingCategories,
+      existingExits,
+      existingCases,
+      caseConfig: categoryToCaseMap(categoryName)
+    });
+
+    categories.push(result.category);
+    exits.push(result.exit);
+    if (result.case) {
+      cases.push(result.case);
+    }
+  });
+
+  // Add "Other" category (default)
+  const other = createOrPreserveCategory({
+    name: 'Other',
+    existingCategories,
+    existingExits
+  });
+  categories.push(other.category);
+  exits.push(other.exit);
+
+  // Add "Failure" category
+  const failure = createOrPreserveCategory({
+    name: 'Failure',
+    existingCategories,
+    existingExits,
+    existingCases,
+    caseConfig: {
+      type: 'has_only_text',
+      arguments: ['<ERROR>']
+    }
+  });
+  categories.push(failure.category);
+  exits.push(failure.exit);
+  if (failure.case) {
+    cases.push(failure.case);
+  }
+
+  return {
+    router: {
+      type: 'switch' as const,
+      categories: categories,
+      default_category_uuid: other.category.uuid,
+      operand: operand,
+      cases: cases
+    },
+    exits: exits
+  };
+};

package/test/nodes/split_by_llm.test.ts

@@ -0,0 +1,232 @@
+import { expect } from '@open-wc/testing';
+import { split_by_llm } from '../../src/flow/nodes/split_by_llm';
+import { Node, CallLLM } from '../../src/store/flow-definition';
+import { NodeTest } from '../NodeHelper';
+
+/**
+ * Test suite for the split_by_llm node configuration.
+ */
+describe('split_by_llm node config', () => {
+  const helper = new NodeTest(split_by_llm, 'split_by_llm');
+
+  describe('basic properties', () => {
+    helper.testBasicProperties();
+
+    it('has correct name', () => {
+      expect(split_by_llm.name).to.equal('Call AI');
+    });
+
+    it('has form configuration', () => {
+      expect(split_by_llm.form).to.exist;
+      expect(split_by_llm.form.llm).to.exist;
+      expect(split_by_llm.form.instructions).to.exist;
+      expect(split_by_llm.form.input).to.exist;
+    });
+
+    it('has layout configuration', () => {
+      expect(split_by_llm.layout).to.exist;
+      expect(split_by_llm.layout).to.deep.equal([
+        'llm',
+        'input',
+        'instructions'
+      ]);
+    });
+  });
+
+  describe('toFormData', () => {
+    it('extracts data from node with call_llm action', () => {
+      const node: Node = {
+        uuid: 'test-node',
+        actions: [
+          {
+            uuid: 'test-action',
+            type: 'call_llm',
+            llm: { uuid: 'gpt-4', name: 'GPT 4.1' },
+            instructions: 'Translate to French',
+            input: '@input',
+            output_local: '_llm_output'
+          } as CallLLM
+        ],
+        exits: []
+      };
+
+      const formData = split_by_llm.toFormData(node);
+
+      expect(formData.uuid).to.equal('test-node');
+      expect(formData.llm).to.deep.equal([{ value: 'gpt-4', name: 'GPT 4.1' }]);
+      expect(formData.input).to.equal('@input');
+      expect(formData.instructions).to.equal('Translate to French');
+    });
+
+    it('handles empty node', () => {
+      const node: Node = {
+        uuid: 'test-node',
+        actions: [],
+        exits: []
+      };
+
+      const formData = split_by_llm.toFormData(node);
+
+      expect(formData.uuid).to.equal('test-node');
+      expect(formData.llm).to.deep.equal([]);
+      expect(formData.input).to.equal('@input');
+      expect(formData.instructions).to.equal('');
+    });
+  });
+
+  describe('fromFormData', () => {
+    it('creates node with call_llm action and router', () => {
+      const formData = {
+        uuid: 'test-node',
+        llm: [{ value: 'gpt-4', name: 'GPT 4.1' }],
+        input: '@input',
+        instructions: 'Translate to French'
+      };
+
+      const originalNode: Node = {
+        uuid: 'test-node',
+        actions: [],
+        exits: []
+      };
+
+      const node = split_by_llm.fromFormData(formData, originalNode);
+
+      expect(node.uuid).to.equal('test-node');
+      expect(node.actions).to.have.length(1);
+      expect(node.actions[0].type).to.equal('call_llm');
+      expect((node.actions[0] as CallLLM).llm).to.deep.equal({
+        uuid: 'gpt-4',
+        name: 'GPT 4.1'
+      });
+      expect((node.actions[0] as CallLLM).instructions).to.equal(
+        'Translate to French'
+      );
+      expect((node.actions[0] as CallLLM).input).to.equal('@input');
+      expect((node.actions[0] as CallLLM).output_local).to.equal('_llm_output');
+
+      expect(node.router).to.exist;
+      expect(node.router.type).to.equal('switch');
+      expect(node.router.operand).to.equal('@locals._llm_output');
+      expect(node.router.categories).to.have.length(2);
+      expect(node.router.categories[0].name).to.equal('Success');
+      expect(node.router.categories[1].name).to.equal('Failure');
+
+      expect(node.exits).to.have.length(2);
+    });
+
+    it('handles empty form data', () => {
+      const formData = {
+        uuid: 'test-node',
+        llm: [],
+        input: '',
+        instructions: ''
+      };
+
+      const originalNode: Node = {
+        uuid: 'test-node',
+        actions: [],
+        exits: []
+      };
+
+      const node = split_by_llm.fromFormData(formData, originalNode);
+
+      const action = node.actions[0] as CallLLM;
+      expect(action.llm).to.deep.equal({ uuid: '', name: '' });
+      expect(action.instructions).to.equal('');
+      expect(action.input).to.equal('@input');
+    });
+  });
+
+  describe('node scenarios', () => {
+    const createTestNode = (
+      llm: any,
+      instructions: string,
+      input: string = '@input'
+    ): Node => ({
+      uuid: 'test-node',
+      actions: [
+        {
+          uuid: 'test-action',
+          type: 'call_llm',
+          llm,
+          instructions,
+          input,
+          output_local: '_llm_output'
+        } as CallLLM
+      ],
+      router: {
+        type: 'switch',
+        operand: '@locals._llm_output',
+        categories: [
+          {
+            uuid: 'success-category',
+            name: 'Success',
+            exit_uuid: 'success-exit'
+          },
+          {
+            uuid: 'failure-category',
+            name: 'Failure',
+            exit_uuid: 'failure-exit'
+          }
+        ],
+        default_category_uuid: 'failure-category',
+        cases: [
+          {
+            uuid: 'success-case',
+            type: 'has_text',
+            arguments: [],
+            category_uuid: 'success-category'
+          }
+        ]
+      },
+      exits: [
+        {
+          uuid: 'success-exit',
+          destination_uuid: null
+        },
+        {
+          uuid: 'failure-exit',
+          destination_uuid: null
+        }
+      ]
+    });
+
+    const nodeUI = {
+      type: 'split_by_llm',
+      position: { left: 50, top: 50 }
+    };
+
+    helper.testNode(
+      createTestNode({ uuid: 'gpt-4', name: 'GPT 4.1' }, 'Translate to French'),
+      nodeUI,
+      'translation-task'
+    );
+
+    helper.testNode(
+      createTestNode(
+        { uuid: 'gpt-5', name: 'GPT 5' },
+        'Analyze the sentiment of the following message and classify it as positive, negative, or neutral. Provide a brief explanation for your classification.'
+      ),
+      nodeUI,
+      'sentiment-analysis'
+    );
+
+    helper.testNode(
+      createTestNode(
+        { uuid: 'gpt-4', name: 'GPT 4.1' },
+        'Summarize the key points from the conversation above in bullet format.'
+      ),
+      nodeUI,
+      'summarization'
+    );
+
+    helper.testNode(
+      createTestNode(
+        { uuid: 'gpt-5', name: 'GPT 5' },
+        'Extract any contact information (phone numbers, email addresses) from the text and format them as a JSON object.'
+      ),
+      nodeUI,
+      'information-extraction'
+    );
+  });
+});