backend-manager 5.0.149 → 5.0.151

package/CHANGELOG.md

@@ -14,6 +14,19 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 - `Fixed` for any bug fixes.
 - `Security` in case of vulnerabilities.
 
+# [5.0.150] - 2026-03-16
+### Added
+- `marketing` config section in `backend-manager-config.json` — per-brand control over SendGrid and Beehiiv provider availability
+- Beehiiv provider reads `publicationId` from config (skips fuzzy-match API call) with in-memory cache
+
+### Changed
+- Provider availability resolved once in Marketing constructor from `config.marketing` + env vars instead of per-request
+- Removed `providers` parameter from `add()`, `sync()`, `remove()` and all route/schema callers
+
+### Removed
+- `DEFAULT_PROVIDERS` constant — no longer needed with config-driven provider resolution
+- Provider-selection tests — no longer applicable
+
 # [5.0.149] - 2026-03-14
 ### Added
 - Modular email library (`libraries/email/`) — replaces monolithic `libraries/email.js` with provider-based architecture

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "backend-manager",
-  "version": "5.0.149",
+  "version": "5.0.151",
   "description": "Quick tools for developing Firebase functions",
   "main": "src/manager/index.js",
   "bin": {

package/src/manager/functions/core/actions/api/general/add-marketing-contact.js

@@ -29,7 +29,6 @@ Module.prototype.main = function () {
 
     // Admin-only options
     const tags = isAdmin ? (requestPayload.tags || []) : [];
-    const providers = isAdmin ? (requestPayload.providers || ['sendgrid', 'beehiiv']) : ['sendgrid', 'beehiiv'];
     const skipValidation = isAdmin ? (requestPayload.skipValidation || false) : false;
 
     // Validate email is provided
@@ -96,10 +95,12 @@ Module.prototype.main = function () {
 
     // Infer name if not provided
     let nameInferred = null;
+    let company = '';
     if (!firstName && !lastName) {
       nameInferred = await inferContact(email, assistant);
       firstName = nameInferred.firstName;
       lastName = nameInferred.lastName;
+      company = nameInferred.company;
     }
 
     // Add to providers
@@ -113,8 +114,8 @@ Module.prototype.main = function () {
         email,
         firstName,
         lastName,
+        company,
         source,
-        providers,
       });
     }
 

package/src/manager/functions/core/actions/api/general/remove-marketing-contact.js

@@ -22,7 +22,6 @@ Module.prototype.main = function () {
 
     // Extract parameters
     const email = (requestPayload.email || '').trim().toLowerCase();
-    const providers = requestPayload.providers || ['sendgrid', 'beehiiv'];
 
     // Validate email is provided
     if (!email) {
@@ -31,7 +30,7 @@ Module.prototype.main = function () {
 
     // Remove from providers
     const mailer = Manager.Email(assistant);
-    const providerResults = await mailer.remove(email, { providers });
+    const providerResults = await mailer.remove(email);
 
     // Log result
     assistant.log('remove-marketing-contact result:', {

package/src/manager/libraries/email/constants.js

@@ -84,8 +84,6 @@ const SENDERS = {
   },
 };
 
-// Default marketing providers — SSOT for all provider loops
-const DEFAULT_PROVIDERS = ['sendgrid', 'beehiiv'];
 
 // SendGrid limit for scheduled emails (72 hours, but use 71 for buffer)
 const SEND_AT_LIMIT = 71;
@@ -146,6 +144,7 @@ const FIELDS = {
 
   // User identity
   user_auth_uid:                         { source: 'user', path: 'auth.uid', type: 'text' },
+  user_personal_company:                 { source: 'user', path: 'personal.company.name', type: 'text' },
   user_personal_country:                 { source: 'user', path: 'personal.location.country', type: 'text' },
   user_metadata_signup_date:             { source: 'user', path: 'metadata.created.timestamp', type: 'date' },
   user_metadata_last_activity:           { source: 'user', path: 'metadata.updated.timestamp', type: 'date' },
@@ -234,7 +233,6 @@ module.exports = {
   GROUPS,
   SENDERS,
   FIELDS,
-  DEFAULT_PROVIDERS,
   SEND_AT_LIMIT,
   sanitizeImagesForEmail,
   encode,

package/src/manager/libraries/email/index.js

@@ -74,16 +74,9 @@ Email.prototype.build = function (settings) {
 };
 
 /**
- * Sync a user's data to marketing providers (SendGrid + Beehiiv).
+ * Add a new contact to enabled marketing providers (lightweight, no full user doc needed).
  *
- * @param {object} userDoc - Full user document from Firestore
- * @param {object} [options] - { providers: array of provider names (default: DEFAULT_PROVIDERS) }
- * @returns {{ sendgrid?: object, beehiiv?: object }}
- */
-/**
- * Add a new contact to marketing providers (lightweight, no full user doc needed).
- *
- * @param {object} options - { email, firstName, lastName, source, customFields, providers }
+ * @param {object} options - { email, firstName, lastName, source, customFields }
  * @returns {{ sendgrid?: object, beehiiv?: object }}
  */
 Email.prototype.add = function (options) {
@@ -91,25 +84,23 @@ Email.prototype.add = function (options) {
 };
 
 /**
- * Sync a user's full data to marketing providers (SendGrid + Beehiiv).
+ * Sync a user's full data to enabled marketing providers.
  *
- * @param {object} userDoc - Full user document from Firestore
- * @param {object} [options] - { providers: array of provider names (default: DEFAULT_PROVIDERS) }
+ * @param {string|object} userDocOrUid - UID string or full user document from Firestore
  * @returns {{ sendgrid?: object, beehiiv?: object }}
  */
-Email.prototype.sync = function (userDoc, options) {
-  return this._marketing.sync(userDoc, options);
+Email.prototype.sync = function (userDocOrUid) {
+  return this._marketing.sync(userDocOrUid);
 };
 
 /**
- * Remove a contact from all marketing providers.
+ * Remove a contact from all enabled marketing providers.
  *
  * @param {string} email - Email address to remove
- * @param {object} [options] - { providers: array of provider names (default: DEFAULT_PROVIDERS) }
  * @returns {{ sendgrid?: object, beehiiv?: object }}
  */
-Email.prototype.remove = function (email, options) {
-  return this._marketing.remove(email, options);
+Email.prototype.remove = function (email) {
+  return this._marketing.remove(email);
 };
 
 /**

package/src/manager/libraries/email/marketing/index.js

@@ -25,7 +25,7 @@
  */
 const _ = require('lodash');
 
-const { TEMPLATES, GROUPS, SENDERS, DEFAULT_PROVIDERS } = require('../constants.js');
+const { TEMPLATES, GROUPS, SENDERS } = require('../constants.js');
 const sendgridProvider = require('../providers/sendgrid.js');
 const beehiivProvider = require('../providers/beehiiv.js');
 
@@ -36,11 +36,19 @@ function Marketing(assistant) {
   self.Manager = assistant.Manager;
   self.admin = self.Manager.libraries.admin;
 
+  // Resolve provider availability from config + env
+  const marketing = self.Manager.config?.marketing || {};
+
+  self.providers = {
+    sendgrid: marketing.sendgrid?.enabled !== false && !!process.env.SENDGRID_API_KEY,
+    beehiiv: marketing.beehiiv?.enabled !== false && !!process.env.BEEHIIV_API_KEY,
+  };
+
   return self;
 }
 
 /**
- * Add a new contact to all providers (lightweight — no full user doc needed).
+ * Add a new contact to enabled providers (lightweight — no full user doc needed).
  * Used by newsletter subscribe and admin bulk import.
  *
  * @param {object} options
@@ -49,49 +57,47 @@ function Marketing(assistant) {
  * @param {string} [options.lastName]
  * @param {string} [options.source] - UTM source
  * @param {object} [options.customFields] - Extra SendGrid custom fields (keyed by field ID)
- * @param {Array<string>} [options.providers] - Which providers (default: all available)
  * @returns {{ sendgrid?: object, beehiiv?: object }}
  */
 Marketing.prototype.add = async function (options) {
   const self = this;
   const assistant = self.assistant;
-  const { email, firstName, lastName, source, customFields, providers } = options;
+  const { email, firstName, lastName, company, source, customFields } = options;
 
   if (!email) {
     assistant.warn('Marketing.add(): No email provided, skipping');
     return {};
   }
 
-  const shouldAdd = !assistant.isTesting() || process.env.TEST_EXTENDED_MODE;
-  const addProviders = providers || DEFAULT_PROVIDERS;
-  const results = {};
-
-  if (!shouldAdd) {
+  if (assistant.isTesting() && !process.env.TEST_EXTENDED_MODE) {
     assistant.log('Marketing.add(): Skipping providers (testing mode)');
-    return results;
+    return {};
   }
 
   assistant.log('Marketing.add():', { email });
 
+  const results = {};
   const promises = [];
 
-  if (addProviders.includes('sendgrid') && process.env.SENDGRID_API_KEY) {
+  if (self.providers.sendgrid) {
     promises.push(
       sendgridProvider.addContact({
         email,
         firstName,
         lastName,
+        company,
         customFields,
       }).then((r) => { results.sendgrid = r; })
     );
   }
 
-  if (addProviders.includes('beehiiv') && process.env.BEEHIIV_API_KEY) {
+  if (self.providers.beehiiv) {
     promises.push(
       beehiivProvider.addContact({
         email,
         firstName,
         lastName,
+        company,
         source,
       }).then((r) => { results.beehiiv = r; })
     );
@@ -109,14 +115,11 @@ Marketing.prototype.add = async function (options) {
  * Upserts the contact with all custom fields derived from the user doc.
  *
  * @param {string|object} userDocOrUid - UID string (fetches from Firestore) or full user document object
- * @param {object} [options]
- * @param {Array<string>} [options.providers] - Which providers to sync to (default: all available)
  * @returns {{ sendgrid?: object, beehiiv?: object }}
  */
-Marketing.prototype.sync = async function (userDocOrUid, options) {
+Marketing.prototype.sync = async function (userDocOrUid) {
   const self = this;
   const assistant = self.assistant;
-  const { providers } = options || {};
 
   // Resolve UID to user doc if string
   let userDoc;
@@ -145,13 +148,9 @@ Marketing.prototype.sync = async function (userDocOrUid, options) {
     return {};
   }
 
-  const shouldSync = !assistant.isTesting() || process.env.TEST_EXTENDED_MODE;
-  const syncProviders = providers || DEFAULT_PROVIDERS;
-  const results = {};
-
-  if (!shouldSync) {
+  if (assistant.isTesting() && !process.env.TEST_EXTENDED_MODE) {
     assistant.log('Marketing.sync(): Skipping providers (testing mode)');
-    return results;
+    return {};
   }
 
   assistant.log('Marketing.sync():', { email });
@@ -159,9 +158,10 @@ Marketing.prototype.sync = async function (userDocOrUid, options) {
   const firstName = _.get(userDoc, 'personal.name.first');
   const lastName = _.get(userDoc, 'personal.name.last');
   const source = _.get(userDoc, 'attribution.utm.tags.utm_source');
+  const results = {};
   const promises = [];
 
-  if (syncProviders.includes('sendgrid') && process.env.SENDGRID_API_KEY) {
+  if (self.providers.sendgrid) {
     promises.push(
       sendgridProvider.buildFields(userDoc).then((customFields) =>
         sendgridProvider.addContact({
@@ -174,7 +174,7 @@ Marketing.prototype.sync = async function (userDocOrUid, options) {
     );
   }
 
-  if (syncProviders.includes('beehiiv') && process.env.BEEHIIV_API_KEY) {
+  if (self.providers.beehiiv) {
     promises.push(
       beehiivProvider.addContact({
         email,
@@ -194,38 +194,33 @@ Marketing.prototype.sync = async function (userDocOrUid, options) {
 };
 
 /**
- * Remove a contact from all providers.
+ * Remove a contact from all enabled providers.
  *
  * @param {string} email - Email address to remove
- * @param {object} [options]
- * @param {Array<string>} [options.providers] - Which providers to remove from (default: all available)
  * @returns {{ sendgrid?: object, beehiiv?: object }}
  */
-Marketing.prototype.remove = async function (email, options) {
+Marketing.prototype.remove = async function (email) {
   const self = this;
   const assistant = self.assistant;
-  const { providers } = options || {};
 
   if (!email) {
     assistant.warn('Marketing.remove(): No email provided, skipping');
     return {};
   }
 
-  const removeProviders = providers || DEFAULT_PROVIDERS;
-  const results = {};
-
   assistant.log('Marketing.remove():', { email });
 
+  const results = {};
   const promises = [];
 
-  if (removeProviders.includes('sendgrid') && process.env.SENDGRID_API_KEY) {
+  if (self.providers.sendgrid) {
     promises.push(
       sendgridProvider.removeContact(email)
         .then((r) => { results.sendgrid = r; })
     );
   }
 
-  if (removeProviders.includes('beehiiv') && process.env.BEEHIIV_API_KEY) {
+  if (self.providers.beehiiv) {
     promises.push(
       beehiivProvider.removeContact(email)
         .then((r) => { results.beehiiv = r; })
@@ -259,8 +254,8 @@ Marketing.prototype.sendCampaign = async function (settings) {
   const Manager = self.Manager;
   const assistant = self.assistant;
 
-  if (!process.env.SENDGRID_API_KEY) {
-    return { success: false, error: 'SENDGRID_API_KEY not set' };
+  if (!self.providers.sendgrid) {
+    return { success: false, error: 'SendGrid not enabled' };
   }
 
   const templateId = TEMPLATES[settings.template] || settings.template || TEMPLATES['default'];

package/src/manager/libraries/email/providers/beehiiv.js

@@ -136,7 +136,22 @@ async function removeSubscriber(email, publicationId) {
  * @param {string} brandName
  * @returns {string|null} Publication ID or null
  */
+let _publicationIdCache = null;
+
 async function getPublicationId() {
+  if (_publicationIdCache) {
+    return _publicationIdCache;
+  }
+
+  // Use publicationId from config if set (skips API call)
+  const configPubId = Manager.config?.marketing?.beehiiv?.publicationId;
+
+  if (configPubId) {
+    _publicationIdCache = configPubId;
+    return configPubId;
+  }
+
+  // Fuzzy-match by brand name
   const brandName = Manager.config.brand?.name;
 
   if (!brandName) {
@@ -168,6 +183,7 @@ async function getPublicationId() {
       );
 
       if (matchedPub) {
+        _publicationIdCache = matchedPub.id;
         return matchedPub.id;
       }
 
@@ -199,20 +215,25 @@ async function getPublicationId() {
  * @param {Array<{name: string, value: string}>} [options.customFields] - Pre-built custom fields
  * @returns {{ success: boolean, id?: string, error?: string }}
  */
-async function addContact({ email, firstName, lastName, source, customFields }) {
+async function addContact({ email, firstName, lastName, company, source, customFields }) {
   const publicationId = await getPublicationId();
 
   if (!publicationId) {
     return { success: false, error: 'Publication not found' };
   }
 
+  const fields = [...(customFields || [])];
+  if (company) {
+    fields.push({ name: 'company', value: company });
+  }
+
   return addSubscriber({
     email,
     firstName,
     lastName,
     source,
     publicationId,
-    customFields: customFields || [],
+    customFields: fields,
   });
 }
 

package/src/manager/libraries/email/providers/sendgrid.js

@@ -370,7 +370,7 @@ async function listSingleSends(options) {
  * @param {object} [options.customFields] - Pre-built custom_fields object (keyed by SendGrid field IDs)
  * @returns {{ success: boolean, jobId?: string, listId?: string, error?: string }}
  */
-async function addContact({ email, firstName, lastName, customFields }) {
+async function addContact({ email, firstName, lastName, company, customFields }) {
   const contact = {
     email: email.toLowerCase(),
     first_name: firstName || undefined,
@@ -378,6 +378,15 @@ async function addContact({ email, firstName, lastName, customFields }) {
     custom_fields: customFields || {},
   };
 
+  // Add company to custom fields if provided (requires field provisioned via OMEGA)
+  if (company) {
+    const idMap = await resolveFieldIds();
+    const companyFieldId = idMap['user_personal_company'];
+    if (companyFieldId) {
+      contact.custom_fields[companyFieldId] = company;
+    }
+  }
+
   const listId = await getListId();
   const result = await upsertContacts({
     contacts: [contact],

package/src/manager/libraries/infer-contact.js

@@ -31,12 +31,14 @@ const GENERIC_DOMAINS = new Set([
 async function inferContact(email, assistant) {
   if (process.env.BACKEND_MANAGER_OPENAI_API_KEY) {
     const aiResult = await inferContactWithAI(email, assistant);
-    if (aiResult && (aiResult.firstName || aiResult.lastName)) {
+    if (aiResult) {
       return aiResult;
     }
   }
 
-  return inferContactFromEmail(email);
+  // TODO: Re-enable regex fallback if needed
+  // return inferContactFromEmail(email);
+  return { firstName: '', lastName: '', company: '', confidence: 0, method: 'none' };
 }
 
 /**
@@ -48,7 +50,7 @@ async function inferContact(email, assistant) {
  */
 async function inferContactWithAI(email, assistant) {
   try {
-    const ai = assistant.Manager.AI(assistant);
+    const ai = assistant.Manager.AI(assistant, process.env.BACKEND_MANAGER_OPENAI_API_KEY);
     const result = await ai.request({
       model: 'gpt-5-mini',
       timeout: 30000,
@@ -63,12 +65,13 @@ async function inferContactWithAI(email, assistant) {
       },
     });
 
-    if (result?.firstName !== undefined) {
+    const parsed = result?.content;
+    if (parsed?.firstName !== undefined) {
       return {
-        firstName: capitalize(result.firstName || ''),
-        lastName: capitalize(result.lastName || ''),
-        company: capitalize(result.company || ''),
-        confidence: typeof result.confidence === 'number' ? result.confidence : 0.5,
+        firstName: capitalize(parsed.firstName || ''),
+        lastName: capitalize(parsed.lastName || ''),
+        company: capitalize(parsed.company || ''),
+        confidence: typeof parsed.confidence === 'number' ? parsed.confidence : 0.5,
         method: 'ai',
       };
     }

package/src/manager/libraries/prompts/infer-contact.md

@@ -1,9 +1,19 @@
 <identity>
-You extract names and company from email addresses.
+You extract real human names and company from email addresses.
 </identity>
 
+<rules>
+- Only return a name if it is a REAL human name. If the local part contains placeholder text, gibberish, generic words, or fictional/brand names, return empty strings for firstName and lastName.
+- Placeholder/test examples that are NOT real names: firstname.lastname, first.last, asdf.qwerty, test.user, mixed.case, bobs.burgers, john.doe (this is a well-known placeholder)
+- Generic role words are NOT names: admin, info, support, hello, contact, sales, billing, noreply, webmaster, postmaster, dev, ceo
+- Single letters or initials ARE acceptable (e.g., "j" from j@company.com → firstName: "J")
+- ALWAYS infer company from the domain, even when there is no name. Generic email providers (gmail.com, yahoo.com, hotmail.com, outlook.com, aol.com, icloud.com, mail.com, protonmail.com, proton.me, zoho.com, yandex.com, gmx.com, live.com, msn.com, me.com) should return empty company.
+- Hyphenated names should preserve capitalization on both parts (e.g., jean-pierre → Jean-Pierre)
+- confidence should reflect how certain you are that the name is a REAL person's name. Placeholders and gibberish should never have confidence above 0.
+</rules>
+
 <format>
-Return ONLY valid JSON like so:
+Return ONLY valid JSON:
 {
   "firstName": "...",
   "lastName": "...",
@@ -11,12 +21,12 @@ Return ONLY valid JSON like so:
   "confidence": "..."
 }
 
-- firstName: First name (string), capitalized
-- lastName: Last name (string), capitalized
-- company: Company name (string), capitalized
-- confidence: Confidence level (number), 0-1 scale
+- firstName: First name (string), properly capitalized
+- lastName: Last name (string), properly capitalized
+- company: Company name (string), capitalized. Infer from domain (not generic providers).
+- confidence: Confidence level (number), 0-1 scale. How sure you are the name is real.
 
-If you cannot determine a name, use empty strings.
+If you cannot determine a real name, use empty strings for firstName and lastName.
 </format>
 
 <examples>
@@ -30,7 +40,7 @@ If you cannot determine a name, use empty strings.
 </example>
 <example>
 <input>support@bigcorp.io</input>
-<output>{"firstName": "", "lastName": "", "company": "Bigcorp", "confidence": 0.7}</output>
+<output>{"firstName": "", "lastName": "", "company": "Bigcorp", "confidence": 0}</output>
 </example>
 <example>
 <input>mary_jane_watson@stark-industries.com</input>
@@ -38,6 +48,26 @@ If you cannot determine a name, use empty strings.
 </example>
 <example>
 <input>info@company.org</input>
-<output>{"firstName": "", "lastName": "", "company": "Company", "confidence": 0.6}</output>
+<output>{"firstName": "", "lastName": "", "company": "Company", "confidence": 0}</output>
+</example>
+<example>
+<input>firstname.lastname@company.com</input>
+<output>{"firstName": "", "lastName": "", "company": "Company", "confidence": 0}</output>
+</example>
+<example>
+<input>asdf.qwerty@outlook.com</input>
+<output>{"firstName": "", "lastName": "", "company": "", "confidence": 0}</output>
+</example>
+<example>
+<input>jean-pierre.dupont@orange.fr</input>
+<output>{"firstName": "Jean-Pierre", "lastName": "Dupont", "company": "Orange", "confidence": 0.95}</output>
+</example>
+<example>
+<input>bobs.burgers@example.com</input>
+<output>{"firstName": "", "lastName": "", "company": "Example", "confidence": 0}</output>
+</example>
+<example>
+<input>j@company.com</input>
+<output>{"firstName": "J", "lastName": "", "company": "Company", "confidence": 0.3}</output>
 </example>
 </examples>

package/src/manager/routes/admin/infer-contact/post.js

@@ -0,0 +1,34 @@
+/**
+ * POST /admin/infer-contact - Infer contact info from email addresses
+ * Admin-only endpoint for testing/debugging the inferContact pipeline
+ */
+const { inferContact } = require('../../../libraries/infer-contact.js');
+
+module.exports = async ({ assistant, user, settings }) => {
+
+  // Require authentication
+  if (!user.authenticated) {
+    return assistant.respond('Authentication required', { code: 401 });
+  }
+
+  // Require admin
+  if (!user.roles.admin) {
+    return assistant.respond('Admin required.', { code: 403 });
+  }
+
+  // Accept single email or array of emails
+  const emails = Array.isArray(settings.emails)
+    ? settings.emails
+    : [settings.email];
+
+  const results = await Promise.all(
+    emails
+      .filter(Boolean)
+      .map(async (email) => {
+        const result = await inferContact(email, assistant);
+        return { email, ...result };
+      })
+  );
+
+  return assistant.respond({ results });
+};

package/src/manager/routes/marketing/contact/delete.js

@@ -18,7 +18,6 @@ module.exports = async ({ assistant, Manager, settings, analytics }) => {
 
   // Extract parameters
   const email = (settings.email || '').trim().toLowerCase();
-  const providers = settings.providers;
 
   // Validate email is provided
   if (!email) {
@@ -27,7 +26,7 @@ module.exports = async ({ assistant, Manager, settings, analytics }) => {
 
   // Remove from providers
   const mailer = Manager.Email(assistant);
-  const providerResults = await mailer.remove(email, { providers });
+  const providerResults = await mailer.remove(email);
 
   // Log result
   assistant.log('marketing/contact delete result:', {

package/src/manager/routes/marketing/contact/post.js

@@ -5,7 +5,6 @@
 const recaptcha = require('../../../libraries/recaptcha.js');
 const { validate: validateEmail, ALL_CHECKS } = require('../../../libraries/email/validation.js');
 const { inferContact } = require('../../../libraries/infer-contact.js');
-const { DEFAULT_PROVIDERS } = require('../../../libraries/email/constants.js');
 
 module.exports = async ({ assistant, Manager, settings, analytics }) => {
 
@@ -23,7 +22,6 @@ module.exports = async ({ assistant, Manager, settings, analytics }) => {
 
   // Admin-only options
   const tags = isAdmin ? settings.tags : [];
-  const providers = isAdmin ? settings.providers : DEFAULT_PROVIDERS;
   const skipValidation = isAdmin ? settings.skipValidation : false;
 
   // Email validation — run free checks before reCAPTCHA/rate limit
@@ -85,12 +83,14 @@ module.exports = async ({ assistant, Manager, settings, analytics }) => {
     }
   }
 
-  // Infer name if not provided
+  // Infer contact info if name not provided
   let nameInferred = null;
+  let company = '';
   if (!firstName && !lastName) {
     nameInferred = await inferContact(email, assistant);
     firstName = nameInferred.firstName;
     lastName = nameInferred.lastName;
+    company = nameInferred.company;
   }
 
   // Add to providers
@@ -104,8 +104,8 @@ module.exports = async ({ assistant, Manager, settings, analytics }) => {
       email,
       firstName,
       lastName,
+      company,
       source,
-      providers,
     });
   }
 

package/src/manager/schemas/admin/infer-contact/post.js

@@ -0,0 +1,12 @@
+module.exports = () => ({
+  email: {
+    types: ['string'],
+    default: '',
+    required: false,
+  },
+  emails: {
+    types: ['array'],
+    default: [],
+    required: false,
+  },
+});

package/src/manager/schemas/marketing/contact/delete.js

@@ -1,9 +1,6 @@
 /**
  * Schema for DELETE /marketing/contact
  */
-const { DEFAULT_PROVIDERS } = require('../../../libraries/email/constants.js');
-
 module.exports = () => ({
   email: { types: ['string'], default: undefined, required: true },
-  providers: { types: ['array'], default: DEFAULT_PROVIDERS },
 });

package/src/manager/schemas/marketing/contact/post.js

@@ -1,15 +1,12 @@
 /**
  * Schema for POST /marketing/contact
  */
-const { DEFAULT_PROVIDERS } = require('../../../libraries/email/constants.js');
-
 module.exports = () => ({
   email: { types: ['string'], default: undefined, required: true },
   firstName: { types: ['string'], default: '' },
   lastName: { types: ['string'], default: '' },
   source: { types: ['string'], default: 'unknown' },
   tags: { types: ['array'], default: [] },
-  providers: { types: ['array'], default: DEFAULT_PROVIDERS },
   skipValidation: { types: ['boolean'], default: false },
   'g-recaptcha-response': { types: ['string'], default: undefined },
 });

package/templates/backend-manager-config.json

@@ -122,6 +122,15 @@
       // Add more products/tiers here
     ],
   },
+  marketing: {
+    sendgrid: {
+      enabled: true,
+    },
+    beehiiv: {
+      enabled: false,
+      // publicationId: 'pub_xxxxx',  // Set to skip fuzzy-match API call
+    },
+  },
   firebaseConfig: {
     apiKey: '123-456',
     authDomain: 'PROJECT-ID.firebaseapp.com',

package/test/functions/general/add-marketing-contact.js

@@ -206,46 +206,7 @@ module.exports = {
       },
     },
 
-    // Test 7: Admin can specify providers
-    {
-      name: 'admin-specify-providers',
-      auth: 'admin',
-      timeout: 30000,
-
-      async run({ http, assert, config, state }) {
-        const testEmail = TEST_EMAILS.valid(config.domain);
-        state.testEmail = testEmail;
-
-        const response = await http.command('general:add-marketing-contact', {
-          email: testEmail,
-          source: 'bem-test',
-          providers: ['sendgrid'], // Only SendGrid, not Beehiiv
-          // No firstName/lastName - should be inferred as "Rachel Greene"
-        });
-
-        assert.isSuccess(response, 'Add marketing contact with specific providers should succeed');
-
-        // Only check providers if TEST_EXTENDED_MODE is set (external APIs are called)
-        if (process.env.TEST_EXTENDED_MODE) {
-          // Should only have sendgrid result
-          if (response.data?.providers) {
-            assert.hasProperty(response.data.providers, 'sendgrid', 'Should have SendGrid result');
-          }
-          state.sendgridAdded = response.data?.providers?.sendgrid?.success;
-          // Beehiiv not called since we only specified sendgrid
-        }
-      },
-
-      async cleanup({ state, http }) {
-        if (!process.env.TEST_EXTENDED_MODE || !state.testEmail) {
-          return;
-        }
-
-        await http.command('general:remove-marketing-contact', { email: state.testEmail });
-      },
-    },
-
-    // Test 8: Mailbox verification (only runs if TEST_EXTENDED_MODE and ZEROBOUNCE_API_KEY are set)
+    // Test 7: Mailbox verification (only runs if TEST_EXTENDED_MODE and ZEROBOUNCE_API_KEY are set)
     {
       name: 'mailbox-validation',
       auth: 'admin',

package/test/routes/admin/infer-contact.js

@@ -0,0 +1,195 @@
+/**
+ * Test: POST /admin/infer-contact
+ * Tests the admin infer-contact endpoint for inferring names from email addresses
+ *
+ * AI inference tests only run when TEST_EXTENDED_MODE is set (requires BACKEND_MANAGER_OPENAI_API_KEY)
+ */
+module.exports = {
+  description: 'Admin infer contact',
+  type: 'group',
+  tests: [
+    // ─── Auth rejection ───
+
+    {
+      name: 'unauthenticated-rejected',
+      auth: 'none',
+      timeout: 15000,
+
+      async run({ http, assert }) {
+        const response = await http.post('admin/infer-contact', {
+          email: 'john.smith@gmail.com',
+        });
+
+        assert.isError(response, 401, 'Should reject unauthenticated requests');
+      },
+    },
+
+    {
+      name: 'non-admin-rejected',
+      auth: 'user',
+      timeout: 15000,
+
+      async run({ http, assert }) {
+        const response = await http.post('admin/infer-contact', {
+          email: 'john.smith@gmail.com',
+        });
+
+        assert.isError(response, 403, 'Should reject non-admin users');
+      },
+    },
+
+    // ─── Single email ───
+
+    {
+      name: 'single-email-returns-result',
+      auth: 'admin',
+      timeout: 30000,
+
+      async run({ http, assert }) {
+        const response = await http.post('admin/infer-contact', {
+          email: 'john.smith@gmail.com',
+        });
+
+        assert.isSuccess(response, 'Should succeed for admin');
+        assert.hasProperty(response, 'data.results', 'Should have results array');
+        assert.equal(response.data.results.length, 1, 'Should have 1 result');
+
+        const result = response.data.results[0];
+        assert.equal(result.email, 'john.smith@gmail.com', 'Should include email');
+        assert.ok(result.firstName, 'Should infer a first name');
+        assert.ok(result.lastName, 'Should infer a last name');
+        assert.hasProperty(result, 'method', 'Should include method');
+        assert.hasProperty(result, 'confidence', 'Should include confidence');
+      },
+    },
+
+    // ─── Batch emails ───
+
+    {
+      name: 'batch-emails-returns-all-results',
+      auth: 'admin',
+      timeout: 60000,
+
+      async run({ http, assert }) {
+        const emails = [
+          'sarah.connor@skynet.io',
+          'bob-jones@hotmail.com',
+          'admin@acme.com',
+        ];
+
+        const response = await http.post('admin/infer-contact', { emails });
+
+        assert.isSuccess(response, 'Should succeed for batch');
+        assert.equal(response.data.results.length, 3, 'Should have 3 results');
+
+        // Verify each email is in results
+        for (let i = 0; i < emails.length; i++) {
+          assert.equal(response.data.results[i].email, emails[i], `Result ${i} should match input email`);
+        }
+      },
+    },
+
+    // ─── Name parsing (regex) ───
+
+    {
+      name: 'regex-parses-dot-separated-names',
+      auth: 'admin',
+      timeout: 30000,
+
+      async run({ http, assert }) {
+        const response = await http.post('admin/infer-contact', {
+          email: 'alice.wonderland@example.com',
+        });
+
+        assert.isSuccess(response);
+        const result = response.data.results[0];
+
+        // AI or regex — either way should get the name right
+        assert.equal(result.firstName, 'Alice', 'Should parse first name');
+        assert.equal(result.lastName, 'Wonderland', 'Should parse last name');
+      },
+    },
+
+    {
+      name: 'infers-company-from-custom-domain',
+      auth: 'admin',
+      timeout: 30000,
+
+      async run({ http, assert }) {
+        const response = await http.post('admin/infer-contact', {
+          email: 'ceo@my-startup.com',
+        });
+
+        assert.isSuccess(response);
+        const result = response.data.results[0];
+        assert.ok(result.company, 'Should infer company from custom domain');
+      },
+    },
+
+    {
+      name: 'no-company-from-generic-domain',
+      auth: 'admin',
+      timeout: 30000,
+
+      async run({ http, assert }) {
+        const response = await http.post('admin/infer-contact', {
+          email: 'someone@gmail.com',
+        });
+
+        assert.isSuccess(response);
+        const result = response.data.results[0];
+        assert.equal(result.company, '', 'Should not infer company from gmail');
+      },
+    },
+
+    // ─── AI inference (requires TEST_EXTENDED_MODE) ───
+
+    {
+      name: 'ai-inference',
+      auth: 'admin',
+      timeout: 60000,
+      skip: !process.env.TEST_EXTENDED_MODE
+        ? 'TEST_EXTENDED_MODE not set (skipping AI inference test)'
+        : false,
+
+      async run({ http, assert }) {
+        const response = await http.post('admin/infer-contact', {
+          emails: [
+            'john.smith@microsoft.com',
+            'xkcd42@gmail.com',
+            'bobs.burgers@example.com',
+          ],
+        });
+
+        assert.isSuccess(response, 'AI inference should succeed');
+
+        const results = response.data.results;
+        const aiResults = results.filter(r => r.method === 'ai');
+
+        assert.ok(aiResults.length > 0, 'At least one result should use AI method');
+
+        // john.smith should be parsed correctly regardless of method
+        const john = results.find(r => r.email === 'john.smith@microsoft.com');
+        assert.equal(john.firstName, 'John', 'Should infer John');
+        assert.equal(john.lastName, 'Smith', 'Should infer Smith');
+      },
+    },
+
+    // ─── Edge cases ───
+
+    {
+      name: 'empty-emails-array-returns-empty',
+      auth: 'admin',
+      timeout: 15000,
+
+      async run({ http, assert }) {
+        const response = await http.post('admin/infer-contact', {
+          emails: [],
+        });
+
+        assert.isSuccess(response);
+        assert.equal(response.data.results.length, 0, 'Empty input should return empty results');
+      },
+    },
+  ],
+};

package/test/routes/marketing/contact.js

@@ -208,44 +208,7 @@ module.exports = {
       },
     },
 
-    // Test 7: Admin can specify providers
-    {
-      name: 'add-admin-specify-providers',
-      auth: 'admin',
-      timeout: 30000,
-
-      async run({ http, assert, config, state }) {
-        const testEmail = TEST_EMAILS.valid(config.domain);
-        state.testEmail = testEmail;
-
-        const response = await http.post('marketing/contact', {
-          email: testEmail,
-          source: 'bem-test',
-          providers: ['sendgrid'], // Only SendGrid, not Beehiiv
-          // No firstName/lastName - should be inferred as "Rachel Greene"
-        });
-
-        assert.isSuccess(response, 'Add marketing contact with specific providers should succeed');
-
-        // Provider calls only happen in extended mode
-        if (process.env.TEST_EXTENDED_MODE) {
-          // Should only have sendgrid result (since we specified providers: ['sendgrid'])
-          assert.hasProperty(response.data.providers, 'sendgrid', 'Should have SendGrid result');
-          state.sendgridAdded = response.data?.providers?.sendgrid?.success;
-          // Beehiiv not called since we only specified sendgrid
-        }
-      },
-
-      async cleanup({ state, http }) {
-        if (!process.env.TEST_EXTENDED_MODE || !state.testEmail) {
-          return;
-        }
-
-        await http.delete('marketing/contact', { email: state.testEmail });
-      },
-    },
-
-    // Test 8: Mailbox verification (only runs if TEST_EXTENDED_MODE and ZEROBOUNCE_API_KEY are set)
+    // Test 7: Mailbox verification (only runs if TEST_EXTENDED_MODE and ZEROBOUNCE_API_KEY are set)
     {
       name: 'add-mailbox-validation',
       auth: 'admin',