chatwoot-router 0.2.0 → 0.4.0

package/CHANGELOG.md

@@ -7,6 +7,62 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.4.0] - 2026-10-04
+
+### Changed
+
+- Route each conversation in a Durable Object of its own, named `<account>:<conversation>`; one sweeper object
+  pages the accounts and hands each conversation to its object. This replaces 0.3.0's `Coordinator` class and
+  bounded RPC machinery; a slow Jev or Chatwoot request still delays only its own conversation.
+
+### Upgrade
+
+- Declare only the `Router` Durable Object (remove `Coordinator`).
+
+## [0.3.0] - 2026-10-03
+
+### Fixed
+
+- End a kind's turn with resolved/snoozed only after its canned reply is confirmed to exist in Chatwoot. Failed,
+  unknown or malformed creation outcomes, incomplete history, and attempts without visible replies hand off to
+  people without sending again. A reply seen as failed/deleted in the final fresh read also hands off.
+- Recognize historical public outgoing messages from the account's exact brand bot, including the former relay's
+  replies, without moving reply ledgers. Preserve the durable attempt/observed guard across turns and upgrades.
+- Disconnecting an inbox hands its pending brand-bot leftovers to people with native bot `status=open`. The sweep
+  reads pending/open account conversations, including old disconnected inboxes, and retries failed handoffs.
+- Release the brand bot immediately after a kind's resolved/snoozed status using its standard unassignment API;
+  durable retries finish failed releases. Preserve status, turn boundaries and other owners. The open sweep heals
+  Chatwoot webhook-failure fallbacks without scanning resolved/snoozed history.
+
+### Changed
+
+- Partition routing by account and conversation, with a separate paged `Coordinator`. Each conversation owns its
+  queue, decisions and reply/turn guards; slow conversations no longer occupy another conversation's executor.
+- Bound webhook admission and sweep child RPC waits. Persist scan progress independently of failed child
+  deliveries, so retries retain unavailable targets while later pages and healthy conversations continue.
+- Reuse message pages only within one fresh phase, combine independent read-only preparation, and scope cached
+  decisions to actual redacted input and routing configuration/model. Preserve fresh side-effect checks and the
+  existing bounded history reads and 45-request budget; inbox-bot ownership is read fresh instead of cached.
+
+### Upgrade
+
+- This minor release changes deployment bindings. Export and declare SQLite `Router` and `Coordinator`, bound as
+  `ROUTER` and `COORDINATOR`, and keep the five-minute reconciliation trigger. Conversation Router identities are
+  now `<account>:<conversation>`; account for any existing global Router guards before enabling
+  new owners. Keep Worker identities, namespaces/storage and immutable configuration keys.
+- Deploy chatwoot-discord-relay 0.31.0 first, completing its separately authorized
+  [partition adoption](https://github.com/Phala-Network/chatwoot-workers/blob/main/packages/chatwoot-discord-relay/docs/adoption.md)
+  when upgrading an existing Hub. Verify the sole routing owner before connecting bots one account at a time;
+  health checks and webhook acknowledgements do not establish successful routing or channel delivery.
+- To stop routing, disconnect bots but retain credentials and keep this router running until pending/open account
+  passes and durable ending retries clear all brand-bot ownership. Verify resolved/snoozed endings too, preserving
+  human and other-bot owners. Only then stop ingress, cron, queued alarms and in-flight work.
+- Preserve permanent reply attempts, observed/deleted-reply records, unknown guards and turn boundaries. Empty
+  history cannot reconstruct lost guards or justify another send. The legacy relay's reply ledger is independent;
+  restoring old code/configuration does not transfer Router-only replies or unknown attempts. Once new effects
+  exist, use forward repair in the current namespaces; direct version rollback to relay 0.27 is not a safe handover
+  and Cloudflare rollback cannot cross Durable Object class/lifecycle changes.
+
 ## [0.2.0] - 2026-10-03
 
 ### Changed
@@ -46,6 +102,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   `routing_kind`.
 - The `chatwoot-router-store-config` command and `chatwoot-router/stored-config`, for a configuration in KV.
 
-[Unreleased]: https://github.com/Phala-Network/chatwoot-workers/compare/chatwoot-router@0.2.0...HEAD
+[Unreleased]: https://github.com/Phala-Network/chatwoot-workers/compare/chatwoot-router@0.4.0...HEAD
+[0.4.0]: https://github.com/Phala-Network/chatwoot-workers/compare/chatwoot-router@0.3.0...chatwoot-router@0.4.0
+[0.3.0]: https://github.com/Phala-Network/chatwoot-workers/compare/chatwoot-router@0.2.0...chatwoot-router@0.3.0
 [0.2.0]: https://github.com/Phala-Network/chatwoot-workers/compare/chatwoot-router@0.1.0...chatwoot-router@0.2.0
 [0.1.0]: https://github.com/Phala-Network/chatwoot-workers/releases/tag/chatwoot-router@0.1.0

package/README.md

@@ -6,80 +6,24 @@ of [chatwoot-discord-relay](https://github.com/Phala-Network/chatwoot-workers/tr
 
 ## How it works
 
-Chatwoot owns the lifecycle: a conversation is the bot's while pending, and people's otherwise.
-
-System One is TypeSafe's class of decision models, and Jev is its first model. The router calls TypeSafe's
-System One API (`/v1/systemone`) with the model in `routing.model` (Jev by default). `routing.endpoint`
-may point to another deployment of that API, for example a proxy or gateway.
-
-- Each routed account has a configured brand bot. Routing is limited to inboxes linked to that exact account's
-  bot, discovered through `GET inboxes/{id}/agent_bot`. The wrapped `agent_bot.id` and `account_id` must match;
-  `agent_bot: null` or `agent_bot: {}` means unlinked. Foreign-account and system bots are rejected. The user token
-  must see every routed inbox. Disconnecting an inbox stops routing. The API does not expose whether the
-  association is inactive; disconnect to disable it. `routing.botIds` and both bot credential maps require
-  exactly the routed account keys (see [Configuration reference](#configuration-reference)).
-- Signed bot webhooks at `/chatwoot/agent-bot` enqueue a deduplicated conversation job. The five-minute sweep
-  lists **pending** conversations without an age cutoff. Inbox discovery and page cursors persist across alarms
-  within the request budget. Failed pages retry. An empty page ends a pass; the next starts at page 1 and catches
-  conversations skipped by changing pages. Neither event payloads nor sweep rows are decision inputs.
-- Read messages newest-first, unfiltered (including activities), with `before` paging, at most five pages of 20.
-  The latest `conversation_status_changed` activity begins the turn; without one or evidence it is missing, use
-  the conversation's start. Take the first three usable customer texts after the boundary, oldest first. Include
-  email subjects and reply text without quoted history; omit automatic email, deleted messages and private notes.
-  Redact identifiers and contact names, then cap the input at 1,600 characters. Memoize Jev's decision by input ids.
-- Status activity is asynchronous. The queue's boundary guard remembers an observed/expected transition and the
-  last boundary needed to reject stale handoff work. An activity read before its first status webhook can match
-  that webhook's status and time only if no existing expectation requires a newer activity. Merging a webhook
-  never lowers or removes an expected boundary id. Once matched, a different transition requires an activity
-  **after that boundary id**, even when the old activity has the same status and second-level timestamp. Repeated
-  delivery of the same transition timestamp does not start another expectation. Only a status webhook supplies a transition time;
-  a read observing pending end requires a newer activity without inferring a time from `updated_at`. The last
-  pending observation survives retries, so a retry confirming resolution after a lost response retains that boundary.
-  Other non-pending snapshots exit: metadata updates change `updated_at` without creating a status activity.
-  An expected activity not yet present retries normally; an incomplete read or a deleted known boundary hands off.
-  Permanently missing activity uses the same three-attempt limit. A new boundary clears the previous turn's failure
-  count and handoff. Chatwoot exposes no turn API: a lost webhook plus permanently removed, never-observed activity
-  cannot be reconstructed. Chatwoot writes activity only for a changed status with activity content; no-op status
-  changes create none. Activities use job execution time, and customer/scheduled reopen usually creates none.
-  A late activity ordered after new text does not license reading old text across the boundary; empty input hands off.
-- Jev chooses owner, topic, kind and whether there is a request. A confident kind takes precedence; otherwise a
-  confident greeting/no-request stays pending while fewer than three texts exist. Empty or identifier-only input,
-  three greetings, an unclear owner with an actual request, or a public human reply hands off. Blocked contacts
-  and person-assigned conversations are untouched. Bot and user assignees are distinguished by `assignee_type`.
-- Before **each** action, re-read the inbox link, pending status, assignee, turn boundary, inputs and public human
-  replies. A changed input defers the job to decide again. Apply topic/kind labels, then the kind's canned reply,
-  then exactly one ending action: the kind's resolved/snoozed status, a confident owner's assignment, or explicit
-  bot `status=open` handoff. Preserve human topic labels and validate that an owner still belongs to the account.
-  Successful person assignment ends the turn without a bot-handoff reporting event; nothing follows it.
-  Reopened resolved conversations can lack a bot assignee, in which case assignment would not open
-  pending: use native handoff instead. Chatwoot has no atomic compare-and-write API for a change racing a mutation.
-- Only canned replies have an action record, `reply:<account>:<conversation>`, kept across turns and upgrades.
-  Record it **before sending**: a failure or unknown outcome is never resent. Labels, assignment and status use
-  current Chatwoot state, without an effects ledger or custom coordination attributes. A missing canned response
-  hands off immediately. After three processing failures (initial, +5s, +10s), persist handoff mode. Further retries
-  only revalidate the turn and hand off, with backoff capped at 30 minutes. Handoff failures keep the job; deleted
-  conversations and disconnected inboxes end it. Credentials/service failures need repair before handoff can succeed.
-- A Worker 2xx means the job is durable, not that routing succeeded. Chatwoot's own webhook failure fallback cannot
-  cover later alarm failures. Its fallback opens pending on failed `message_created`/`message_updated` delivery unless
-  `keep_pending_on_bot_failure` is enabled; it may leave a bot assignee on open. The relay shows that as unassigned.
-  Chatwoot makes three delivery attempts for 429/500 responses. Irrelevant valid bot events are acknowledged.
-  There is no router account-webhook endpoint.
-
-After handoff, later customer messages belong to people. Resolved tickets reopen pending in an active bot inbox
-and are decided on their **new turn's** messages. Snoozed tickets reopen open and go to people. A canned reply
-following a customer message counts as answering it in the relay, even if that message was outside Jev's window.
-
-The API contracts were checked against Chatwoot v4.18.0:
-[assignment](https://raw.githubusercontent.com/chatwoot/chatwoot/v4.18.0/app/services/conversations/assignment_service.rb),
-[status changes](https://raw.githubusercontent.com/chatwoot/chatwoot/v4.18.0/app/controllers/api/v1/accounts/conversations_controller.rb),
-[activity creation](https://raw.githubusercontent.com/chatwoot/chatwoot/v4.18.0/app/models/concerns/activity_message_handler.rb)
-and its [job](https://raw.githubusercontent.com/chatwoot/chatwoot/v4.18.0/app/jobs/conversations/activity_message_job.rb),
-[message paging](https://raw.githubusercontent.com/chatwoot/chatwoot/v4.18.0/app/finders/message_finder.rb),
-[inbox bot response](https://raw.githubusercontent.com/chatwoot/chatwoot/v4.18.0/app/views/api/v1/accounts/inboxes/agent_bot.json.jbuilder),
-[assignees/timestamps](https://raw.githubusercontent.com/chatwoot/chatwoot/v4.18.0/app/presenters/conversations/event_data_presenter.rb),
-[token permissions](https://raw.githubusercontent.com/chatwoot/chatwoot/v4.18.0/app/controllers/concerns/access_token_auth_helper.rb),
-[bot events](https://raw.githubusercontent.com/chatwoot/chatwoot/v4.18.0/app/listeners/agent_bot_listener.rb), and
-[webhook fallback](https://raw.githubusercontent.com/chatwoot/chatwoot/v4.18.0/lib/webhooks/trigger.rb).
+Chatwoot owns the lifecycle: a conversation is the bot's while it is pending, and people's otherwise. The router
+is each routed account's native agent bot, connected to the inboxes it should route.
+
+1. A new ticket in a connected inbox is pending, so Chatwoot sends its events to the router's
+   `/chatwoot/agent-bot` webhook. Each conversation is routed by a Durable Object of its own, so a slow request
+   for one conversation never delays another.
+2. The router reads the customer's first messages of this turn (redacted, at most three and 1,600 characters)
+   and asks TypeSafe's System One API (`/v1/systemone`, model `routing.model`, Jev by default; `routing.endpoint`
+   may point to another deployment) for the owner, topic, kind, and whether there is a request yet.
+3. It applies the topic and kind labels, sends the kind's canned reply if it has one (at most once per
+   conversation), and ends the turn: the kind's resolved or snoozed status, the confident owner, or a handoff to
+   people (`status=open`). A greeting with no request yet stays pending until the customer says more.
+4. Anything uncertain hands off to people: an unclear owner, a failed or unconfirmed reply, a human replying,
+   three failed attempts. Disconnecting an inbox's bot hands its pending tickets to people.
+5. A sweep every five minutes lists pending and open conversations, so a missed webhook is caught up and a bot
+   assignment left on an open ticket is released.
+
+[Routing behavior](https://github.com/Phala-Network/chatwoot-workers/blob/main/packages/chatwoot-router/docs/behavior.md) has the precise rules and the Chatwoot contracts they rest on.
 
 ## Deploy
 
@@ -195,21 +139,43 @@ fail startup; `/healthz` returns 503 without credentials in its response. All se
 
 ## Upgrade and rollback
 
-1. Verify user-token inbox visibility and count existing pending tickets. Keep both existing Worker names,
-   Durable Object namespaces and reply records. Existing pending tickets will be routed; open tickets stay human-owned.
-2. Deploy the new relay first. Remove its `router.accounts` and `router.waitSeconds`; keep every kind name in
-   `router.keepLabels`. During the transition existing open tickets can go directly to triage.
-3. Stop the old router's account webhook and cron; replace it in place. Never run both routers. Remove
-   `startAfterConversationId`, `reconcile`, `routing.snoozeUnclear`, `CHATWOOT_WEBHOOK_SECRETS` and
-   `CHATWOOT_BOT_TOKENS` from its configuration. Add `routing.botIds` and the two new required bot secrets.
-   The one-time storage migration removes old jobs/checkpoints/non-reply effects and decision memos. Reply records
-   survive; the pending sweep reconstructs jobs. The Worker never deletes Chatwoot attributes.
-4. Connect the bots one account at a time after both Workers are ready. Keep existing `routing_*` attributes and
-   definitions until the owner's rollback window ends, then remove them manually.
-5. To roll back, **disconnect bots first**, stop the new router/cron, then restore old code, config and account
-   webhook if needed. Do not run old and new routing together. Choose old cutover ids deliberately; retained
-   reply records prevent resends, but lifecycle changes already made are not reversible automatically.
-   Relay sweeps wake held jobs after disconnect; people can open ordinary pending conversations.
+Keep Worker names, Durable Object namespaces/storage and old KV configuration keys. The Router DO holds
+permanent reply attempts/observed records and turn guards as well as jobs and decisions. Message history cannot
+rebuild an unknown attempt, an observed reply since deleted, or a missing turn boundary. Do not delete or recreate
+the Router DO during rollback. If its state is lost or restored to an older recovery point, keep bots disconnected
+and isolate conversations with uncertain attempts/turns for owner review; a currently empty history does not
+prove another send is safe. Existing pending conversations are reconciled; non-pending conversations stay with people. The user token must see all relevant inboxes.
+
+For the first move from the relay's built-in routing (production baseline 0.27.0):
+
+1. Record the live relay deployment/version id and CONFIG_KEY before rollout; retain its Hub and old secrets.
+   Disconnect all brand bots and prevent competing old deployments. Verify bot identities, owner membership,
+   labels, canned responses and inbox visibility. Historical confirmed brand-bot replies need no ledger migration.
+2. Deploy and verify relay 0.30 first. Remove `routing`, `router.accounts` and `router.waitSeconds`; keep every kind
+   in `router.keepLabels`. Verify the actual version and that built-in routing/in-flight old work stopped.
+3. Bootstrap this Worker by hand with all four secrets in a protected secrets file while bots remain disconnected.
+   Verify KV/domain, upstream permissions and test tickets; health/2xx alone do not prove routing success.
+   If using an infra PR whose push deploys both Workers independently, merge only after both hand deployments pass.
+4. Connect bots one account at a time and verify real routing, handoff, failed/unknown reply handling, historical
+   reply deduplication and Discord/triage behavior, including at least a complete sweep.
+5. To roll back, disconnect bots first and **keep this router running until no pending ticket remains assigned to
+   a disconnected brand bot and no non-pending ticket remains assigned to that bot**. Complete pending/open
+   account passes and let failed ending releases finish through their durable retries: pending uses native bot
+   handoff, open leftovers use explicit unassignment, and kind endings release resolved/snoozed tickets in the
+   same turn. Confirm cleared bot ownership across statuses; preserve human/other-bot owners. Then stop
+   webhook entry, cron and queued/in-flight router work; stopping cron alone does not cancel DO alarms. Preserve DO
+   namespace and storage, including reply and turn guards. Restore the recorded live 0.27 version **and its
+   CONFIG_KEY**, without overlapping old/new routing. Relay 0.27 uses its original Hub's
+   `kind-reply:<account>:<conversation>` records; the Router uses separate `reply:<account>:<conversation>`
+   records. Restoring code/config does not copy Router attempts into the Hub or reset either ledger. Only replies
+   already recorded by 0.27 retain its own reply-once protection; Router-only replies/unknown attempts can be
+   attempted again by 0.27. Keep both DOs and review/isolate those tickets before restoring old routing. Rollback
+   does not guarantee reply-once across this switch or undo sent messages or other mutations.
+
+Current router upgrades need no custom coordination attributes, compatibility effects or one-time lifecycle
+cleanup. Older unreadable job payloads are dropped; live snapshots and the account sweep reconstruct queued work, not durable reply/turn guards.
+If handoff credentials fail, repair them or let a real owner take the tickets; do not bulk-open with the integration
+user token, which can assign every ticket to that user. Keep old attributes through the owner's rollback window.
 
 Redaction is best effort, not anonymization: other personal information can still reach TypeSafe. Logs contain
 ids and outcomes, never message bodies or credentials. See [SECURITY.md](https://github.com/Phala-Network/chatwoot-workers/blob/main/SECURITY.md),

package/lib/packages/chatwoot-router/src/index.js

@@ -90,6 +90,11 @@ var Budget = class {
   get remaining() {
     return this.limit - this.used;
   }
+  /** Counts a request that is not a fetch, such as a call to another Durable Object. */
+  consume() {
+    if (this.used >= this.limit) throw new BudgetExhaustedError();
+    this.used += 1;
+  }
   fetch = (request) => {
     if (this.used >= this.limit) return Promise.reject(new BudgetExhaustedError());
     this.used += 1;
@@ -136,6 +141,7 @@ var emailSchema = z2.object({
 });
 var messageSchema = z2.object({
   id: z2.number(),
+  conversation_id: z2.number().optional(),
   content: text,
   message_type: z2.number(),
   content_type: text,
@@ -158,6 +164,7 @@ var messageSchema = z2.object({
   attachments: z2.array(attachmentSchema).nullish()
 });
 var messageListSchema = z2.object({ payload: z2.array(messageSchema) });
+var CONVERSATIONS_PER_PAGE = 25;
 var MESSAGE_HISTORY_PAGE_SIZE = 20;
 var inboxBotSchema = z2.object({
   agent_bot: z2.object({ id: z2.number().int().positive().optional(), account_id: z2.number().int().positive().nullish() }).nullable()
@@ -197,15 +204,6 @@ function chatwootClient(baseUrl, token, fetch2) {
     );
     return list && messageListSchema.parse(list).payload.toSorted((a, b) => a.id - b.id);
   }
-  function setCustomAttributes(accountId2, conversationId, attributes) {
-    return ensureOk(
-      "set custom attribute",
-      client.POST("/api/v1/accounts/{account_id}/conversations/{conversation_id}/custom_attributes", {
-        params: { path: { account_id: accountId2, conversation_id: conversationId } },
-        body: { custom_attributes: attributes, merge: true }
-      })
-    );
-  }
   return {
     /** The conversation, or undefined when it does not exist (it was deleted). */
     getConversation(accountId2, conversationId) {
@@ -231,15 +229,6 @@ function chatwootClient(baseUrl, token, fetch2) {
       const messages = await listMessages(accountId2, conversationId, { after: messageId - 1, before: messageId + 1 });
       return messages?.find((message) => message.id === messageId);
     },
-    async listInboxes(accountId2) {
-      const list = await data(
-        "list inboxes",
-        client.GET("/api/v1/accounts/{account_id}/inboxes", {
-          params: { path: { account_id: accountId2 } }
-        })
-      );
-      return (list.payload ?? []).flatMap((inbox) => inbox.id === void 0 ? [] : [inbox.id]);
-    },
     async inboxBot(accountId2, inboxId) {
       const value = await dataUnlessNotFound(
         "get inbox agent bot",
@@ -375,13 +364,21 @@ function chatwootClient(baseUrl, token, fetch2) {
         })
       );
     },
-    setCustomAttributes,
+    setCustomAttributes(accountId2, conversationId, attributes) {
+      return ensureOk(
+        "set custom attribute",
+        client.POST("/api/v1/accounts/{account_id}/conversations/{conversation_id}/custom_attributes", {
+          params: { path: { account_id: accountId2, conversation_id: conversationId } },
+          body: { custom_attributes: attributes, merge: true }
+        })
+      );
+    },
     /**
      * Sends an outgoing message (or private note). With files it is sent as the spec's
      * multipart/form-data body; the generated type renders its `attachments[]` binaries as
      * strings, so the serializer appends the files itself.
      */
-    createMessage(accountId2, conversationId, message) {
+    async createMessage(accountId2, conversationId, message) {
       const fields = {
         content: message.content,
         message_type: "outgoing",
@@ -397,14 +394,17 @@ function chatwootClient(baseUrl, token, fetch2) {
         for (const file of message.files) form.append("attachments[]", file.blob, file.filename);
         return form;
       };
-      return ensureOk(
-        "create message",
-        client.POST("/api/v1/accounts/{account_id}/conversations/{conversation_id}/messages", {
+      const { data: data2, response } = await client.POST(
+        "/api/v1/accounts/{account_id}/conversations/{conversation_id}/messages",
+        {
           params: { path: { account_id: accountId2, conversation_id: conversationId } },
           body: fields,
           ...message.files.length === 0 ? {} : { bodySerializer: () => multipart(fields) }
-        })
+        }
       );
+      if (!response.ok) throw new ChatwootError(response.status, "create message", notFound(response));
+      const parsed = messageSchema.safeParse(data2);
+      return parsed.success ? parsed.data : void 0;
     }
   };
 }
@@ -470,10 +470,6 @@ var QueueStore = class {
     );
     CREATE INDEX IF NOT EXISTS jobs_due ON jobs (not_before);
     CREATE TABLE IF NOT EXISTS cache (key TEXT PRIMARY KEY, value TEXT NOT NULL, expires_at INTEGER);`);
-    const columns = this.sql.exec("PRAGMA table_info(jobs)").toArray();
-    if (!columns.some((column) => column.name === "suspended")) {
-      this.sql.exec("ALTER TABLE jobs ADD COLUMN suspended INTEGER NOT NULL DEFAULT 0");
-    }
   }
   // Cache
   get(key) {
@@ -500,7 +496,7 @@ var QueueStore = class {
   enqueue(key, priority, payload, notBefore = this.now()) {
     this.sql.exec(
       `INSERT INTO jobs (key, priority, payload, not_before, created_at) VALUES (?, ?, ?, ?, ?)
-       ON CONFLICT (key) DO UPDATE SET version = version + 1, payload = excluded.payload, suspended = 0,
+       ON CONFLICT (key) DO UPDATE SET version = version + 1, payload = excluded.payload,
          not_before = CASE WHEN attempts > 0 THEN not_before ELSE MIN(not_before, excluded.not_before) END`,
       key,
       priority,
@@ -511,7 +507,7 @@ var QueueStore = class {
   }
   nextDueJob() {
     const row = this.sql.exec(
-      `SELECT key, payload, version, attempts, created_at FROM jobs WHERE suspended != 2 AND not_before <= ?
+      `SELECT key, payload, version, attempts, created_at FROM jobs WHERE not_before <= ?
          ORDER BY priority, not_before, created_at LIMIT 1`,
       this.now()
     ).toArray()[0];
@@ -521,7 +517,7 @@ var QueueStore = class {
   }
   /** Earliest due time. */
   nextWakeup() {
-    const row = this.sql.exec("SELECT MIN(not_before) AS at FROM jobs WHERE suspended != 2").toArray()[0];
+    const row = this.sql.exec("SELECT MIN(not_before) AS at FROM jobs").toArray()[0];
     return row?.at ?? void 0;
   }
   /** Removes a finished job unless it was enqueued again while running. */
@@ -546,20 +542,18 @@ var QueueStore = class {
   deferJob(job, delayMs = 0) {
     this.sql.exec("UPDATE jobs SET not_before = ? WHERE key = ?", this.now() + delayMs, job.key);
   }
-  /** One short re-read for a racing status webhook, then wait for an event or a sweep. */
-  holdJob(job) {
+  /**
+   * Makes a job due again after `delayMs`, unless it was queued again while it ran (it is due
+   * then), clearing its failures.
+   */
+  postponeJob(job, delayMs) {
     this.sql.exec(
-      `UPDATE jobs SET suspended = CASE WHEN suspended = 0 THEN 1 ELSE 2 END,
-       not_before = ?, attempts = 0 WHERE key = ? AND version = ?`,
-      this.now() + 1e3,
+      "UPDATE jobs SET not_before = ?, attempts = 0 WHERE key = ? AND version = ?",
+      this.now() + delayMs,
       job.key,
       job.version
     );
   }
-  /** Suspended conversation jobs need reconciliation even outside the ordinary activity window. */
-  wakeHeldJobs() {
-    this.sql.exec("UPDATE jobs SET suspended = 0, not_before = ? WHERE suspended = 2", this.now());
-  }
   prune() {
     this.sql.exec("DELETE FROM cache WHERE expires_at IS NOT NULL AND expires_at <= ?", this.now());
   }
@@ -569,6 +563,28 @@ var QueueStore = class {
 import ipRegex from "ip-regex";
 import { z as z4 } from "zod";
 
+// src/reply.ts
+function confirmedReply(message, botId) {
+  return message !== void 0 && Number.isSafeInteger(message.id) && message.id > 0 && message.message_type === 1 && message.private === false && message.sender?.type === "agent_bot" && message.sender.id === botId && message.status !== "failed" && !message.content_attributes?.deleted;
+}
+async function replyHistory(chatwoot, accountId2, conversationId, botId) {
+  let before;
+  for (let page = 0; page < 5; page += 1) {
+    const messages = await chatwoot.listMessages(accountId2, conversationId, before === void 0 ? {} : { before });
+    for (const message of messages) {
+      if (confirmedReply(message, botId)) return "found";
+      if (message.message_type !== 1 || message.private === true) continue;
+      if (message.sender?.type == null || message.sender.type === "agent_bot" && (message.sender.id == null || message.sender.id === botId))
+        return "unknown";
+    }
+    if (messages.length < MESSAGE_HISTORY_PAGE_SIZE) return "complete-none";
+    const next = messages[0]?.id;
+    if (next === void 0 || before !== void 0 && next >= before) return "unknown";
+    before = next;
+  }
+  return "unknown";
+}
+
 // src/turn.ts
 import { z as z3 } from "zod";
 var guardSchema = z3.object({
@@ -749,17 +765,33 @@ async function routeConversation(ctx, accountId2, conversationId) {
   const bot = chatwootClient(settings.config.chatwoot.baseUrl, token, ctx.fetch);
   const kinds = routing.kinds?.[String(accountId2)] ?? {};
   const botId = routing.botIds[String(accountId2)];
+  const owns = (conversation) => conversation?.meta?.assignee_type === "AgentBot" && conversation.meta.assignee?.id === botId;
+  const release = async () => {
+    const latest = await chatwoot.getConversation(accountId2, conversationId);
+    if (latest?.status !== void 0 && latest.status !== "pending" && owns(latest)) {
+      await bot.unassign(accountId2, conversationId);
+    }
+  };
   const snapshot = async (inboxId) => {
     const raw = await chatwoot.getConversation(accountId2, conversationId);
     if (!raw || raw.inbox_id === void 0 || inboxId !== void 0 && raw.inbox_id !== inboxId) return;
     if (raw.status !== "pending") {
       observeStatus(store, accountId2, conversationId, raw.status ?? "open");
+      if (raw.status !== void 0 && owns(raw)) await release();
       return;
     }
     const conversation = toRelayConversation(conversationId, raw);
-    if (conversation.contact.blocked || conversation.assignee) return;
+    if (conversation.assignee) return;
     if (raw.meta?.assignee && (raw.meta.assignee_type !== "AgentBot" || raw.meta.assignee.id !== botId)) return;
-    if ((await chatwoot.inboxBot(accountId2, raw.inbox_id))?.id !== botId) return;
+    if ((await chatwoot.inboxBot(accountId2, raw.inbox_id))?.id !== botId) {
+      if (owns(raw)) {
+        const latest = await chatwoot.getConversation(accountId2, conversationId);
+        if (latest?.status === "pending" && latest.inbox_id === raw.inbox_id && owns(latest))
+          await bot.setStatus(accountId2, conversationId, { status: "open" });
+      }
+      return;
+    }
+    if (conversation.contact.blocked) return;
     observeStatus(store, accountId2, conversationId, "pending");
     return { raw, conversation };
   };
@@ -782,15 +814,15 @@ async function routeConversation(ctx, accountId2, conversationId) {
   };
   const turn = await readTurn(chatwoot, store, accountId2, conversationId);
   const input = inputs(turn.messages);
-  const humanReply = (messages) => messages.some(
-    (message) => message.message_type === 1 && !message.private && message.sender?.type === "user" && !message.content_attributes?.deleted
+  const requiresHandoff = (messages) => messages.some(
+    (message) => message.message_type === 1 && !message.private && (message.sender?.type === "user" && !message.content_attributes?.deleted || message.sender?.type === "agent_bot" && message.sender.id === botId && (message.status === "failed" || message.content_attributes?.deleted))
   );
   const fresh = async () => {
     const current2 = await snapshot(initial.raw.inbox_id);
     if (!current2) return;
     const latest = await readTurn(chatwoot, store, accountId2, conversationId);
     if (latest.boundary !== turn.boundary || inputs(latest.messages).key !== input.key) return "defer";
-    return { ...current2, handoff: latest.handoff || humanReply(latest.messages) };
+    return { ...current2, handoff: latest.handoff || requiresHandoff(latest.messages) };
   };
   const handoff = async (current2) => {
     requestHandoff(store, accountId2, conversationId);
@@ -799,9 +831,10 @@ async function routeConversation(ctx, accountId2, conversationId) {
     if (current2) await bot.setStatus(accountId2, conversationId, { status: "open" });
     return void 0;
   };
-  if (turn.handoff || humanReply(turn.messages) || input.count === 0) return handoff();
+  if (turn.handoff || requiresHandoff(turn.messages) || input.count === 0) return handoff();
   const memoKey = `decision:${accountId2}:${conversationId}:${input.key}`;
-  let decision = readDecision(store.get(memoKey));
+  const memo = decisionSchema.safeParse(parseJson(store.get(memoKey)));
+  let decision = memo.success ? memo.data : void 0;
   if (!decision) {
     decision = await decide(ctx, owners, routing.kinds?.[String(accountId2)], input.text);
     store.set(memoKey, JSON.stringify(decision));
@@ -821,14 +854,31 @@ async function routeConversation(ctx, accountId2, conversationId) {
   ];
   if (labels.length !== current.conversation.labels.length) await bot.setLabels(accountId2, conversationId, labels);
   const replyKey = `reply:${accountId2}:${conversationId}`;
-  if (kind?.cannedResponse && store.get(replyKey) === void 0) {
-    const content = await chatwoot.cannedResponse(accountId2, kind.cannedResponse);
-    if (!content?.trim()) return handoff();
-    current = await fresh();
-    if (current === "defer" || !current) return current;
-    if (current.handoff) return handoff(current);
-    store.set(replyKey, "attempted");
-    await bot.createMessage(accountId2, conversationId, { content, private: false, files: [] });
+  if (kind?.cannedResponse) {
+    let history;
+    try {
+      history = await replyHistory(chatwoot, accountId2, conversationId, botId);
+    } catch (error) {
+      log.warn("reply history unavailable; handing off", { accountId: accountId2, conversationId, ...errorFields(error) });
+      return handoff();
+    }
+    if (history === "unknown" || history === "complete-none" && store.get(replyKey) !== void 0) return handoff();
+    if (history === "found" && store.get(replyKey) === void 0) store.set(replyKey, "observed");
+    if (history === "complete-none") {
+      const content = await chatwoot.cannedResponse(accountId2, kind.cannedResponse);
+      if (!content?.trim()) return handoff();
+      current = await fresh();
+      if (current === "defer" || !current) return current;
+      if (current.handoff) return handoff(current);
+      store.set(replyKey, "attempted");
+      try {
+        const message = await bot.createMessage(accountId2, conversationId, { content, private: false, files: [] });
+        if (!confirmedReply(message, botId) || message?.conversation_id !== conversationId) return handoff();
+      } catch (error) {
+        log.warn("reply creation unconfirmed; handing off", { accountId: accountId2, conversationId, ...errorFields(error) });
+        return handoff();
+      }
+    }
   }
   if (assignee !== void 0 && !kind?.status) {
     const agents = await chatwoot.listAgents(accountId2);
@@ -840,6 +890,7 @@ async function routeConversation(ctx, accountId2, conversationId) {
   if (kind?.status) {
     await bot.setStatus(accountId2, conversationId, { status: kind.status });
     expectActivity(store, accountId2, conversationId, { status: kind.status });
+    await release();
   } else if (assignee !== void 0 && current.raw.meta?.assignee_type === "AgentBot") {
     await bot.assign(accountId2, conversationId, assignee);
     expectActivity(store, accountId2, conversationId, { status: "open" });
@@ -929,10 +980,6 @@ async function decide(ctx, owners, kinds, text2) {
     noRequest: request.choice === "none" && request.confidence >= routing.minConfidence
   };
 }
-function readDecision(stored) {
-  const parsed = decisionSchema.safeParse(parseJson(stored));
-  return parsed.success ? parsed.data : void 0;
-}
 
 // ../../shared/settings.ts
 function settingsLoader(parse) {
@@ -1057,35 +1104,26 @@ function buildSettings(config, secrets) {
 var loadSettings = settingsLoader(parseSettings);
 
 // src/router.ts
-var ROUTER_NAME = "global";
-var ROUTE_BUDGET = 45;
-var BUDGET = { route: ROUTE_BUDGET, sweep: 2 };
+var SWEEP_NAME = "global";
+var BUDGET = { route: 45, sweep: 1 + CONVERSATIONS_PER_PAGE };
+function sweeper(env) {
+  return env.ROUTER.getByName(SWEEP_NAME);
+}
+function conversationRouter(env, accountId2, conversationId) {
+  return env.ROUTER.getByName(`${accountId2}:${conversationId}`);
+}
 var RUN_WALL_MS = 5 * 60 * 1e3;
 var id = z6.number().int().positive();
 var jobSchema = z6.discriminatedUnion("type", [
   z6.object({ type: z6.literal("route"), accountId: id, conversationId: id }),
-  z6.object({ type: z6.literal("sweep"), accountId: id })
+  z6.object({ type: z6.literal("sweep"), accountId: id, status: z6.enum(["pending", "open"]) })
 ]);
-var passSchema = z6.object({
-  page: z6.number().int().positive(),
-  remaining: z6.array(id),
-  routed: z6.array(id)
-});
 var Router = class extends DurableObject {
   store;
   constructor(context, env) {
     super(context, env);
     this.store = new QueueStore(context.storage.sql);
-    context.blockConcurrencyWhile(async () => {
-      this.store.migrate();
-      if (!this.store.get("migration:agent-bot")) {
-        context.storage.sql.exec("DELETE FROM jobs");
-        for (const prefix of ["seen:", "decision:", "assign:", "labels:", "status:", "sweep:"]) {
-          context.storage.sql.exec("DELETE FROM cache WHERE key >= ? AND key < ?", prefix, `${prefix.slice(0, -1)};`);
-        }
-        this.store.set("migration:agent-bot", "1");
-      }
-    });
+    this.store.migrate();
   }
   async enqueueConversation(accountId2, conversationId, transition) {
     const settings = await loadSettings(this.env);
@@ -1096,7 +1134,8 @@ var Router = class extends DurableObject {
   }
   async requestSweep() {
     for (const accountId2 of Object.keys((await loadSettings(this.env)).config.routing.accounts)) {
-      this.enqueue({ type: "sweep", accountId: Number(accountId2) });
+      for (const status of ["pending", "open"])
+        this.enqueue({ type: "sweep", accountId: Number(accountId2), status });
     }
     await this.schedule();
   }
@@ -1129,7 +1168,13 @@ var Router = class extends DurableObject {
           }
           clearFailures(this.store, payload.accountId, payload.conversationId);
         } else if (routesAccount(settings, payload.accountId)) {
-          await this.sweep(settings, chatwoot, payload.accountId);
+          await this.sweep(
+            chatwoot,
+            budget,
+            payload.accountId,
+            payload.status,
+            settings.config.routing.botIds[String(payload.accountId)]
+          );
         }
         this.store.completeJob(job);
       } catch (error) {
@@ -1157,34 +1202,37 @@ var Router = class extends DurableObject {
     }
     await this.schedule(yielded ? Date.now() : void 0);
   }
-  async sweep(settings, chatwoot, accountId2) {
-    const key = `sweep:${accountId2}:pending`;
-    const saved = passSchema.safeParse(parseJson(this.store.get(key)));
-    const pass = saved.success ? saved.data : { page: 1, remaining: await chatwoot.listInboxes(accountId2), routed: [] };
-    const inboxId = pass.remaining[0];
-    if (inboxId !== void 0) {
-      if ((await chatwoot.inboxBot(accountId2, inboxId))?.id === settings.config.routing.botIds[String(accountId2)]) {
-        pass.routed.push(inboxId);
-      }
-      pass.remaining.shift();
-    } else {
-      const conversations = await chatwoot.listConversations(accountId2, pass.page, "pending");
-      for (const conversation of conversations) {
-        if (conversation.id !== void 0 && conversation.inbox_id !== void 0 && pass.routed.includes(conversation.inbox_id)) {
-          this.enqueue({ type: "route", accountId: accountId2, conversationId: conversation.id });
-        }
-      }
-      if (conversations.length === 0) {
-        this.store.delete(key);
-        return;
-      }
-      pass.page += 1;
+  async sweep(chatwoot, budget, accountId2, status, botId) {
+    const key = `sweep:${accountId2}:${status}`;
+    const saved = id.safeParse(parseJson(this.store.get(key)));
+    const page = saved.success ? saved.data : 1;
+    const conversations = await chatwoot.listConversations(accountId2, page, status);
+    const routed = conversations.flatMap(
+      (conversation) => conversation.id !== void 0 && (status === "pending" || conversation.meta?.assignee_type === "AgentBot" && conversation.meta.assignee?.id === botId) ? [conversation.id] : []
+    );
+    for (const _ of routed) budget.consume();
+    const results = await Promise.allSettled(
+      routed.map(
+        (conversationId) => conversationRouter(this.env, accountId2, conversationId).enqueueConversation(accountId2, conversationId)
+      )
+    );
+    results.forEach((result, index) => {
+      if (result.status === "rejected")
+        log.warn("sweep could not hand over a conversation", {
+          accountId: accountId2,
+          conversationId: routed[index],
+          ...errorFields(result.reason)
+        });
+    });
+    if (conversations.length === 0) {
+      this.store.delete(key);
+      return;
     }
-    this.store.set(key, JSON.stringify(pass));
-    this.enqueue({ type: "sweep", accountId: accountId2 });
+    this.store.set(key, String(page + 1));
+    this.enqueue({ type: "sweep", accountId: accountId2, status });
   }
   enqueue(payload) {
-    const key = payload.type === "sweep" ? `sweep:${payload.accountId}` : `${payload.type}:${payload.accountId}:${payload.conversationId}`;
+    const key = payload.type === "sweep" ? `sweep:${payload.accountId}:${payload.status}` : `${payload.type}:${payload.accountId}:${payload.conversationId}`;
     this.store.enqueue(key, payload.type === "sweep" ? 1 : 0, JSON.stringify(payload));
   }
   async schedule(at) {
@@ -1271,7 +1319,7 @@ app.post("/chatwoot/agent-bot", bodyLimit({ maxSize: 2 * 1024 * 1024 }), async (
   if (target.accountId !== signedBy || !routesAccount(settings, target.accountId)) {
     return context.text("account does not match the webhook secret", 403);
   }
-  await context.env.ROUTER.getByName(ROUTER_NAME).enqueueConversation(
+  await conversationRouter(context.env, target.accountId, target.conversationId).enqueueConversation(
     target.accountId,
     target.conversationId,
     target.transition
@@ -1286,7 +1334,7 @@ app.onError((error, context) => {
 var src_default = {
   fetch: app.fetch,
   async scheduled(_controller, env, context) {
-    context.waitUntil(env.ROUTER.getByName(ROUTER_NAME).requestSweep());
+    context.waitUntil(sweeper(env).requestSweep());
   }
 };
 export {

package/lib/packages/chatwoot-router/src/reply.d.ts

@@ -0,0 +1,5 @@
+import { type ChatwootClient, type ChatwootMessage } from "../../../shared/chatwoot/api.ts";
+/** A Chatwoot creation receipt, not a channel delivery receipt. */
+export declare function confirmedReply(message: ChatwootMessage | undefined, botId: number | undefined): boolean;
+/** Read past turn boundaries, including replies made by the former relay's brand bot. */
+export declare function replyHistory(chatwoot: ChatwootClient, accountId: number, conversationId: number, botId: number | undefined): Promise<"found" | "complete-none" | "unknown">;

package/lib/packages/chatwoot-router/src/router.d.ts

@@ -1,8 +1,8 @@
 import { DurableObject } from "cloudflare:workers";
 import type { Env } from "./env.ts";
 import type { Transition } from "./webhook.ts";
-export declare const ROUTER_NAME = "global";
-export declare const ROUTE_BUDGET = 45;
+export declare function sweeper(env: Env): DurableObjectStub<Router>;
+export declare function conversationRouter(env: Env, accountId: number, conversationId: number): DurableObjectStub<Router>;
 export declare class Router extends DurableObject<Env> {
     private readonly store;
     constructor(context: DurableObjectState, env: Env);

package/lib/packages/chatwoot-router/src/routing.d.ts

@@ -1,7 +1,5 @@
 import { type ChatwootClient, type Fetch } from "../../../shared/chatwoot/api.ts";
 import type { Settings } from "./config.ts";
-/** Jev's answer when no owner fits; also the reserved route name. */
-export declare const UNCLEAR = "unclear";
 export interface RoutingStore {
     get(key: string): string | undefined;
     set(key: string, value: string): void;
@@ -15,4 +13,3 @@ export interface RoutingContext {
 }
 export declare function routesAccount(settings: Settings, accountId: number): boolean;
 export declare function routeConversation(ctx: RoutingContext, accountId: number, conversationId: number): Promise<"defer" | undefined>;
-export declare function sanitize(text: string, identities: Array<string | null | undefined>): string;

package/lib/packages/chatwoot-router/src/turn.d.ts

@@ -1,23 +1,6 @@
-import { z } from "zod";
 import { type ChatwootClient } from "../../../shared/chatwoot/api.ts";
 import type { RoutingStore } from "./routing.ts";
 import type { Transition } from "./webhook.ts";
-declare const guardSchema: z.ZodObject<{
-    boundary: z.ZodOptional<z.ZodNumber>;
-    claimed: z.ZodOptional<z.ZodBoolean>;
-    pending: z.ZodOptional<z.ZodBoolean>;
-    transitionAt: z.ZodOptional<z.ZodNumber>;
-    expected: z.ZodOptional<z.ZodObject<{
-        status: z.ZodString;
-        at: z.ZodOptional<z.ZodNumber>;
-        after: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
-    handoff: z.ZodDefault<z.ZodBoolean>;
-    failures: z.ZodDefault<z.ZodNumber>;
-}, z.core.$strip>;
-type Guard = z.infer<typeof guardSchema>;
-export declare function readGuard(store: RoutingStore, accountId: number, conversationId: number): Guard;
-export declare function saveGuard(store: RoutingStore, accountId: number, conversationId: number, guard: Guard): void;
 export declare function expectActivity(store: RoutingStore, accountId: number, conversationId: number, transition: Transition): void;
 /** Preserve an observed pending departure across retries, without using metadata timestamps. */
 export declare function observeStatus(store: RoutingStore, accountId: number, conversationId: number, status: string): void;
@@ -25,12 +8,10 @@ export declare function requestHandoff(store: RoutingStore, accountId: number, c
 /** Counts processing failures for this turn, independently of an old queued job's backoff. */
 export declare function recordFailure(store: RoutingStore, accountId: number, conversationId: number): number;
 export declare function clearFailures(store: RoutingStore, accountId: number, conversationId: number): void;
-export declare class ActivityPendingError extends Error {
-    constructor();
-}
 export declare function readTurn(chatwoot: ChatwootClient, store: RoutingStore, accountId: number, conversationId: number): Promise<{
     messages: {
         id: number;
+        conversation_id?: number | undefined;
         content?: string | null | undefined;
         message_type: number;
         content_type?: string | null | undefined;
@@ -83,4 +64,3 @@ export declare function readTurn(chatwoot: ChatwootClient, store: RoutingStore,
     boundary: number;
     handoff: boolean;
 }>;
-export {};

package/lib/shared/budget.d.ts

@@ -9,5 +9,7 @@ export declare class Budget {
     private used;
     constructor(limit: number, fetchImpl?: Fetch, timeoutMs?: number);
     get remaining(): number;
+    /** Counts a request that is not a fetch, such as a call to another Durable Object. */
+    consume(): void;
     readonly fetch: Fetch;
 }

package/lib/shared/chatwoot/api.d.ts

@@ -19,6 +19,7 @@ export type ChatwootConversation = components["schemas"]["conversation_show"] &
 };
 declare const messageSchema: z.ZodObject<{
     id: z.ZodNumber;
+    conversation_id: z.ZodOptional<z.ZodNumber>;
     content: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     message_type: z.ZodNumber;
     content_type: z.ZodOptional<z.ZodNullable<z.ZodString>>;
@@ -107,7 +108,6 @@ export declare function chatwootClient(baseUrl: string, token: string, fetch: Fe
      * (MessageFinder#messages_between at v4.18.0) or exclusively (as the spec describes it).
      */
     getMessage(accountId: number, conversationId: number, messageId: number): Promise<ChatwootMessage | undefined>;
-    listInboxes(accountId: number): Promise<number[]>;
     inboxBot(accountId: number, inboxId: number): Promise<{
         id: number;
     } | undefined>;
@@ -186,13 +186,13 @@ export declare function chatwootClient(baseUrl: string, token: string, fetch: Fe
     conversationLabels(accountId: number, conversationId: number): Promise<string[]>;
     /** Replaces the conversation's labels (the spec's "Add Labels" overwrites the list). */
     setLabels(accountId: number, conversationId: number, labels: string[]): Promise<void>;
-    setCustomAttributes: (accountId: number, conversationId: number, attributes: Record<string, unknown>) => Promise<void>;
+    setCustomAttributes(accountId: number, conversationId: number, attributes: Record<string, unknown>): Promise<void>;
     /**
      * Sends an outgoing message (or private note). With files it is sent as the spec's
      * multipart/form-data body; the generated type renders its `attachments[]` binaries as
      * strings, so the serializer appends the files itself.
      */
-    createMessage(accountId: number, conversationId: number, message: NewMessage): Promise<void>;
+    createMessage(accountId: number, conversationId: number, message: NewMessage): Promise<ChatwootMessage | undefined>;
 };
 /** A bot (or another explicit non-user assignee) must never be matched to a numeric user id. */
 export declare function personAssignee(conversation: ChatwootConversation): {

package/lib/shared/store.d.ts

@@ -32,9 +32,10 @@ export declare class QueueStore {
      * budget, or Discord rate limits it.
      */
     deferJob(job: Job, delayMs?: number): void;
-    /** One short re-read for a racing status webhook, then wait for an event or a sweep. */
-    holdJob(job: Job): void;
-    /** Suspended conversation jobs need reconciliation even outside the ordinary activity window. */
-    wakeHeldJobs(): void;
+    /**
+     * Makes a job due again after `delayMs`, unless it was queued again while it ran (it is due
+     * then), clearing its failures.
+     */
+    postponeJob(job: Job, delayMs: number): void;
     prune(): void;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chatwoot-router",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "Route Chatwoot conversations with TypeSafe Jev on Cloudflare Workers.",
   "keywords": [
     "chatwoot",