@nyaruka/temba-components 0.129.10 → 0.130.0

package/src/flow/actions/call_webhook.ts

@@ -1,143 +0,0 @@
-import { html } from 'lit-html';
-import { ActionConfig, COLORS } from '../types';
-import { Node, CallWebhook } from '../../store/flow-definition';
-
-const defaultPost = `@(json(object(
-  "contact", object(
-    "uuid", contact.uuid, 
-    "name", contact.name, 
-    "urn", contact.urn
-  ),
-  "flow", object(
-    "uuid", run.flow.uuid, 
-    "name", run.flow.name
-  ),
-  "results", foreach_value(results, extract_object, "value", "category")
-)))`;
-
-export const call_webhook: ActionConfig = {
-  name: 'Call Webhook',
-  color: COLORS.call,
-  render: (_node: Node, action: CallWebhook) => {
-    return html`<div
-      style="word-wrap: break-word; overflow-wrap: break-word; hyphens: auto;"
-    >
-      ${action.url}
-    </div>`;
-  },
-  evaluated: ['url', 'headers', 'body'], // keep for backward compatibility
-  form: {
-    method: {
-      type: 'select',
-      required: true,
-      options: ['GET', 'POST', 'PUT', 'DELETE', 'HEAD', 'PATCH'],
-      maxWidth: '120px',
-      searchable: false
-    },
-    url: {
-      type: 'text',
-      required: true,
-      evaluated: true,
-      placeholder: 'https://example.com/webhook'
-    },
-    headers: {
-      type: 'key-value',
-      sortable: true,
-      keyPlaceholder: 'Header name',
-      valuePlaceholder: 'Header value',
-      minRows: 0
-    },
-    body: {
-      type: 'textarea',
-      evaluated: true,
-      placeholder: 'Request body content (JSON, XML, etc.)',
-      minHeight: 200,
-      dependsOn: ['method'],
-      computeValue: (
-        values: Record<string, any>,
-        currentValue: any,
-        originalValues?: Record<string, any>
-      ) => {
-        // Check if method is POST (handle both string and select object formats)
-        const method =
-          Array.isArray(values.method) && values.method.length > 0
-            ? values.method[0].value || values.method[0].name
-            : values.method;
-
-        if (method === 'POST') {
-          // For POST, provide the template if body is empty or was never set by user
-          if (!currentValue || currentValue.trim() === '') {
-            return defaultPost;
-          }
-        } else {
-          // For non-POST methods, clear the body if it was auto-generated or empty
-          // Check if the original body was empty (user never specified a body)
-          const originalBody = originalValues?.body || '';
-          const isOriginallyEmpty = !originalBody || originalBody.trim() === '';
-
-          // Clear if: originally empty, contains default template, or is currently empty
-          if (
-            isOriginallyEmpty ||
-            !currentValue ||
-            currentValue.trim() === '' ||
-            currentValue.trim() === defaultPost.trim()
-          ) {
-            return '';
-          }
-        }
-
-        return currentValue; // Keep existing value if user has customized it
-      }
-    }
-  },
-  layout: [
-    // Row with method and URL side by side
-    { type: 'row', items: ['method', 'url'] },
-    // Advanced group with nested layouts
-    {
-      type: 'group',
-      label: 'Headers',
-      items: ['headers'],
-      collapsible: true,
-      collapsed: true,
-      helpText: 'Configure authentication or custom headers',
-      getGroupValueCount: (formData: any) => {
-        return formData.headers?.length || 0;
-      }
-    },
-    {
-      type: 'group',
-      label: 'Body',
-      items: ['body'],
-      collapsible: true,
-      collapsed: true,
-      helpText: 'Configure the request payload',
-      getGroupValueCount: (formData: any) => {
-        return !!(
-          formData.body &&
-          formData.body.trim() !== '' &&
-          formData.body !== defaultPost
-        );
-      }
-    }
-  ],
-  toFormData: (action: CallWebhook) => {
-    return {
-      uuid: action.uuid,
-      url: action.url || '',
-      method: [{ value: action.method, name: action.method }],
-      headers: action.headers || [],
-      body: action.body || ''
-    };
-  },
-  fromFormData: (data: Record<string, any>) => {
-    return {
-      uuid: data.uuid,
-      type: 'call_webhook',
-      url: data.url,
-      method: data.method[0].value,
-      headers: data.headers || [],
-      body: data.body || ''
-    } as CallWebhook;
-  }
-};

package/src/flow/actions/enter_flow.ts

@@ -1,15 +0,0 @@
-import { html } from 'lit-html';
-import { ActionConfig, COLORS } from '../types';
-import { Node, EnterFlow } from '../../store/flow-definition';
-
-export const enter_flow: ActionConfig = {
-  name: 'Enter a Flow',
-  color: COLORS.execute,
-  render: (_node: Node, action: EnterFlow) => {
-    return html`<div
-      style="word-wrap: break-word; overflow-wrap: break-word; hyphens: auto;"
-    >
-      Enter <b>${action.flow.name}</b>
-    </div>`;
-  }
-};

package/src/flow/actions/open_ticket.ts

@@ -1,83 +0,0 @@
-import { html } from 'lit-html';
-import { ActionConfig, COLORS } from '../types';
-import { Node, OpenTicket } from '../../store/flow-definition';
-
-export const open_ticket: ActionConfig = {
-  name: 'Open Ticket',
-  color: COLORS.create,
-  render: (_node: Node, action: OpenTicket) => {
-    return html`<div>${action.topic.name}</div>`;
-  },
-  form: {
-    topic: {
-      type: 'select',
-      required: true,
-      placeholder: 'Select a topic',
-      options: [],
-      endpoint: '/api/v2/topics.json',
-      valueKey: 'uuid',
-      nameKey: 'name',
-      maxWidth: '200px'
-    },
-    assignee: {
-      type: 'select',
-      required: false,
-      placeholder: 'Select an agent (optional)',
-      options: [],
-      endpoint: '/api/v2/users.json',
-      valueKey: 'uuid',
-      getName: (item: {
-        first_name?: string;
-        last_name?: string;
-        name?: string;
-      }) => {
-        return item.name || [item.first_name, item.last_name].join(' ');
-      },
-      clearable: true
-    },
-    note: {
-      type: 'textarea',
-      required: false,
-      placeholder: 'Enter a note for the ticket (optional)',
-      minHeight: 100
-    }
-  },
-  layout: [{ type: 'row', items: ['topic', 'assignee'] }, 'note'],
-  toFormData: (action: OpenTicket) => {
-    return {
-      uuid: action.uuid,
-      topic: action.topic
-        ? [{ uuid: action.topic.uuid, name: action.topic.name }]
-        : [],
-      assignee: action.assignee
-        ? [{ uuid: action.assignee.uuid, name: action.assignee.name }]
-        : [],
-      note: action.note || ''
-    };
-  },
-  fromFormData: (data: Record<string, any>) => {
-    return {
-      uuid: data.uuid,
-      type: 'open_ticket',
-      topic:
-        data.topic && data.topic.length > 0
-          ? {
-              uuid: data.topic[0].uuid,
-              name: data.topic[0].name
-            }
-          : undefined,
-      assignee:
-        data.assignee && data.assignee.length > 0
-          ? {
-              uuid: data.assignee[0].uuid,
-              name:
-                data.assignee[0].name ||
-                [data.assignee[0].first_name, data.assignee[0].last_name].join(
-                  ' '
-                )
-            }
-          : undefined,
-      note: data.note || ''
-    } as OpenTicket;
-  }
-};

package/test/actions/call_llm.test.ts

@@ -1,137 +0,0 @@
-import { expect } from '@open-wc/testing';
-import { call_llm } from '../../src/flow/actions/call_llm';
-import { CallLLM } from '../../src/store/flow-definition';
-import { ActionTest } from '../ActionHelper';
-
-/**
- * Test suite for the call_llm action configuration.
- */
-describe('call_llm action config', () => {
-  const helper = new ActionTest(call_llm, 'call_llm');
-
-  describe('basic properties', () => {
-    helper.testBasicProperties();
-
-    it('has correct name', () => {
-      expect(call_llm.name).to.equal('Call AI');
-    });
-
-    it('has form configuration', () => {
-      expect(call_llm.form).to.exist;
-      expect(call_llm.form.llm).to.exist;
-      expect(call_llm.form.instructions).to.exist;
-      expect(call_llm.form.input).to.exist;
-    });
-
-    it('has layout configuration', () => {
-      expect(call_llm.layout).to.exist;
-      expect(call_llm.layout).to.deep.equal(['llm', 'input', 'instructions']);
-    });
-
-    it('has data transformation functions', () => {
-      expect(call_llm.toFormData).to.be.a('function');
-      expect(call_llm.fromFormData).to.be.a('function');
-    });
-  });
-
-  describe('data transformations', () => {
-    it('converts action to form data correctly', () => {
-      const action: CallLLM = {
-        uuid: 'test-llm-1',
-        type: 'call_llm',
-        input: '@input',
-        llm: { uuid: 'gpt-4', name: 'GPT 4.1' },
-        instructions: 'Translate to French',
-        result_name: 'translated_text'
-      };
-
-      const formData = call_llm.toFormData(action);
-
-      expect(formData.uuid).to.equal('test-llm-1');
-      expect(formData.llm).to.deep.equal([{ value: 'gpt-4', name: 'GPT 4.1' }]);
-      expect(formData.instructions).to.equal('Translate to French');
-      expect(formData.input).to.equal('@input');
-    });
-
-    it('converts form data to action correctly', () => {
-      const formData = {
-        uuid: 'test-llm-2',
-        llm: [{ value: 'gpt-5', name: 'GPT 5' }],
-        instructions: 'Summarize the following text',
-        input: '@input'
-      };
-
-      const action = call_llm.fromFormData(formData) as CallLLM;
-
-      expect(action.uuid).to.equal('test-llm-2');
-      expect(action.type).to.equal('call_llm');
-      expect(action.llm).to.deep.equal({ uuid: 'gpt-5', name: 'GPT 5' });
-      expect(action.instructions).to.equal('Summarize the following text');
-      expect(action.input).to.equal('@input');
-    });
-
-    it('handles empty form data', () => {
-      const formData = {
-        uuid: 'test-llm-3',
-        llm: [],
-        instructions: '',
-        input: ''
-      };
-
-      const action = call_llm.fromFormData(formData) as CallLLM;
-
-      expect(action.llm).to.deep.equal({ uuid: '', name: '' });
-      expect(action.instructions).to.equal('');
-      expect(action.input).to.equal('@input');
-    });
-  });
-
-  describe('action scenarios', () => {
-    helper.testAction(
-      {
-        uuid: 'test-action-1',
-        type: 'call_llm',
-        llm: { uuid: 'gpt-4', name: 'GPT 4.1' },
-        instructions: 'Translate to French',
-        input: '@input'
-      } as CallLLM,
-      'translation-task'
-    );
-
-    helper.testAction(
-      {
-        uuid: 'test-action-2',
-        type: 'call_llm',
-        llm: { uuid: 'gpt-5', name: 'GPT 5' },
-        instructions:
-          'Analyze the sentiment of the following message and classify it as positive, negative, or neutral. Provide a brief explanation for your classification.',
-        input: '@input'
-      } as CallLLM,
-      'sentiment-analysis'
-    );
-
-    helper.testAction(
-      {
-        uuid: 'test-action-3',
-        type: 'call_llm',
-        llm: { uuid: 'gpt-4', name: 'GPT 4.1' },
-        instructions:
-          'Summarize the key points from the conversation above in bullet format.',
-        input: '@input'
-      } as CallLLM,
-      'summarization'
-    );
-
-    helper.testAction(
-      {
-        uuid: 'test-action-4',
-        type: 'call_llm',
-        llm: { uuid: 'gpt-5', name: 'GPT 5' },
-        instructions:
-          'Extract any contact information (phone numbers, email addresses) from the text and format them as a JSON object.',
-        input: '@input'
-      } as CallLLM,
-      'information-extraction'
-    );
-  });
-});