@tellescope/sdk 1.255.3 → 1.255.5

package/src/tests/api_tests/healthie_multi_integration.test.ts

@@ -0,0 +1,245 @@
+require('source-map-support').install();
+
+import axios from "axios"
+import { Session } from "../../sdk"
+import {
+  async_test,
+  log_header,
+  wait,
+} from "@tellescope/testing"
+import { setup_tests } from "../setup"
+import { BUILT_INS_FOR_SET_FIELDS, HEALTHIE_TITLE } from "@tellescope/constants"
+
+const host = process.env.API_URL || 'http://localhost:8080' as const
+
+const TAG = 'clinic-two'
+const FORMSORT_TEST_KEY = '9d4f9dff00f60df2690a16da2cb848f289b447614ad9bef850e54af09a1fbf7a'
+
+export const healthie_multi_integration_tests = async ({ sdk, sdkNonAdmin } : { sdk: Session, sdkNonAdmin: Session }) => {
+  log_header("Multiple Healthie Integrations Tests")
+
+  const businessId = sdk.userInfo.businessId
+
+  let primaryIntegrationId = ''
+  let taggedIntegrationId = ''
+  let enduserId = ''
+  let formsortEnduserId = ''
+  let formId = ''
+
+  try {
+    // ── Set Fields support ────────────────────────────────────────────────────────────────────
+    if (!BUILT_INS_FOR_SET_FIELDS.includes('healthieIntegrationId')) {
+      throw new Error("healthieIntegrationId missing from BUILT_INS_FOR_SET_FIELDS")
+    }
+    console.log("✅ healthieIntegrationId exposed in BUILT_INS_FOR_SET_FIELDS")
+
+    // ── Create primary (untagged, sandbox-style key) + additional (tagged, production-style key)
+    // via the standard REST create endpoint — the real creation path for additional connections ──
+    const primary = await sdk.api.integrations.createOne({
+      title: HEALTHIE_TITLE,
+      disableEnduserAutoSync: true, // fake keys — avoid auto-sync attempts during the test
+      disableTicketAutoSync: true,
+      authentication: {
+        type: 'apiKey',
+        info: { access_token: 'gh_sbox_fake_primary_key', refresh_token: 'unused', scope: '', token_type: 'Bearer', expiry_date: 0 },
+      },
+    })
+    primaryIntegrationId = primary.id
+
+    const tagged = await sdk.api.integrations.createOne({
+      title: HEALTHIE_TITLE,
+      tenantId: TAG,
+      disableEnduserAutoSync: true,
+      disableTicketAutoSync: true,
+      authentication: {
+        type: 'apiKey',
+        info: { access_token: 'fake_production_key', refresh_token: 'unused', scope: '', token_type: 'Bearer', expiry_date: 0 },
+      },
+    })
+    taggedIntegrationId = tagged.id
+
+    if (tagged.tenantId !== TAG) {
+      throw new Error(`tenantId not persisted on create (got "${tagged.tenantId}")`)
+    }
+    console.log("✅ tenantId persists via standard integrations create")
+
+    // ── Per-connection settings: update_settings works against a tagged integration ──
+    await async_test(
+      "update_settings updates a tagged integration",
+      () => sdk.api.integrations.update_settings({ id: taggedIntegrationId, updates: { pushAddedTags: true } }),
+      { onResult: r => r.integration?.pushAddedTags === true },
+    )
+    await async_test(
+      "tagged integration settings persist independently",
+      () => sdk.api.integrations.getOne(taggedIntegrationId),
+      { onResult: i => i.pushAddedTags === true && i.tenantId === TAG },
+    )
+    await async_test(
+      "primary integration unaffected by tagged settings update",
+      () => sdk.api.integrations.getOne(primaryIntegrationId),
+      { onResult: i => !i.pushAddedTags },
+    )
+
+    // ── Organization.healthieIntegrationIds pushed by create side effect ──
+    await wait(undefined, 2000) // side effects are async
+    await async_test(
+      "organization.healthieIntegrationIds includes tag after create",
+      () => sdk.api.organizations.getOne(businessId),
+      { onResult: o => !!(o as any).healthieIntegrationIds?.includes(TAG) },
+    )
+
+    // ── Inbound webhook resolution (help page proves the integration lookup without network) ──
+    await async_test(
+      "webhook help page resolves primary (sandbox) without query param",
+      () => axios.get(`${host}/v1/webhooks/healthie/${businessId}`),
+      { onResult: r => typeof r.data === 'string' && r.data.startsWith('Sandbox') },
+    )
+    await async_test(
+      "webhook help page resolves tagged (production) integration via healthieIntegrationId param",
+      () => axios.get(`${host}/v1/webhooks/healthie/${businessId}?healthieIntegrationId=${TAG}`),
+      { onResult: r => typeof r.data === 'string' && r.data.startsWith('Production') },
+    )
+    await async_test(
+      "webhook help page rejects unknown healthieIntegrationId",
+      () => axios.get(`${host}/v1/webhooks/healthie/${businessId}?healthieIntegrationId=not-a-real-id`),
+      { shouldError: true, onError: (e: any) => e?.response?.status === 400 },
+    )
+
+    // ── Enduser field + one-org-per-patient lock (relationship constraint) ──
+    const enduser = await sdk.api.endusers.createOne({
+      email: 'multi-healthie-test@tellescope.com',
+      healthieIntegrationId: TAG,
+    })
+    enduserId = enduser.id
+    if (enduser.healthieIntegrationId !== TAG) {
+      throw new Error("healthieIntegrationId not persisted on enduser create")
+    }
+
+    await async_test(
+      "healthieIntegrationId freely changeable while unlinked",
+      () => sdk.api.endusers.updateOne(enduserId, { healthieIntegrationId: '' }),
+      { onResult: e => !e.healthieIntegrationId },
+    )
+    await async_test(
+      "healthieIntegrationId re-set while unlinked",
+      () => sdk.api.endusers.updateOne(enduserId, { healthieIntegrationId: TAG }),
+      { onResult: e => e.healthieIntegrationId === TAG },
+    )
+
+    // link the patient to Healthie (reference with a Healthie patient id)
+    await sdk.api.endusers.updateOne(enduserId, { references: [{ type: HEALTHIE_TITLE, id: '12345' }] } as any, { replaceObjectFields: true })
+
+    await async_test(
+      "healthieIntegrationId locked once a Healthie patient ID exists",
+      () => sdk.api.endusers.updateOne(enduserId, { healthieIntegrationId: 'somewhere-else' }),
+      { shouldError: true, onError: (e: any) => (e?.message || e?.toString() || '').includes('healthieIntegrationId') },
+    )
+    await async_test(
+      "no-op write of the same value still allowed while locked",
+      () => sdk.api.endusers.updateOne(enduserId, { healthieIntegrationId: TAG }),
+      { onResult: e => e.healthieIntegrationId === TAG },
+    )
+
+    // unlink → changeable again
+    await sdk.api.endusers.updateOne(enduserId, { references: [] } as any, { replaceObjectFields: true })
+    await async_test(
+      "healthieIntegrationId changeable again after unlinking",
+      () => sdk.api.endusers.updateOne(enduserId, { healthieIntegrationId: '' }),
+      { onResult: e => !e.healthieIntegrationId },
+    )
+
+    // ── Formsort mapping ──
+    const form = await sdk.api.forms.createOne({ title: "Multi Healthie FormSort" })
+    formId = form.id
+
+    const formsortEmail = 'multi-healthie-formsort@tellescope.com'
+    const postToFormsort = (answers: { key: string, value: any }[], responder_uuid: string) => {
+      const url = new URL(`${host}/v1/webhooks/formsort/${FORMSORT_TEST_KEY}`)
+      url.searchParams.set('formId', form.id)
+      return axios.post(url.toString(), { answers, responder_uuid, finalized: true })
+    }
+
+    await postToFormsort([
+      { key: 'email', value: formsortEmail },
+      { key: 'healthieIntegrationId', value: TAG },
+    ], "multi-healthie-1")
+
+    await async_test(
+      "formsort sets healthieIntegrationId on unlinked enduser",
+      () => sdk.api.endusers.getSome({ filter: { email: formsortEmail } }),
+      { onResult: es => {
+        const e = es.find(e => e.email === formsortEmail)
+        formsortEnduserId = e?.id || ''
+        return e?.healthieIntegrationId === TAG
+      }},
+    )
+
+    // link the formsort enduser, then attempt a relink via formsort — field change must be dropped
+    await sdk.api.endusers.updateOne(formsortEnduserId, { references: [{ type: HEALTHIE_TITLE, id: '6789' }] } as any, { replaceObjectFields: true })
+    await postToFormsort([
+      { key: 'email', value: formsortEmail },
+      { key: 'healthieIntegrationId', value: 'somewhere-else' },
+    ], "multi-healthie-2")
+    await wait(undefined, 1000)
+
+    await async_test(
+      "formsort relink attempt on linked enduser is dropped",
+      () => sdk.api.endusers.getOne(formsortEnduserId),
+      { onResult: e => e.healthieIntegrationId === TAG },
+    )
+    await async_test(
+      "formsort relink attempt logs a customer-visible background error",
+      () => sdk.api.background_errors.getSome(),
+      { onResult: errors => errors.some(e =>
+        e.title === "Healthie Integration Change Blocked" && e.enduserId === formsortEnduserId
+      )},
+    )
+
+    // ── Removing the primary must not affect the tagged integration; org list recomputes on delete ──
+    await sdk.api.integrations.deleteOne(primaryIntegrationId)
+    primaryIntegrationId = ''
+    await async_test(
+      "tagged integration survives primary deletion",
+      () => sdk.api.integrations.getOne(taggedIntegrationId),
+      { onResult: i => i.tenantId === TAG },
+    )
+
+    await sdk.api.integrations.deleteOne(taggedIntegrationId)
+    taggedIntegrationId = ''
+    await wait(undefined, 2000) // delete side effect is async
+    await async_test(
+      "organization.healthieIntegrationIds recomputed (emptied) after delete",
+      () => sdk.api.organizations.getOne(businessId),
+      { onResult: o => !(o as any).healthieIntegrationIds?.includes(TAG) },
+    )
+  } finally {
+    for (const id of [primaryIntegrationId, taggedIntegrationId]) {
+      if (!id) continue
+      await sdk.api.integrations.deleteOne(id).catch(console.error)
+    }
+    if (enduserId) await sdk.api.endusers.deleteOne(enduserId).catch(console.error)
+    if (formsortEnduserId) await sdk.api.endusers.deleteOne(formsortEnduserId).catch(console.error)
+    if (formId) await sdk.api.forms.deleteOne(formId).catch(console.error)
+  }
+}
+
+if (require.main === module) {
+  console.log(`Using API URL: ${host}`)
+  const sdk = new Session({ host })
+  const sdkNonAdmin = new Session({ host })
+
+  const runTests = async () => {
+    await setup_tests(sdk, sdkNonAdmin)
+    await healthie_multi_integration_tests({ sdk, sdkNonAdmin })
+  }
+
+  runTests()
+    .then(() => {
+      console.log("✅ Multiple Healthie integrations test suite completed successfully")
+      process.exit(0)
+    })
+    .catch((error) => {
+      console.error("❌ Multiple Healthie integrations test suite failed:", error)
+      process.exit(1)
+    })
+}

package/src/tests/api_tests/medication_added_trigger.test.ts

@@ -182,7 +182,7 @@ export const medication_added_trigger_tests = async ({ sdk, sdkNonAdmin } : { sd
     title: "Medication - Beluga Protocol Test"
   })
 
-  // Simulate the Beluga RX_WRITTEN webhook with two meds covering category present (typical) and "N/A"
+  // Simulate the Beluga RX_WRITTEN webhook with two meds covering category/pharmacyNotes present (typical) and "N/A"/absent
   const webhookResponse = await fetch(`${host}/v1/webhooks/beluga`, {
     method: 'POST',
     headers: { 'Content-Type': 'application/json' },
@@ -198,6 +198,7 @@ export const medication_added_trigger_tests = async ({ sdk, sdkNonAdmin } : { sd
         medId: 'test-ndc-123',
         rxId: 'test-rx-456',
         category: 'weightloss1',
+        pharmacyNotes: 'Dispense with syringes',
       }, {
         name: 'Metformin',
         strength: '500mg',
@@ -245,6 +246,16 @@ export const medication_added_trigger_tests = async ({ sdk, sdkNonAdmin } : { sd
     async () => belugaMedMetformin,
     { onResult: (m: EnduserMedication) => m?.category === 'N/A' }
   )
+  await async_test(
+    "Beluga RX_WRITTEN - Medication has notes from webhook pharmacyNotes",
+    async () => belugaMedSemaglutide,
+    { onResult: (m: EnduserMedication) => m?.notes === 'Dispense with syringes' }
+  )
+  await async_test(
+    "Beluga RX_WRITTEN - Medication omits notes when pharmacyNotes not provided on med",
+    async () => belugaMedMetformin,
+    { onResult: (m: EnduserMedication) => m?.notes === undefined || m?.notes === null }
+  )
 
   // Backwards-compatibility: a webhook with no category on any med should result in undefined category
   const belugaFormNoCategory = await sdk.api.forms.createOne({
@@ -294,6 +305,11 @@ export const medication_added_trigger_tests = async ({ sdk, sdkNonAdmin } : { sd
     async () => belugaMedNoCategory,
     { onResult: (m: EnduserMedication) => m?.category === undefined || m?.category === null }
   )
+  await async_test(
+    "Beluga RX_WRITTEN - Medication omits notes when pharmacyNotes not provided",
+    async () => belugaMedNoCategory,
+    { onResult: (m: EnduserMedication) => m?.notes === undefined || m?.notes === null }
+  )
 
   try {
     // Clean up Beluga test data
@@ -389,14 +405,56 @@ export const medication_added_trigger_tests = async ({ sdk, sdkNonAdmin } : { sd
     { onResult: (e: Enduser) => e.fields?.['Medication Category'] === '' }
   )
 
+  // ---- Set Fields with {{medication.notes}} Test ----
+  log_header("Medication Added - Set Fields with {{medication.notes}}")
+
+  const setFieldsPharmacyNotesTrigger = await sdk.api.automation_triggers.createOne({
+    event: { type: 'Medication Added', info: { titles: [], protocols: [] } },
+    action: { type: 'Set Fields', info: { fields: [{ name: 'Medication Notes', type: 'Custom Value' as const, value: '{{medication.notes}}' }] }},
+    status: 'Active',
+    title: "Medication - Set Fields medication.notes"
+  })
+
+  const setFieldsPharmacyNotesEnduser = await sdk.api.endusers.createOne({})
+
+  const setFieldsPharmacyNotesMed = await sdk.api.enduser_medications.createOne({
+    enduserId: setFieldsPharmacyNotesEnduser.id,
+    title: 'Ozempic 1mg',
+    notes: 'Dispense with syringes',
+  })
+  await wait(undefined, 500)
+
+  await async_test(
+    "Medication Added - Set Fields copies medication.notes to enduser field",
+    () => sdk.api.endusers.getOne(setFieldsPharmacyNotesEnduser.id),
+    { onResult: (e: Enduser) => e.fields?.['Medication Notes'] === 'Dispense with syringes' }
+  )
+
+  // notes absent on medication → placeholder resolves to empty string
+  const setFieldsPharmacyNotesEnduserEmpty = await sdk.api.endusers.createOne({})
+  const setFieldsPharmacyNotesMedEmpty = await sdk.api.enduser_medications.createOne({
+    enduserId: setFieldsPharmacyNotesEnduserEmpty.id,
+    title: 'Lisinopril 40mg',
+  })
+  await wait(undefined, 500)
+
+  await async_test(
+    "Medication Added - Set Fields with no notes resolves to empty string",
+    () => sdk.api.endusers.getOne(setFieldsPharmacyNotesEnduserEmpty.id),
+    { onResult: (e: Enduser) => e.fields?.['Medication Notes'] === '' }
+  )
+
   try {
     await sdk.api.automation_triggers.deleteOne(setFieldsTrigger.id)
     await sdk.api.automation_triggers.deleteOne(setFieldsTriggerFiltered.id)
     await sdk.api.automation_triggers.deleteOne(setFieldsCategoryTrigger.id)
+    await sdk.api.automation_triggers.deleteOne(setFieldsPharmacyNotesTrigger.id)
     await sdk.api.endusers.deleteOne(setFieldsEnduser.id)
     await sdk.api.endusers.deleteOne(setFieldsEnduser2.id)
     await sdk.api.endusers.deleteOne(setFieldsCategoryEnduser.id)
     await sdk.api.endusers.deleteOne(setFieldsCategoryEnduserEmpty.id)
+    await sdk.api.endusers.deleteOne(setFieldsPharmacyNotesEnduser.id)
+    await sdk.api.endusers.deleteOne(setFieldsPharmacyNotesEnduserEmpty.id)
   } finally {}
 
   // ---- titleCondition (compound conditional logic on title) ----

package/src/tests/api_tests/security/F-0005-ai-conversations-rbac.test.ts

@@ -28,6 +28,16 @@ const [nonAdminEmail, nonAdminPassword] = [process.env.NON_ADMIN_EMAIL, process.
  *   2. Assigns the role to the non-admin user.
  *   3. Calls each endpoint as the non-admin.
  *   4. Asserts each endpoint returns a 403-equivalent error (not 200).
+ *   5. Positive case: a role granting ai_conversations create (read/update denied) must pass
+ *      the send_message gate — generating a NEW conversation requires only create access.
+ *   6. But the same role must still 403 when passing a conversationId: continuing an existing
+ *      conversation reads its stored history (returned in the response) and appends to it,
+ *      so it requires read + update access in addition to create.
+ *   7. Default-provider-permissions role (ai_conversations = Assigned): send_message must not
+ *      500. Regression: the post-generation $push previously ran through the caller's
+ *      access-scoped DB, where "Assigned" filters can't match the just-created conversation,
+ *      returning null and crashing the handler (Cannot read properties of null '_id') after
+ *      credits were consumed. bedrock.ts now persists via tenant-scoped org-wide queries.
  *
  * Pre-fix:
  *   - send_message: 200 (or some downstream error from Bedrock) — NOT 403. Test fails.
@@ -39,7 +49,11 @@ export const ai_conversations_rbac_tests = async ({ sdk, sdkNonAdmin } : { sdk:
   log_header("F-0005: ai_conversations RBAC bypass regression")
 
   const roleName = `f0005-ai-conversations-no-access-${Date.now()}`
+  const grantRoleName = `f0005-ai-conversations-create-granted-${Date.now()}`
+  const assignedRoleName = `f0005-ai-conversations-assigned-default-${Date.now()}`
   let rbapId: string | undefined
+  let grantRbapId: string | undefined
+  let assignedRbapId: string | undefined
   const originalRoles = sdkNonAdmin.userInfo.roles
 
   try {
@@ -109,6 +123,109 @@ export const ai_conversations_rbac_tests = async ({ sdk, sdkNonAdmin } : { sdk:
         },
       },
     )
+
+    // 4. Positive case: granting only ai_conversations create must pass the RBAC gate.
+    //    send_message may still fail downstream (e.g. 400 "Organization has not set up credits"),
+    //    but it must NOT be an access-denial error.
+    const grantRbap = await sdk.api.role_based_access_permissions.createOne({
+      role: grantRoleName,
+      permissions: {
+        ...PROVIDER_PERMISSIONS,
+        ai_conversations: { create: 'All', read: null, update: null, delete: null },
+      },
+    })
+    grantRbapId = grantRbap.id
+
+    await sdk.api.users.updateOne(
+      sdkNonAdmin.userInfo.id,
+      { roles: [grantRoleName] },
+      { replaceObjectFields: true },
+    )
+    await wait(undefined, 1500)
+    await sdkNonAdmin.authenticate(nonAdminEmail!, nonAdminPassword!)
+
+    await async_test(
+      "F-0005: ai_conversations.send_message must NOT be access-denied when role grants create",
+      () => sdkNonAdmin.api.ai_conversations.send_message({
+        message: 'F-0005 positive-case test',
+        type: 'Test',
+        maxTokens: 1,
+      } as any)
+        .then(() => 'allowed' as const)
+        .catch((e: any) => {
+          const msg = (e?.message ?? '').toLowerCase()
+          const status = e?.status ?? e?.code
+          if (status === 403 || status === 401
+            || msg.includes('access') || msg.includes('permission') || msg.includes('forbidden')) {
+            throw e // access denial — the gate incorrectly blocked a create-granted role
+          }
+          return 'allowed' as const // downstream (e.g. credits) error is fine — the gate passed
+        }),
+      { onResult: r => r === 'allowed' },
+    )
+
+    // 5. The create-granted (read/update-denied) role must still be blocked from CONTINUING an
+    //    existing conversation — send_message with conversationId returns the full stored history
+    //    and appends to it. Fake id is fine: the access check must fire before any lookup.
+    await async_test(
+      "F-0005: ai_conversations.send_message with conversationId must 403 when role denies read/update",
+      () => sdkNonAdmin.api.ai_conversations.send_message({
+        message: 'F-0005 conversationId bypass test',
+        type: 'Test',
+        maxTokens: 1,
+        conversationId: new ObjectId().toHexString(),
+      } as any),
+      {
+        shouldError: true,
+        onError: (e: any) => {
+          const msg = (e?.message ?? '').toLowerCase()
+          const status = e?.status ?? e?.code
+          return status === 403 || status === 401
+            || msg.includes('access') || msg.includes('permission') || msg.includes('forbidden')
+        },
+      },
+    )
+
+    // 6. Regression: a role with default provider permissions (ai_conversations = Assigned)
+    //    must be able to generate a new conversation without a 500. Previously the
+    //    post-generation $push ran through the access-scoped DB, matched nothing under
+    //    "Assigned", and crashed the handler with "Cannot read properties of null ('_id')".
+    const assignedRbap = await sdk.api.role_based_access_permissions.createOne({
+      role: assignedRoleName,
+      permissions: { ...PROVIDER_PERMISSIONS },
+    })
+    assignedRbapId = assignedRbap.id
+
+    await sdk.api.users.updateOne(
+      sdkNonAdmin.userInfo.id,
+      { roles: [assignedRoleName] },
+      { replaceObjectFields: true },
+    )
+    await wait(undefined, 1500)
+    await sdkNonAdmin.authenticate(nonAdminEmail!, nonAdminPassword!)
+
+    await async_test(
+      "F-0005: ai_conversations.send_message must not 500 for Assigned-access (default provider) role",
+      () => sdkNonAdmin.api.ai_conversations.send_message({
+        message: 'F-0005 assigned-access regression test',
+        type: 'Test',
+        maxTokens: 1,
+      } as any)
+        .then(() => 'ok' as const)
+        .catch((e: any) => {
+          const msg = (e?.message ?? '').toLowerCase()
+          const status = e?.status ?? e?.code
+          if (status === 500 || msg.includes('internal error') || msg.includes('cannot read properties')) {
+            throw e // the null-update crash — regression
+          }
+          if (status === 403 || status === 401
+            || msg.includes('access') || msg.includes('permission') || msg.includes('forbidden')) {
+            throw e // Assigned access must pass the RBAC gate
+          }
+          return 'ok' as const // downstream (e.g. credits) error is fine
+        }),
+      { onResult: r => r === 'ok' },
+    )
   } finally {
     // Cleanup: restore original roles, delete the test role.
     try {
@@ -121,6 +238,12 @@ export const ai_conversations_rbac_tests = async ({ sdk, sdkNonAdmin } : { sdk:
     if (rbapId) {
       try { await sdk.api.role_based_access_permissions.deleteOne(rbapId) } catch {}
     }
+    if (grantRbapId) {
+      try { await sdk.api.role_based_access_permissions.deleteOne(grantRbapId) } catch {}
+    }
+    if (assignedRbapId) {
+      try { await sdk.api.role_based_access_permissions.deleteOne(assignedRbapId) } catch {}
+    }
     // Re-authenticate the non-admin to drop the no-access role from their JWT
     // before subsequent tests run.
     // Role restore above re-triggers deauthenticate_user; wait > 1s so the freshly minted

package/src/tests/tests.ts

@@ -39,6 +39,7 @@ import { enduser_observations_acknowledge_tests } from "./api_tests/enduser_obse
 import { translations_tests } from "./api_tests/translations.test"
 import { user_portal_settings_tests } from "./api_tests/user_portal_settings.test"
 import { integrations_redacted_tests } from "./api_tests/integrations_redacted.test"
+import { healthie_multi_integration_tests } from "./api_tests/healthie_multi_integration.test"
 import { get_some_projection_tests } from "./api_tests/get_some_projection.test"
 import { mdb_sort_tests } from "./api_tests/mdb_sort.test"
 import { create_user_notifications_trigger_tests } from "./api_tests/create_user_notifications_trigger.test"
@@ -15073,6 +15074,7 @@ const ip_address_form_tests = async () => {
     await openloop_webhooks_tests({ sdk, sdkNonAdmin })
     await mdi_webhooks_tests({ sdk, sdkNonAdmin })
     await integrations_redacted_tests({ sdk, sdkNonAdmin })
+    await healthie_multi_integration_tests({ sdk, sdkNonAdmin })
     await mdb_sort_tests({ sdk, sdkNonAdmin })
     await search_tests()
     await time_tracks_tests({ sdk, sdkNonAdmin })