🚀 Feature: Add ValueFirst (vfirst.com) as a native SMS provider

[Lokendra-egov]

🔖 Feature description

Add ValueFirst (https://www.vfirst.com) as a native SMS provider under packages/providers/src/lib/sms/valuefirst/, following the same pattern as existing providers such as termii and firetext.

ValueFirst exposes an XML-based HTTPS API for sending SMS. The provider requires Bearer token authentication (7-day TTL, auto-refreshed) and supports delivery report (DLR) webhooks via HTTP callback.

Credentials needed

• username — ValueFirst account username
• password — ValueFirst account password
• from — Sender ID (max 11 alphanumeric chars)

API endpoint: https://api.myvfirst.com/psms/servlet/psms.Eservice2

DLR status values to map: DELIVERED, NOT_DELIVERED, QUEUED, SENT, FAILED, REJECTED

🎤 Why is this feature needed ?

ValueFirst is one of the most widely adopted CPaaS providers in India, used extensively across government platforms, banking, healthcare, and enterprise systems. Several Novu users building products for the Indian market are currently blocked from using ValueFirst natively and are forced to work around the limitation using the generic-sms provider with a custom HTTP adapter — adding unnecessary infrastructure overhead.

Concrete use case:
We are building a citizen-facing complaint resolution system on the
DIGIT urban governance platform (used by multiple state governments in
India). Notifications such as complaint acknowledgements, status updates,
and resolution confirmations need to be delivered via SMS using ValueFirst,
which is the mandated SMS gateway for several government tenants.

India-specific requirement — DLT compliance:
TRAI (India's telecom regulator) mandates that every commercial SMS carry
a registered DLTTEMPLATEID, DLTCONTENTTYPE, and ENTITYID. A native
ValueFirst provider would allow these fields to be passed correctly through
Novu's _passthrough mechanism, which is not straightforward with the
current generic-sms workaround.

Adding this provider would give Indian Novu users a first-class integration
with no custom adapter code required.

✌️ How do you aim to achieve this?

I want this feature to introduce a new valuefirst provider package under
packages/providers/src/lib/sms/valuefirst/ with the following structure:

Files to create:

• valuefirst.provider.ts — core provider implementing ISmsProvider
• valuefirst.provider.spec.ts — unit tests
• index.ts — barrel export

Implementation plan:

1. Authentication — POST to ValueFirst's token endpoint
   (https://api.myvfirst.com/psms/api/messages/token?action=generate)
   using Basic Auth, cache the Bearer token with a 7-day TTL, and
   auto-refresh before expiry.

2. sendMessage() — Build a ValueFirst XML payload and POST it to
   https://api.myvfirst.com/psms/servlet/psms.Eservice2 with
   Authorization: Bearer <token>. Extract the message ID from the
   XML response.

3. getStatus() — Map ValueFirst DLR statuses (DELIVERED,
   NOT_DELIVERED, QUEUED, SENT, FAILED, REJECTED) to
   SmsEventStatusEnum.

4. parseEventBody() — Parse ValueFirst's DLR webhook callback
   (query-string format) into a standardised ISmsWebhookBody.

5. Register the provider in SmsProviderIdEnum and export it
   from the SMS providers index.

I am willing to submit a PR implementing the above. The implementation
would closely follow the pattern of termii and firetext providers
already in the codebase.

🔄️ Additional Information

I tried using the existing generic-sms provider as a workaround by
pointing its baseUrl at a custom Node.js adapter that translates
Novu's JSON payload into ValueFirst's XML API format. While this works,
It requires maintaining an extra adapter service, managing the Bearer token
rotation outside of Novu, and handling DLR webhook forwarding manually.

A native provider would eliminate all of this overhead and make
ValueFirst a first-class integration available directly from the
Novu dashboard — consistent with how Twilio, Termii, and other
Providers work today.

References:

• ValueFirst XML API docs: https://product-user-guide.vfirst.com/xml/
• ValueFirst token API: https://api.myvfirst.com/psms/api/messages/token?action=generate
• Similar provider implementations for reference: termii, firetext

👀 Have you spent some time to check if this feature request has been raised before?

• I checked and didn't find similar issue

🏢 Have you read the Code of Conduct?

• I have read the Contributing Guidelines

Are you willing to submit PR?

None

[linear]

NV-7442

[Yashh56]

Anyone working on this issue?

[rohanranjan0902]

Hi @scopsy , I have completed the implementation for the native ValueFirst SMS provider integration including:

1. provider implementation
2. token auth caching
   3.DLR webhook parsing
   4.dashboard/provider registration
3. handler integration
4. tests

However, GitHub is currently preventing me from opening a PR due to repository contribution restrictions.

Could you please guide me on the correct contribution flow or enable PR access for external contributors?

Thanks!

[scopsy]

Hi @rohanranjan0902 unfortuently due to the recent events targeting open-source projects we had to block non core-contributor PR creation until GitHub can provide us better tools to protect those flows.

You are welcome to provide a detailed guide here on how such integration can be added, and we can follow up with implementation 🙏

[rohanranjan0902]

Hi @scopsy

Since PR creations for external contributors are currently paused, I have fully implemented, unit-tested, and verified the ValueFirst native SMS provider integration locally.

Below is the complete technical blueprint and the exact code implementation, which you can copy and merge directly into the codebase.

---

📂 File Structure Overview

1. New Files:

   • packages/providers/src/lib/sms/valuefirst/valuefirst.provider.ts (Core wrapper)
   • packages/providers/src/lib/sms/valuefirst/valuefirst.provider.spec.ts (Unit tests)
   • libs/application-generic/src/factories/sms/handlers/valuefirst.handler.ts (Factory handler)

2. Modified Files:

   • packages/shared/src/types/providers.ts
   • packages/shared/src/consts/providers/credentials/provider-credentials.ts
   • packages/shared/src/consts/providers/channels/sms.ts
   • packages/framework/src/shared.ts
   • packages/framework/src/schemas/providers/sms/index.ts
   • packages/providers/src/lib/sms/index.ts
   • libs/application-generic/src/factories/sms/handlers/index.ts
   • libs/application-generic/src/factories/sms/sms.factory.ts

---

💻 1. Core Provider Implementation

File: packages/providers/src/lib/sms/valuefirst/valuefirst.provider.ts

import { SmsProviderIdEnum } from 'novu/shared';
import {
  ChannelTypeEnum,
  ISendMessageSuccessResponse,
  ISMSEventBody,
  ISmsOptions,
  ISmsProvider,
  SmsEventStatusEnum,
} from '@novu/stateless';
import { BaseProvider, CasingEnum } from '../../../base.provider';
import { WithPassthrough } from '../../../utils/types';

export class ValueFirstSmsProvider extends BaseProvider implements ISmsProvider {
  id = SmsProviderIdEnum.ValueFirst;
  channelType = ChannelTypeEnum.SMS as ChannelTypeEnum.SMS;
  protected casing = CasingEnum.CAMEL_CASE;

  private static token: string | null = null;
  private static tokenExpiry = 0;

  constructor(
    private config: {
      username?: string;
      password?: string;
      from?: string;
    }
  ) {
    super();
  }

  private async getBearerToken(): Promise<string> {
    const now = Date.now();
    // Refresh token 5 minutes before actual 7-day expiration
    if (!ValueFirstSmsProvider.token || now >= ValueFirstSmsProvider.tokenExpiry - 5 * 60 * 1000) {
      await this.refreshToken();
    }
    return ValueFirstSmsProvider.token!;
  }

  private async refreshToken(): Promise<void> {
    const username = this.config.username;
    const password = this.config.password;
    if (!username || !password) {
      throw new Error('ValueFirst provider credentials (username, password) are missing.');
    }

    const authHeader = 'Basic ' + Buffer.from(`${username}:${password}`).toString('base64');
    const tokenUrl = 'https://api.myvfirst.com/psms/api/messages/token?action=generate';

    const response = await fetch(tokenUrl, {
      method: 'POST',
      headers: {
        Authorization: authHeader,
        'Content-Type': 'application/json',
      },
    } as any);

    if (!response.ok) {
      const errorText = await response.text();
      throw new Error(`Failed to generate ValueFirst token: ${response.statusText} (${errorText})`);
    }

    const data = await response.json();
    if (!data.token) {
      throw new Error(`ValueFirst token generation response did not contain a token: ${JSON.stringify(data)}`);
    }

    ValueFirstSmsProvider.token = data.token;

    let ttlMs = 7 * 24 * 60 * 60 * 1000; // default 7 days
    if (data.expiryDate) {
      const expiryTime = new Date(data.expiryDate).getTime();
      if (!isNaN(expiryTime)) {
        ttlMs = expiryTime - Date.now();
      }
    }

    ValueFirstSmsProvider.tokenExpiry = Date.now() + ttlMs;
  }

  async sendMessage(
    options: ISmsOptions,
    bridgeProviderData: WithPassthrough<Record<string, unknown>> = {}
  ): Promise<ISendMessageSuccessResponse> {
    const token = await this.getBearerToken();

    const transformed = this.transform<Record<string, unknown>>(bridgeProviderData, {
      to: options.to,
      from: options.from || this.config.from,
      message: options.content,
    });

    const body = transformed.body;
    const to = String(body.to || options.to);
    const formattedTo = to.replace(/[^0-9]/g, '');

    const from = String(body.from || options.from || this.config.from);
    const content = String(body.message || options.content);

    // Optional DLT properties for TRAI DLT compliance
    const dltTemplateId = body.dltTemplateId || body.dlt_templateid || body.dltTemplateid;
    const entityId = body.entityId || body.entityid || body.peId || body.pe_id || body.peid;
    const dltContentType = body.dltContentType || body.dltcontenttype;
    const templateInfo = body.templateInfo || body.templateinfo;

    const escapeXml = (unsafe: string) => {
      return unsafe.replace(/[<>&'"]/g, (c) => {
        switch (c) {
          case '<': return '&lt;';
          case '>': return '&gt;';
          case '&': return '&amp;';
          case '\'': return '&apos;';
          case '"': return '&quot;';
          default: return c;
        }
      });
    };

    const escapedContent = escapeXml(content);
    const escapedFrom = escapeXml(from);

    let smsAttributes = `UDH="0" CODING="1" TEXT="${escapedContent}" PROPERTY="0" ID="1"`;
    if (templateInfo) {
      smsAttributes += ` TEMPLATEINFO="${escapeXml(String(templateInfo))}"`;
    }
    if (dltTemplateId) {
      smsAttributes += ` DLT_TEMPLATE_ID="${escapeXml(String(dltTemplateId))}"`;
    }
    if (dltContentType) {
      smsAttributes += ` DLTCONTENTTYPE="${escapeXml(String(dltContentType))}"`;
    }

    let addressAttributes = `FROM="${escapedFrom}" TO="${formattedTo}" SEQ="1"`;
    if (entityId) {
      addressAttributes += ` ENTITYID="${escapeXml(String(entityId))}"`;
    }

    const xmlPayload = `<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE MESSAGE SYSTEM "https://127.0.0.1:80/psms/dtd/messagev12.dtd">
<MESSAGE VER="1.2">
    <USER USERNAME="${escapeXml(this.config.username || '')}" PASSWORD="${escapeXml(this.config.password || '')}"/>
    <SMS ${smsAttributes}>
        <ADDRESS ${addressAttributes}/>
    </SMS>
</MESSAGE>`;

    const apiEndpoint = 'https://api.myvfirst.com/psms/servlet/psms.Eservice2';

    const response = await fetch(apiEndpoint, {
      method: 'POST',
      headers: {
        Authorization: `Bearer ${token}`,
        'Content-Type': 'application/xml',
      },
      body: xmlPayload,
    } as any);

    if (!response.ok) {
      const errorText = await response.text();
      throw new Error(`ValueFirst API HTTP error: ${response.statusText} (${errorText})`);
    }

    const responseText = await response.text();

    if (responseText.includes('<Err ') || responseText.includes('<Err>')) {
      const codeMatch = responseText.match(/Code="([^"]+)"/i);
      const descMatch = responseText.match(/Desc="([^"]+)"/i);
      const code = codeMatch ? codeMatch[1] : 'Unknown';
      const desc = descMatch ? descMatch[1] : 'Unknown error';
      throw new Error(`ValueFirst API Error: ${desc} (Code: ${code})`);
    }

    const errorMatch = responseText.match(/<ERROR\s+[^>]*CODE="([^"]+)"/i) || responseText.match(/<ERROR\s+[^>]*Code="([^"]+)"/i);
    if (errorMatch) {
      const errorCode = errorMatch[1];
      throw new Error(`ValueFirst Message Error: Code ${errorCode}`);
    }

    const guidMatch = responseText.match(/<GUID\s+[^>]*GUID="([^"]+)"/i);
    if (!guidMatch) {
      throw new Error(`ValueFirst API unexpected response format: ${responseText}`);
    }

    return {
      id: guidMatch[1],
      date: new Date().toISOString(),
    };
  }

  getMessageId(body: any | any[]): string[] {
    if (Array.isArray(body)) {
      return body.map((item) => item.guid || item.msgid || item.messageId || item.messageid);
    }
    return [body.guid || body.msgid || body.messageId || body.messageid];
  }

  parseEventBody(body: any | any[], identifier: string): ISMSEventBody | undefined {
    if (Array.isArray(body)) {
      body = body.find((item) => {
        const id = item.guid || item.msgid || item.messageId || item.messageid;
        return id === identifier;
      });
    }

    if (!body) return undefined;

    const guid = body.guid || body.msgid || body.messageId || body.messageid;
    if (guid !== identifier) return undefined;

    const status = this.getStatus(body.status);
    if (status === undefined) return undefined;

    return {
      status,
      date: new Date().toISOString(),
      externalId: guid,
      attempts: body.attempt ? parseInt(body.attempt, 10) : 1,
      response: body.response ? body.response : '',
      row: body,
    };
  }

  private getStatus(status: string): SmsEventStatusEnum | undefined {
    if (!status) return undefined;
    switch (status.toUpperCase()) {
      case 'DELIVERED': return SmsEventStatusEnum.DELIVERED;
      case 'NOT_DELIVERED': return SmsEventStatusEnum.UNDELIVERED;
      case 'QUEUED': return SmsEventStatusEnum.QUEUED;
      case 'SENT': return SmsEventStatusEnum.SENT;
      case 'FAILED': return SmsEventStatusEnum.FAILED;
      case 'REJECTED': return SmsEventStatusEnum.REJECTED;
      default: return undefined;
    }
  }
}

[rohanranjan0902]

** 2. Provider Unit Tests
File: packages/providers/src/lib/sms/valuefirst/valuefirst.provider.spec.ts**

import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest';
import { SmsEventStatusEnum } from '@novu/stateless';
import { ValueFirstSmsProvider } from './valuefirst.provider';

describe('ValueFirstSmsProvider', () => {
let provider: ValueFirstSmsProvider;

beforeEach(() => {
provider = new ValueFirstSmsProvider({
username: 'testUser',
password: 'testPassword',
from: 'testFrom',
});
(ValueFirstSmsProvider as any).token = null;
(ValueFirstSmsProvider as any).tokenExpiry = 0;
});

afterEach(() => {
vi.restoreAllMocks();
});

test('should generate and cache bearer token correctly', async () => {
const tokenResponse = {
token: 'eyJhbGciOiJIUzI1NiJ9.eyJpc3MiOiJ2Zmlyc3QifQ',
expiryDate: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000).toISOString(),
};

const successXml = `
  <MESSAGEACK>
    <GUID GUID="kb4jc4334130a5f461209l7t17" SUBMITDATE="2026-05-24" ID="1"/>
  </MESSAGEACK>
`;

const fetchMock = vi.fn().mockImplementation((url, options) => {
  if (url.includes('/token')) {
    return Promise.resolve({
      ok: true,
      json: () => Promise.resolve(tokenResponse),
    });
  }
  return Promise.resolve({
    ok: true,
    text: () => Promise.resolve(successXml),
  });
});

global.fetch = fetchMock;

const result1 = await provider.sendMessage({
  content: 'hello',
  to: '+919876543210',
});

expect(result1).toEqual({
  id: 'kb4jc4334130a5f461209l7t17',
  date: expect.any(String),
});

expect(fetchMock).toHaveBeenCalledWith(
  'https://api.myvfirst.com/psms/api/messages/token?action=generate',
  expect.objectContaining({
    method: 'POST',
    headers: expect.objectContaining({
      Authorization: 'Basic dGVzdFVzZXI6dGVzdFBhc3N3b3Jk',
    }),
  })
);

fetchMock.mockClear();

await provider.sendMessage({
  content: 'world',
  to: '+919876543210',
});

const tokenCall = fetchMock.mock.calls.find((c) => c[0].includes('/token'));
expect(tokenCall).toBeUndefined();

const sendCall = fetchMock.mock.calls.find((c) => c[0].includes('Eservice2'));
expect(sendCall).toBeDefined();
expect(sendCall![1]?.headers?.Authorization).toBe(`Bearer ${tokenResponse.token}`);

});

test('should build XML payload correctly and escape special characters', async () => {
const tokenResponse = {
token: 'test-token',
expiryDate: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000).toISOString(),
};

const successXml = `
  <MESSAGEACK>
    <GUID GUID="test-guid" SUBMITDATE="2026-05-24" ID="1"/>
  </MESSAGEACK>
`;

const fetchMock = vi.fn().mockImplementation((url, options) => {
  if (url.includes('/token')) {
    return Promise.resolve({
      ok: true,
      json: () => Promise.resolve(tokenResponse),
    });
  }
  return Promise.resolve({
    ok: true,
    text: () => Promise.resolve(successXml),
  });
});

global.fetch = fetchMock;

await provider.sendMessage({
  content: 'hello <world> & "friends"\'',
  to: '+91-98765-43210',
});

const sendCall = fetchMock.mock.calls.find((c) => c[0].includes('Eservice2'));
expect(sendCall).toBeDefined();

const xmlPayload = sendCall![1]?.body as string;

expect(xmlPayload).toContain('TO="919876543210"');
expect(xmlPayload).toContain('TEXT="hello &lt;world&gt; &amp; &quot;friends&quot;&apos;"');
expect(xmlPayload).toContain('USERNAME="testUser"');
expect(xmlPayload).toContain('PASSWORD="testPassword"');

});

test('should support DLT parameters passed via passthrough', async () => {
const tokenResponse = {
token: 'test-token',
expiryDate: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000).toISOString(),
};

const successXml = `
  <MESSAGEACK>
    <GUID GUID="test-guid" SUBMITDATE="2026-05-24" ID="1"/>
  </MESSAGEACK>
`;

const fetchMock = vi.fn().mockImplementation((url, options) => {
  if (url.includes('/token')) {
    return Promise.resolve({
      ok: true,
      json: () => Promise.resolve(tokenResponse),
    });
  }
  return Promise.resolve({
    ok: true,
    text: () => Promise.resolve(successXml),
  });
});

global.fetch = fetchMock;

await provider.sendMessage(
  {
    content: 'DLT content',
    to: '919876543210',
  },
  {
    _passthrough: {
      body: {
        dltTemplateId: '120716172635467',
        entityId: '110115984635467',
        dltContentType: '1',
        templateInfo: '120716172635467~var1',
      },
    },
  }
);

const sendCall = fetchMock.mock.calls.find((c) => c[0].includes('Eservice2'));
expect(sendCall).toBeDefined();

const xmlPayload = sendCall![1]?.body as string;

expect(xmlPayload).toContain('DLT_TEMPLATE_ID="120716172635467"');
expect(xmlPayload).toContain('DLTCONTENTTYPE="1"');
expect(xmlPayload).toContain('TEMPLATEINFO="120716172635467~var1"');
expect(xmlPayload).toContain('ENTITYID="110115984635467"');

});

test('should throw a descriptive error on critical XML error', async () => {
const tokenResponse = {
token: 'test-token',
expiryDate: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000).toISOString(),
};

const errorXml = `
  <MESSAGEACK>
    <Err Code="52992" Desc="UserName Password Incorrect"/>
  </MESSAGEACK>
`;

const fetchMock = vi.fn().mockImplementation((url, options) => {
  if (url.includes('/token')) {
    return Promise.resolve({
      ok: true,
      json: () => Promise.resolve(tokenResponse),
    });
  }
  return Promise.resolve({
    ok: true,
    text: () => Promise.resolve(errorXml),
  });
});

global.fetch = fetchMock;

await expect(
  provider.sendMessage({
    content: 'hello',
    to: '919876543210',
  })
).rejects.toThrow('ValueFirst API Error: UserName Password Incorrect (Code: 52992)');

});

test('should throw a descriptive error on message/sequence error', async () => {
const tokenResponse = {
token: 'test-token',
expiryDate: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000).toISOString(),
};

const errorXml = `
  <MESSAGEACK>
    <GUID GUID="some-guid" ID="1">
      <ERROR SEQ="1" CODE="28682"/>
    </GUID>
  </MESSAGEACK>
`;

const fetchMock = vi.fn().mockImplementation((url, options) => {
  if (url.includes('/token')) {
    return Promise.resolve({
      ok: true,
      json: () => Promise.resolve(tokenResponse),
    });
  }
  return Promise.resolve({
    ok: true,
    text: () => Promise.resolve(errorXml),
  });
});

global.fetch = fetchMock;

await expect(
  provider.sendMessage({
    content: 'hello',
    to: '919876543210',
  })
).rejects.toThrow('ValueFirst Message Error: Code 28682');

});

test('should get message ID correctly', () => {
const singleBody = {
guid: 'kb4jc4334130a5f461209l7t17',
status: 'DELIVERED',
};
expect(provider.getMessageId(singleBody)).toEqual(['kb4jc4334130a5f461209l7t17']);

const arrayBody = [
  { msgid: 'guid-1', status: 'SENT' },
  { messageId: 'guid-2', status: 'DELIVERED' },
];
expect(provider.getMessageId(arrayBody)).toEqual(['guid-1', 'guid-2']);

});

test('should parse webhook callback correctly', () => {
const webhookBody = {
guid: 'kb4jc4334130a5f461209l7t17',
status: 'DELIVERED',
attempt: '2',
response: 'Success',
};

const result = provider.parseEventBody(webhookBody, 'kb4jc4334130a5f461209l7t17');

expect(result).toEqual({
  status: SmsEventStatusEnum.DELIVERED,
  date: expect.any(String),
  externalId: 'kb4jc4334130a5f461209l7t17',
  attempts: 2,
  response: 'Success',
  row: webhookBody,
});

});

test('should map DLR statuses correctly', () => {
const parse = (status: string) => {
const body = {
guid: 'test-guid',
status,
};
return provider.parseEventBody(body, 'test-guid');
};

expect(parse('DELIVERED')?.status).toBe(SmsEventStatusEnum.DELIVERED);
expect(parse('NOT_DELIVERED')?.status).toBe(SmsEventStatusEnum.UNDELIVERED);
expect(parse('QUEUED')?.status).toBe(SmsEventStatusEnum.QUEUED);
expect(parse('SENT')?.status).toBe(SmsEventStatusEnum.SENT);
expect(parse('FAILED')?.status).toBe(SmsEventStatusEnum.FAILED);
expect(parse('REJECTED')?.status).toBe(SmsEventStatusEnum.REJECTED);
expect(parse('UNKNOWN')).toBeUndefined();

});
});

3. Generic Handler Factory
File: libs/application-generic/src/factories/sms/handlers/valuefirst.handler.ts

import { ValueFirstSmsProvider } from '@novu/providers';
import { ChannelTypeEnum, ICredentials, SmsProviderIdEnum } from '@novu/shared';
import { BaseSmsHandler } from './base.handler';

export class ValueFirstSmsHandler extends BaseSmsHandler {
constructor() {
super(SmsProviderIdEnum.ValueFirst, ChannelTypeEnum.SMS);
}

buildProvider(credentials: ICredentials) {
this.provider = new ValueFirstSmsProvider({
username: credentials.user,
password: credentials.password,
from: credentials.from,
});
}
}

4. Monorepo Integration Modifications
To stitch the provider into the monorepo registry, apply the following changes:

A. @novu/shared modifications
packages/shared/src/types/providers.ts

export enum SmsProviderIdEnum {
// ...
CmTelecom = 'cm-telecom',

• ValueFirst = 'valuefirst',
  }

packages/shared/src/consts/providers/credentials/provider-credentials.ts

export const valuefirstConfig: IConfigCredential[] = [
{
key: CredentialsKeyEnum.User,
displayName: 'Username',
type: 'string',
required: true,
},
{
key: CredentialsKeyEnum.Password,
displayName: 'Password',
type: 'string',
required: true,
},
...smsConfigBase,
];

packages/shared/src/consts/providers/channels/sms.ts

import {
// ...

• valuefirstConfig,
  } from '../credentials';

export const smsProviders: IProviderConfig[] = [
// ...

• {
• id: SmsProviderIdEnum.ValueFirst,
• displayName: 'ValueFirst',
• channel: ChannelTypeEnum.SMS,
• credentials: valuefirstConfig,
• docReference: 'https://product-user-guide.vfirst.com/xml/',
• logoFileName: { light: 'valuefirst.svg', dark: 'valuefirst.svg' },
• },
  ];

B. @novu/framework modifications
packages/framework/src/shared.ts

export enum SmsProviderIdEnum {
// ...

• ValueFirst = 'valuefirst',
  }

packages/framework/src/schemas/providers/sms/index.ts
export const smsProviderSchemas = {
// ...

• valuefirst: genericProviderSchemas,
  } as const satisfies Record<SmsProviderIdEnum, { output: JsonSchema }>;

C. @novu/providers and @novu/application-generic mappings
packages/providers/src/lib/sms/index.ts

typescript
export * from './unifonic/unifonic.provider';
+export * from './valuefirst/valuefirst.provider';
libs/application-generic/src/factories/sms/handlers/index.ts

typescript
export * from './unifonic.handler';
+export * from './valuefirst.handler';
libs/application-generic/src/factories/sms/sms.factory.ts

typescript
import {
// ...
UnifonicHandler,

• ValueFirstSmsHandler,
  } from './handlers';
  export class SmsFactory implements ISmsFactory {
  handlers: ISmsHandler[] = [
  // ...
  new CmTelecomHandler(),
• new ValueFirstSmsHandler(),
  ];
  }