@tellescope/sdk 2.0.0-beta.1 → 2.0.0-beta.3

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

@@ -1,11 +1,20 @@
 require('source-map-support').install();
 
-import { Session, EnduserSession } from "../../sdk"
+import { EnduserSession } from "../../sdk"
 import {
-  log_header,
+  poll_for_results,
   wait,
 } from "@tellescope/testing"
-import { setup_tests } from "../setup"
+import {
+  assert_checks,
+  Check,
+  IsolatedSuite,
+  setup_isolated_tenant,
+} from "../setup_isolated"
+
+const host = process.env.API_URL || 'http://localhost:8080' as const
+
+const RAND = () => Math.random().toString(36).slice(2, 10)
 
 /**
  * Tests for the "Outbound Chat Sent" automation trigger event.
@@ -16,8 +25,22 @@ import { setup_tests } from "../setup"
  *  3. Multi-enduser room,  inbound (one enduser's session)  → neither enduser tagged or stamped
  *  4. Multi-enduser room,  outbound (user session)          → BOTH endusers tagged + stamped
  *  5. User session, senderId = enduser.id (backfill case)   → treated as inbound: no trigger, no stamp
+ *  6. Autoreply chat (isAutoreply: true)                    → no trigger, no stamp
+ *
+ * Runs on its own provisioned tenant, which is not optional here for two reasons: the trigger it
+ * installs is ENTIRELY unfiltered (`info: {}`), so on the shared organization it tagged every
+ * outbound chat any concurrently running suite sent; and case 6 switches `outOfOfficeHours` and
+ * `settings.endusers.autoReplyEnabled` ON at the organization level, which made every other suite's
+ * inbound chats generate autoreplies while this one ran. It never calls `sdk.reset_db()`, which
+ * clears throttle namespaces shared with other suites.
+ *
+ * The org settings are deliberately NOT restored any more: they are this tenant's own settings, no
+ * other suite can observe them, and the tenant (organization record included) is deleted in the
+ * `finally`. For the same reason no record is deleted individually — teardown removes them all.
  *
- * Chats are NOT explicitly deleted — they cascade-delete from chat_rooms.
+ * The `wait` after each send is the trigger-processing barrier. The positive cases then poll, which
+ * returns immediately once the tag is visible; the "did NOT fire" cases read once after the same
+ * fixed wait, since polling a must-not-happen check only delays it.
  */
 
 const isRecent = (value: Date | string | undefined, sinceMs: number): boolean => {
@@ -26,45 +49,38 @@ const isRecent = (value: Date | string | undefined, sinceMs: number): boolean =>
   return t >= sinceMs - 1000 && t <= Date.now() + 1000
 }
 
-export const outbound_chat_sent_trigger_tests = async ({ sdk }: { sdk: Session }) => {
-  log_header("Outbound Chat Sent Trigger Tests")
+export const outbound_chat_sent_trigger_checks = async (): Promise<Check[]> => {
+  const checks: Check[] = []
+  const record = (label: string, pass: boolean, detail: string) => checks.push({ label, pass, detail })
 
-  const host = process.env.API_URL || 'http://localhost:8080'
   const TAG = `outbound-chat-sent-${Date.now()}`
 
-  let endSolo: { id: string } | undefined
-  let endA: { id: string } | undefined
-  let endB: { id: string } | undefined
-  let endBackfill: { id: string } | undefined
-  let endAutoreply: { id: string } | undefined
-
-  let trigger: { id: string } | undefined
-  let roomSolo: { id: string } | undefined
-  let roomGroup: { id: string } | undefined
-  let roomBackfill: { id: string } | undefined
-  let roomAutoreply: { id: string } | undefined
-
-  let settingsModified = false
-  let originalOutOfOfficeHours: any[] = []
-  let originalAutoReplyEnabled = false
+  let tenant: Awaited<ReturnType<typeof setup_isolated_tenant>> | undefined
 
   try {
+    tenant = await setup_isolated_tenant({
+      name: `Outbound Chat Sent trigger ${RAND()}`,
+      users: [{ isAdmin: true }],
+      apiKeys: 0,
+    })
+    const { sdk } = tenant
+
     // ── Endusers ──────────────────────────────────────────────────────
-    endSolo = await sdk.api.endusers.createOne({ fname: 'Solo', lname: 'Patient' })
-    endA = await sdk.api.endusers.createOne({ fname: 'GroupA', lname: 'Patient' })
-    endB = await sdk.api.endusers.createOne({ fname: 'GroupB', lname: 'Patient' })
-    endBackfill = await sdk.api.endusers.createOne({ fname: 'Backfill', lname: 'Patient' })
+    const endSolo = await sdk.api.endusers.createOne({ fname: 'Solo', lname: 'Patient' })
+    const endA = await sdk.api.endusers.createOne({ fname: 'GroupA', lname: 'Patient' })
+    const endB = await sdk.api.endusers.createOne({ fname: 'GroupB', lname: 'Patient' })
+    const endBackfill = await sdk.api.endusers.createOne({ fname: 'Backfill', lname: 'Patient' })
     console.log(`Created endusers: solo=${endSolo.id}, A=${endA.id}, B=${endB.id}, backfill=${endBackfill.id}`)
 
     // ── Enduser sessions for inbound sends ────────────────────────────
     const { authToken: tokenSolo } = await sdk.api.endusers.generate_auth_token({ id: endSolo.id })
-    const endSoloSDK = new EnduserSession({ host, authToken: tokenSolo, businessId: sdk.userInfo.businessId })
+    const endSoloSDK = new EnduserSession({ host, authToken: tokenSolo, businessId: tenant.businessId })
 
     const { authToken: tokenA } = await sdk.api.endusers.generate_auth_token({ id: endA.id })
-    const endASDK = new EnduserSession({ host, authToken: tokenA, businessId: sdk.userInfo.businessId })
+    const endASDK = new EnduserSession({ host, authToken: tokenA, businessId: tenant.businessId })
 
     // ── Trigger ───────────────────────────────────────────────────────
-    trigger = await sdk.api.automation_triggers.createOne({
+    const trigger = await sdk.api.automation_triggers.createOne({
       title: `Outbound Chat Sent Test ${Date.now()}`,
       status: 'Active',
       event: { type: 'Outbound Chat Sent', info: {} },
@@ -73,15 +89,15 @@ export const outbound_chat_sent_trigger_tests = async ({ sdk }: { sdk: Session }
     console.log(`Created trigger: ${trigger.id}`)
 
     // ── Rooms ─────────────────────────────────────────────────────────
-    roomSolo = await sdk.api.chat_rooms.createOne({
+    const roomSolo = await sdk.api.chat_rooms.createOne({
       userIds: [sdk.userInfo.id],
       enduserIds: [endSolo.id],
     })
-    roomGroup = await sdk.api.chat_rooms.createOne({
+    const roomGroup = await sdk.api.chat_rooms.createOne({
       userIds: [sdk.userInfo.id],
       enduserIds: [endA.id, endB.id],
     })
-    roomBackfill = await sdk.api.chat_rooms.createOne({
+    const roomBackfill = await sdk.api.chat_rooms.createOne({
       userIds: [sdk.userInfo.id],
       enduserIds: [endBackfill.id],
     })
@@ -97,14 +113,16 @@ export const outbound_chat_sent_trigger_tests = async ({ sdk }: { sdk: Session }
     await wait(undefined, 2000)
 
     const soloAfterInbound = await sdk.api.endusers.getOne(endSolo.id)
-    const c1_notTagged = !soloAfterInbound.tags?.includes(TAG)
-    const c1_noStamp = !soloAfterInbound.recentOutboundChatAt
-    console.log(c1_notTagged
-      ? `✅ [1] Solo inbound did NOT fire trigger`
-      : `❌ [1] Solo inbound fired trigger. tags=${JSON.stringify(soloAfterInbound.tags)}`)
-    console.log(c1_noStamp
-      ? `✅ [1] Solo inbound did NOT set recentOutboundChatAt`
-      : `❌ [1] Solo inbound set recentOutboundChatAt=${soloAfterInbound.recentOutboundChatAt}`)
+    record(
+      '[1] Solo inbound did NOT fire trigger',
+      !soloAfterInbound.tags?.includes(TAG),
+      `tags=${JSON.stringify(soloAfterInbound.tags)} expected to exclude ${TAG}`,
+    )
+    record(
+      '[1] Solo inbound did NOT set recentOutboundChatAt',
+      !soloAfterInbound.recentOutboundChatAt,
+      `recentOutboundChatAt=${soloAfterInbound.recentOutboundChatAt ?? '(unset)'}`,
+    )
 
     // ═════════════════════════════════════════════════════════════════
     // Case 2: Single-enduser outbound (user session)
@@ -117,15 +135,21 @@ export const outbound_chat_sent_trigger_tests = async ({ sdk }: { sdk: Session }
     })
     await wait(undefined, 2000)
 
-    const soloAfterOutbound = await sdk.api.endusers.getOne(endSolo.id)
-    const c2_tagged = !!soloAfterOutbound.tags?.includes(TAG)
-    const c2_stamped = isRecent(soloAfterOutbound.recentOutboundChatAt, c2_sendStart)
-    console.log(c2_tagged
-      ? `✅ [2] Solo outbound fired trigger`
-      : `❌ [2] Solo outbound did NOT fire trigger. tags=${JSON.stringify(soloAfterOutbound.tags)}`)
-    console.log(c2_stamped
-      ? `✅ [2] Solo outbound set recentOutboundChatAt=${soloAfterOutbound.recentOutboundChatAt}`
-      : `❌ [2] Solo outbound did not set a recent recentOutboundChatAt. got=${soloAfterOutbound.recentOutboundChatAt}`)
+    const soloAfterOutbound = await poll_for_results(
+      () => sdk.api.endusers.getOne(endSolo.id),
+      e => !!e.tags?.includes(TAG) && !!e.recentOutboundChatAt,
+    )
+    record(
+      '[2] Solo outbound fired trigger',
+      !!soloAfterOutbound.tags?.includes(TAG),
+      `tags=${JSON.stringify(soloAfterOutbound.tags)} expected to include ${TAG}`,
+    )
+    record(
+      '[2] Solo outbound set a recent recentOutboundChatAt',
+      isRecent(soloAfterOutbound.recentOutboundChatAt, c2_sendStart),
+      `recentOutboundChatAt=${soloAfterOutbound.recentOutboundChatAt ?? '(unset)'}`
+      + ` sendStart=${new Date(c2_sendStart).toISOString()}`,
+    )
 
     // ═════════════════════════════════════════════════════════════════
     // Case 3: Multi-enduser inbound (endA sends in [A, B] room)
@@ -138,16 +162,17 @@ export const outbound_chat_sent_trigger_tests = async ({ sdk }: { sdk: Session }
 
     const aAfterInbound = await sdk.api.endusers.getOne(endA.id)
     const bAfterInbound = await sdk.api.endusers.getOne(endB.id)
-    const c3_aNotTagged = !aAfterInbound.tags?.includes(TAG)
-    const c3_bNotTagged = !bAfterInbound.tags?.includes(TAG)
-    const c3_neitherTagged = c3_aNotTagged && c3_bNotTagged
-    const c3_neitherStamped = !aAfterInbound.recentOutboundChatAt && !bAfterInbound.recentOutboundChatAt
-    console.log(c3_neitherTagged
-      ? `✅ [3] Group inbound did NOT fire trigger on either enduser`
-      : `❌ [3] Group inbound fired trigger. A tags=${JSON.stringify(aAfterInbound.tags)} B tags=${JSON.stringify(bAfterInbound.tags)}`)
-    console.log(c3_neitherStamped
-      ? `✅ [3] Group inbound did NOT set recentOutboundChatAt on either enduser`
-      : `❌ [3] Group inbound stamped recentOutboundChatAt. A=${aAfterInbound.recentOutboundChatAt} B=${bAfterInbound.recentOutboundChatAt}`)
+    record(
+      '[3] Group inbound did NOT fire trigger on either enduser',
+      !aAfterInbound.tags?.includes(TAG) && !bAfterInbound.tags?.includes(TAG),
+      `A tags=${JSON.stringify(aAfterInbound.tags)} B tags=${JSON.stringify(bAfterInbound.tags)}`
+      + ` expected both to exclude ${TAG}`,
+    )
+    record(
+      '[3] Group inbound did NOT set recentOutboundChatAt on either enduser',
+      !aAfterInbound.recentOutboundChatAt && !bAfterInbound.recentOutboundChatAt,
+      `A=${aAfterInbound.recentOutboundChatAt ?? '(unset)'} B=${bAfterInbound.recentOutboundChatAt ?? '(unset)'}`,
+    )
 
     // ═════════════════════════════════════════════════════════════════
     // Case 4: Multi-enduser outbound (user sends in [A, B] room)
@@ -160,17 +185,26 @@ export const outbound_chat_sent_trigger_tests = async ({ sdk }: { sdk: Session }
     })
     await wait(undefined, 2000)
 
-    const aAfterOutbound = await sdk.api.endusers.getOne(endA.id)
-    const bAfterOutbound = await sdk.api.endusers.getOne(endB.id)
-    const c4_bothTagged = !!aAfterOutbound.tags?.includes(TAG) && !!bAfterOutbound.tags?.includes(TAG)
-    const c4_bothStamped = isRecent(aAfterOutbound.recentOutboundChatAt, c4_sendStart)
-      && isRecent(bAfterOutbound.recentOutboundChatAt, c4_sendStart)
-    console.log(c4_bothTagged
-      ? `✅ [4] Group outbound fired trigger on BOTH endusers`
-      : `❌ [4] Group outbound did not tag both. A tags=${JSON.stringify(aAfterOutbound.tags)} B tags=${JSON.stringify(bAfterOutbound.tags)}`)
-    console.log(c4_bothStamped
-      ? `✅ [4] Group outbound set recentOutboundChatAt on BOTH endusers`
-      : `❌ [4] Group outbound did not stamp both. A=${aAfterOutbound.recentOutboundChatAt} B=${bAfterOutbound.recentOutboundChatAt}`)
+    const [aAfterOutbound, bAfterOutbound] = await poll_for_results(
+      () => Promise.all([sdk.api.endusers.getOne(endA.id), sdk.api.endusers.getOne(endB.id)]),
+      ([a, b]) => (
+        !!a.tags?.includes(TAG) && !!a.recentOutboundChatAt
+        && !!b.tags?.includes(TAG) && !!b.recentOutboundChatAt
+      ),
+    )
+    record(
+      '[4] Group outbound fired trigger on BOTH endusers',
+      !!aAfterOutbound.tags?.includes(TAG) && !!bAfterOutbound.tags?.includes(TAG),
+      `A tags=${JSON.stringify(aAfterOutbound.tags)} B tags=${JSON.stringify(bAfterOutbound.tags)}`
+      + ` expected both to include ${TAG}`,
+    )
+    record(
+      '[4] Group outbound set recentOutboundChatAt on BOTH endusers',
+      isRecent(aAfterOutbound.recentOutboundChatAt, c4_sendStart)
+      && isRecent(bAfterOutbound.recentOutboundChatAt, c4_sendStart),
+      `A=${aAfterOutbound.recentOutboundChatAt ?? '(unset)'} B=${bAfterOutbound.recentOutboundChatAt ?? '(unset)'}`
+      + ` sendStart=${new Date(c4_sendStart).toISOString()}`,
+    )
 
     // ═════════════════════════════════════════════════════════════════
     // Case 5: User session, senderId = enduser.id (backfill)
@@ -183,14 +217,16 @@ export const outbound_chat_sent_trigger_tests = async ({ sdk }: { sdk: Session }
     await wait(undefined, 2000)
 
     const backfillAfter = await sdk.api.endusers.getOne(endBackfill.id)
-    const c5_notTagged = !backfillAfter.tags?.includes(TAG)
-    const c5_noStamp = !backfillAfter.recentOutboundChatAt
-    console.log(c5_notTagged
-      ? `✅ [5] Backfill (user-session + enduser senderId) did NOT fire trigger`
-      : `❌ [5] Backfill fired trigger. tags=${JSON.stringify(backfillAfter.tags)}`)
-    console.log(c5_noStamp
-      ? `✅ [5] Backfill did NOT set recentOutboundChatAt`
-      : `❌ [5] Backfill set recentOutboundChatAt=${backfillAfter.recentOutboundChatAt}`)
+    record(
+      '[5] Backfill (user-session + enduser senderId) did NOT fire trigger',
+      !backfillAfter.tags?.includes(TAG),
+      `tags=${JSON.stringify(backfillAfter.tags)} expected to exclude ${TAG}`,
+    )
+    record(
+      '[5] Backfill did NOT set recentOutboundChatAt',
+      !backfillAfter.recentOutboundChatAt,
+      `recentOutboundChatAt=${backfillAfter.recentOutboundChatAt ?? '(unset)'}`,
+    )
 
     // ═════════════════════════════════════════════════════════════════
     // Case 6: Autoreply — enduser inbound triggers an org autoreply.
@@ -198,14 +234,10 @@ export const outbound_chat_sent_trigger_tests = async ({ sdk }: { sdk: Session }
     //   or stamp recentOutboundChatAt.
     //
     // Setup requires enabling org autoreply with an OOO window covering
-    // "now" (is_out_of_office returns false on empty config).
+    // "now" (is_out_of_office returns false on empty config). These are
+    // this tenant's own settings and go away with it at teardown.
     // ═════════════════════════════════════════════════════════════════
-    const originalOrg = await sdk.api.organizations.getOne(sdk.userInfo.businessId)
-    originalOutOfOfficeHours = originalOrg.outOfOfficeHours ?? []
-    originalAutoReplyEnabled = !!originalOrg.settings?.endusers?.autoReplyEnabled
-
-    settingsModified = true
-    await sdk.api.organizations.updateOne(sdk.userInfo.businessId, {
+    await sdk.api.organizations.updateOne(tenant.businessId, {
       outOfOfficeHours: [{
         from: new Date(Date.now() - 24 * 60 * 60 * 1000).toISOString(),
         to:   new Date(Date.now() + 24 * 60 * 60 * 1000).toISOString(),
@@ -214,11 +246,11 @@ export const outbound_chat_sent_trigger_tests = async ({ sdk }: { sdk: Session }
       settings: { endusers: { autoReplyEnabled: true } } as any,
     }, { replaceObjectFields: true })
 
-    endAutoreply = await sdk.api.endusers.createOne({ fname: 'Autoreply', lname: 'Patient' })
+    const endAutoreply = await sdk.api.endusers.createOne({ fname: 'Autoreply', lname: 'Patient' })
     const { authToken: tokenAR } = await sdk.api.endusers.generate_auth_token({ id: endAutoreply.id })
-    const endAutoreplySDK = new EnduserSession({ host, authToken: tokenAR, businessId: sdk.userInfo.businessId })
+    const endAutoreplySDK = new EnduserSession({ host, authToken: tokenAR, businessId: tenant.businessId })
 
-    roomAutoreply = await sdk.api.chat_rooms.createOne({
+    const roomAutoreply = await sdk.api.chat_rooms.createOne({
       userIds: [sdk.userInfo.id],
       enduserIds: [endAutoreply.id],
     })
@@ -232,102 +264,58 @@ export const outbound_chat_sent_trigger_tests = async ({ sdk }: { sdk: Session }
     // handle_chat_create re-runs against the autoreply chat.
     await wait(undefined, 4000)
 
-    const arAfter = await sdk.api.endusers.getOne(endAutoreply.id)
-    const roomChats = await sdk.api.chats.getSome({ filter: { roomId: roomAutoreply.id } })
+    const roomChats = await poll_for_results(
+      () => sdk.api.chats.getSome({ filter: { roomId: roomAutoreply.id } }),
+      cs => cs.some(c => (c as any).isAutoreply === true),
+    )
     const sanity_autoreplySent = roomChats.some(c => (c as any).isAutoreply === true)
+    record(
+      '[6] Autoreply chat was sent (sanity check)',
+      sanity_autoreplySent,
+      sanity_autoreplySent
+        ? `${roomChats.length} chat(s) in the room, one of them isAutoreply`
+        : `no autoreply chat found in room — test setup invalid, the trigger skip is NOT validated.`
+          + ` chats=${JSON.stringify(roomChats.map(c => ({ id: c.id, isAutoreply: (c as any).isAutoreply })))}`,
+    )
+
+    // Only read the enduser once the autoreply chat exists, plus a barrier: the negative checks
+    // below would pass vacuously if the chat the trigger must ignore had not been written yet.
+    await wait(undefined, 1000)
 
-    const c6_notTagged = !arAfter.tags?.includes(TAG)
-    const c6_noStamp = !arAfter.recentOutboundChatAt
-
-    console.log(sanity_autoreplySent
-      ? `✅ [6] Autoreply chat was sent (sanity check)`
-      : `❌ [6] No autoreply chat found in room — test setup invalid. Cannot validate trigger skip.`)
-    console.log(c6_notTagged
-      ? `✅ [6] Autoreply did NOT fire trigger`
-      : `❌ [6] Autoreply fired trigger. tags=${JSON.stringify(arAfter.tags)}`)
-    console.log(c6_noStamp
-      ? `✅ [6] Autoreply did NOT set recentOutboundChatAt`
-      : `❌ [6] Autoreply set recentOutboundChatAt=${arAfter.recentOutboundChatAt}`)
-
-    // ── Summary ───────────────────────────────────────────────────────
-    console.log(`\n=== Outbound Chat Sent Trigger Test Results ===`)
-    console.log(`[1] Solo  inbound  — no trigger:        ${c1_notTagged ? '✅' : '❌'}`)
-    console.log(`[1] Solo  inbound  — no stamp:          ${c1_noStamp ? '✅' : '❌'}`)
-    console.log(`[2] Solo  outbound — trigger:           ${c2_tagged ? '✅' : '❌'}`)
-    console.log(`[2] Solo  outbound — stamp:             ${c2_stamped ? '✅' : '❌'}`)
-    console.log(`[3] Group inbound  — no trigger (both): ${c3_neitherTagged ? '✅' : '❌'}`)
-    console.log(`[3] Group inbound  — no stamp (both):   ${c3_neitherStamped ? '✅' : '❌'}`)
-    console.log(`[4] Group outbound — trigger (both):    ${c4_bothTagged ? '✅' : '❌'}`)
-    console.log(`[4] Group outbound — stamp (both):      ${c4_bothStamped ? '✅' : '❌'}`)
-    console.log(`[5] Backfill       — no trigger:        ${c5_notTagged ? '✅' : '❌'}`)
-    console.log(`[5] Backfill       — no stamp:          ${c5_noStamp ? '✅' : '❌'}`)
-    console.log(`[6] Autoreply      — sanity sent:       ${sanity_autoreplySent ? '✅' : '❌'}`)
-    console.log(`[6] Autoreply      — no trigger:        ${c6_notTagged ? '✅' : '❌'}`)
-    console.log(`[6] Autoreply      — no stamp:          ${c6_noStamp ? '✅' : '❌'}`)
-
-    const allPassed =
-      c1_notTagged && c1_noStamp
-      && c2_tagged && c2_stamped
-      && c3_neitherTagged && c3_neitherStamped
-      && c4_bothTagged && c4_bothStamped
-      && c5_notTagged && c5_noStamp
-      && sanity_autoreplySent && c6_notTagged && c6_noStamp
-
-    if (!allPassed) {
-      throw new Error('Outbound Chat Sent trigger tests failed')
-    }
-
-    return { success: true }
+    const arAfter = await sdk.api.endusers.getOne(endAutoreply.id)
+    record(
+      '[6] Autoreply did NOT fire trigger',
+      !arAfter.tags?.includes(TAG),
+      `tags=${JSON.stringify(arAfter.tags)} expected to exclude ${TAG}`,
+    )
+    record(
+      '[6] Autoreply did NOT set recentOutboundChatAt',
+      !arAfter.recentOutboundChatAt,
+      `recentOutboundChatAt=${arAfter.recentOutboundChatAt ?? '(unset)'}`,
+    )
   } finally {
-    try {
-      // Restore org settings FIRST (sequentially, before deletes), so a
-      // failure here doesn't leave autoReplyEnabled=true polluting other tests.
-      if (settingsModified) {
-        try {
-          await sdk.api.organizations.updateOne(sdk.userInfo.businessId, {
-            outOfOfficeHours: originalOutOfOfficeHours as any,
-            settings: { endusers: { autoReplyEnabled: originalAutoReplyEnabled } } as any,
-          }, { replaceObjectFields: true })
-          console.log(`Restored org settings (autoReplyEnabled=${originalAutoReplyEnabled}, outOfOfficeHours.length=${originalOutOfOfficeHours.length})`)
-        } catch (err) {
-          console.error(`❌ Failed to restore org settings — manual cleanup may be required: ${err}`)
-        }
-      }
-
-      const cleanups: Promise<any>[] = []
-
-      if (trigger?.id) cleanups.push(sdk.api.automation_triggers.deleteOne(trigger.id).catch(() => {}))
-      if (roomSolo?.id) cleanups.push(sdk.api.chat_rooms.deleteOne(roomSolo.id).catch(() => {}))
-      if (roomGroup?.id) cleanups.push(sdk.api.chat_rooms.deleteOne(roomGroup.id).catch(() => {}))
-      if (roomBackfill?.id) cleanups.push(sdk.api.chat_rooms.deleteOne(roomBackfill.id).catch(() => {}))
-      if (roomAutoreply?.id) cleanups.push(sdk.api.chat_rooms.deleteOne(roomAutoreply.id).catch(() => {}))
-      if (endSolo?.id) cleanups.push(sdk.api.endusers.deleteOne(endSolo.id).catch(() => {}))
-      if (endA?.id) cleanups.push(sdk.api.endusers.deleteOne(endA.id).catch(() => {}))
-      if (endB?.id) cleanups.push(sdk.api.endusers.deleteOne(endB.id).catch(() => {}))
-      if (endBackfill?.id) cleanups.push(sdk.api.endusers.deleteOne(endBackfill.id).catch(() => {}))
-      if (endAutoreply?.id) cleanups.push(sdk.api.endusers.deleteOne(endAutoreply.id).catch(() => {}))
-
-      await Promise.all(cleanups)
-      console.log(`Outbound Chat Sent trigger test cleanup completed`)
-    } catch (error) {
-      console.error(`Cleanup error: ${error}`)
-    }
+    // Teardown BEFORE anything asserts — assert calls process.exit, which would strand this tenant.
+    if (tenant) { try { await tenant.teardown() } catch (e) { console.error('teardown failed', e) } }
   }
+
+  return checks
+}
+
+/** Asserting wrapper, for standalone runs and for sequential use in the suite. */
+export const outbound_chat_sent_trigger_tests = async () => {
+  assert_checks('Outbound Chat Sent trigger', await outbound_chat_sent_trigger_checks())
+}
+
+/** Enrolls this suite in the auto-discovered parallel pool — see run_discovered_isolated_suites. */
+export const ISOLATED_SUITE: IsolatedSuite = {
+  name: 'Outbound Chat Sent trigger',
+  run: outbound_chat_sent_trigger_checks,
 }
 
 // Allow running this test file independently
 if (require.main === module) {
-  const host = process.env.API_URL || 'http://localhost:8080'
   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 outbound_chat_sent_trigger_tests({ sdk })
-  }
-
-  runTests()
+  outbound_chat_sent_trigger_tests()
     .then(() => {
       console.log("✅ Outbound Chat Sent trigger tests completed successfully")
       process.exit(0)