chatwoot-router 0.3.0 → 0.4.0

package/CHANGELOG.md

@@ -7,6 +7,18 @@ 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
@@ -90,7 +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.3.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,106 +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 classification/replies and hands any pending ticket still assigned to this bot to people. 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)).
-- Each account+conversation has its own SQLite `Router` Durable Object: its queue, memo, reply records and turn
-  guards have one writer. A slow conversation cannot occupy another conversation’s alarm. A separate `Coordinator`
-  Durable Object pages the account lists and durably enqueues each conversation in its own object.
-- Signed bot webhooks at `/chatwoot/agent-bot` enqueue a deduplicated conversation job. The five-minute sweep
-  lists only **pending and open conversations in the account**, including disconnected inboxes, without an age
-  cutoff. Pending tickets route or hand off; open tickets still assigned to the brand bot release that assignment
-  with `POST assignments {assignee_id: null}`, preserving status after a fresh ownership read. Resolved/snoozed
-  history is not scanned. Each status has its own persistent page cursor within the request budget. Failed pages
-  retry. An empty page ends that status's 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 account, conversation, input ids, actual redacted input and routing configuration/model.
-- 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 only release a remaining brand-bot assignment: 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 during routing; disconnect handoff also clears blocked bot leftovers.
-  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 end the turn: set the kind's resolved/snoozed status and immediately release the bot, assign a confident
-  owner, or use explicit bot `status=open` handoff. Chatwoot keeps the bot on resolve/snooze, so release is part of
-  that same ending, with a fresh ownership/status read. A failed release keeps the durable job for retry, even
-  though the sweep excludes closed history. Clearing only the bot creates no assignment/status activity and does
-  not move the turn boundary; Chatwoot still dispatches assignment/update events. 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.
-  Before sending, read up to five unfiltered history pages (100 messages), past turn boundaries, for a public outgoing
-  message (`message_type=1`, `private=false`, `sender.type=agent_bot`) from this account's exact configured bot id.
-  A confirmed, non-deleted, non-failed reply counts as replied, including replies the old relay sent; preserve an
-  observed record so later removal cannot permit a resend. A complete read to the beginning with none permits the
-  first attempt; an incomplete/failed/ambiguous read or an existing attempt without a visible reply hands off.
-  Record the attempt **before sending**. A failed POST, lost response, malformed receipt or failed/deleted reply
-  persists handoff and never resolves/snoozes or resends. Only a valid creation receipt for this conversation or
-  confirmed history permits the kind's ending status. This confirms creation in Chatwoot, not channel delivery;
-  a delivery failure seen in the final fresh read also hands off. 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 end it. Disconnected brand-bot pending tickets use native bot `status=open` handoff without Jev
-  or a turn-history read; failures retry until the handoff succeeds. Other bots and people are untouched. 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 router releases that assignment on its next job or sweep.
-  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 service](https://raw.githubusercontent.com/chatwoot/chatwoot/v4.18.0/app/services/conversations/assignment_service.rb)
-and [controller](https://raw.githubusercontent.com/chatwoot/chatwoot/v4.18.0/app/controllers/api/v1/accounts/conversations/assignments_controller.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),
-[message creation](https://raw.githubusercontent.com/chatwoot/chatwoot/v4.18.0/app/builders/messages/message_builder.rb),
-[message JSON](https://raw.githubusercontent.com/chatwoot/chatwoot/v4.18.0/app/views/api/v1/models/_message.json.jbuilder),
-[bot sender](https://raw.githubusercontent.com/chatwoot/chatwoot/v4.18.0/app/models/agent_bot.rb),
-[account access](https://raw.githubusercontent.com/chatwoot/chatwoot/v4.18.0/app/controllers/concerns/ensure_current_account_helper.rb),
-[conversation access](https://raw.githubusercontent.com/chatwoot/chatwoot/v4.18.0/app/policies/conversation_policy.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
 
@@ -123,7 +41,7 @@ npx cf deploy --prebuilt --dry-run
 Edit `cloudflare.config.ts` with your non-secret settings. Keep required secrets out of source control;
 `.dev.vars.example` lists placeholders. For local development copy it to `.dev.vars` and use `npm run dev`.
 A maintainer deploys with `npx cf deploy --secrets-file <private-file>`.
-The default Worker name is `chatwoot-router`; it exports SQLite Durable Objects `Router` (bound as `ROUTER`) and `Coordinator` (bound as `COORDINATOR`).
+The default Worker name is `chatwoot-router`; it exports one SQLite Durable Object, `Router`, bound as `ROUTER`.
 Keep the `*/5 * * * *` cron trigger for reconciliation. `GET /healthz` returns 200 for a valid, readable
 configuration and 503 otherwise; it does not test upstream credentials or connectivity.
 
@@ -131,12 +49,12 @@ For a private deployment repository, depend on the public `chatwoot-router` npm
 `@cloudflare/vite-plugin`. Its Worker entry is:
 
 ```ts
-export { default, Router, Coordinator } from "chatwoot-router";
+export { default, Router } from "chatwoot-router";
 ```
 
 Use the same `cloudflare.config.ts` and `vite.config.ts` structure as this package. Pin compatible tooling versions
-from the workspace and root manifests. Declare `Router` and `Coordinator` with `exports.durableObject({ storage: "sqlite" })`, bind it as
-`ROUTER` and `COORDINATOR` respectively, declare required secrets with `bindings.secret()`, and put `CONFIG` in `bindings.json(...)`.
+from the workspace and root manifests. Declare `Router` with `exports.durableObject({ storage: "sqlite" })`, bind it as
+`ROUTER`, declare required secrets with `bindings.secret()`, and put `CONFIG` in `bindings.json(...)`.
 
 For a configuration larger than a Worker JSON binding, use immutable KV configuration instead:
 
@@ -221,12 +139,10 @@ fail startup; `/healthz` returns 503 without credentials in its response. All se
 
 ## Upgrade and rollback
 
-0.2.x was never deployed, so the conversation partition and coordinator require no state migration.
-
 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
-any conversation’s Router DO during rollback. If its state is lost or restored to an older recovery point, keep bots disconnected
+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.
 

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

@@ -1,8 +1,6 @@
 import type { ConfigEnv } from "../../../shared/settings.ts";
-import type { Coordinator } from "./coordinator.ts";
 import type { Router } from "./router.ts";
 export interface Env extends ConfigEnv {
-    COORDINATOR: DurableObjectNamespace<Coordinator>;
     ROUTER: DurableObjectNamespace<Router>;
     CHATWOOT_TOKEN: string;
     CHATWOOT_AGENT_BOT_SECRETS: string;

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

@@ -4,5 +4,4 @@ declare const _default: {
     scheduled(_controller: ScheduledController, env: Env, context: ExecutionContext<unknown>): Promise<void>;
 };
 export default _default;
-export { Coordinator } from "./coordinator.ts";
 export { Router } from "./router.ts";

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

@@ -2,118 +2,6 @@
 import { Hono } from "hono";
 import { bodyLimit } from "hono/body-limit";
 
-// ../../shared/deadline.ts
-async function within(pending, signal) {
-  let abort;
-  try {
-    return await Promise.race([
-      pending,
-      new Promise((_resolve, reject) => {
-        abort = () => reject(signal.reason);
-        if (signal.aborted) abort();
-        else signal.addEventListener("abort", abort, { once: true });
-      })
-    ]);
-  } finally {
-    if (abort) signal.removeEventListener("abort", abort);
-  }
-}
-var JobDeadlineError = class extends Error {
-  requestStarted;
-  constructor(requestStarted = false) {
-    super("Job time slice is used up");
-    this.name = "JobDeadlineError";
-    this.requestStarted = requestStarted;
-  }
-};
-
-// ../../shared/budget.ts
-var BudgetExhaustedError = class extends Error {
-  constructor() {
-    super("Subrequest budget for this invocation is used up");
-    this.name = "BudgetExhaustedError";
-  }
-};
-var METADATA_TIMEOUT_MS = 1500;
-var JOB_SLICE_MS = 1e4;
-var Budget = class {
-  constructor(limit, fetchImpl = (request) => fetch(request)) {
-    this.limit = limit;
-    this.fetchImpl = fetchImpl;
-  }
-  limit;
-  fetchImpl;
-  used = 0;
-  slice;
-  sliceEnds = Number.POSITIVE_INFINITY;
-  get remaining() {
-    return this.limit - this.used;
-  }
-  startSlice(ms = JOB_SLICE_MS) {
-    this.sliceEnds = Date.now() + ms;
-    this.slice = AbortSignal.timeout(ms);
-  }
-  requireTime(ms) {
-    this.checkpoint();
-    if (Date.now() + ms > this.sliceEnds) throw new JobDeadlineError();
-  }
-  checkpoint() {
-    if (this.slice?.aborted) throw new JobDeadlineError();
-  }
-  consume() {
-    this.checkpoint();
-    if (this.used >= this.limit) throw new BudgetExhaustedError();
-    this.used += 1;
-  }
-  require(requests) {
-    this.checkpoint();
-    if (this.remaining < requests) throw new BudgetExhaustedError();
-  }
-  controlSignal(ms) {
-    return AbortSignal.any([AbortSignal.timeout(ms), ...this.slice ? [this.slice] : []]);
-  }
-  fetchWith(timeoutMs) {
-    return (request) => this.request(request, timeoutMs);
-  }
-  fetch = (request) => this.request(request, METADATA_TIMEOUT_MS);
-  async request(request, timeoutMs) {
-    this.consume();
-    const operation = AbortSignal.timeout(timeoutMs);
-    const signal = AbortSignal.any([request.signal, operation, ...this.slice ? [this.slice] : []]);
-    try {
-      const response = await within(this.fetchImpl(new Request(request, { signal })), signal);
-      if (!response.body) return response;
-      const reader = response.body.getReader();
-      const slice = this.slice;
-      const body = new ReadableStream({
-        async pull(controller) {
-          try {
-            const { done, value } = await within(reader.read(), signal);
-            if (done) controller.close();
-            else controller.enqueue(value);
-          } catch (error) {
-            controller.error(slice?.aborted ? new JobDeadlineError(true) : error);
-            void reader.cancel().catch(() => {
-            });
-          }
-        },
-        cancel: (reason) => {
-          void reader.cancel(reason).catch(() => {
-          });
-        }
-      });
-      return new Response(body, {
-        status: response.status,
-        statusText: response.statusText,
-        headers: response.headers
-      });
-    } catch (error) {
-      if (this.slice?.aborted) throw new JobDeadlineError(true);
-      throw error;
-    }
-  }
-};
-
 // ../../shared/chatwoot/signature.ts
 var TIMESTAMP_TOLERANCE_SECONDS = 300;
 var encoder = new TextEncoder();
@@ -177,16 +65,42 @@ function errorFields(error) {
   return error instanceof Error ? { error: error.name, detail: error.message } : { error: String(error) };
 }
 
-// src/coordinator.ts
-import { DurableObject as DurableObject2 } from "cloudflare:workers";
-import { z as z7 } from "zod";
+// src/router.ts
+import { DurableObject } from "cloudflare:workers";
+import { z as z6 } from "zod";
 
-// ../../shared/alarm.ts
-async function scheduleAlarm(state, next) {
-  if (next === void 0) return;
-  const current = await state.storage.getAlarm();
-  if (current === null || current > next) await state.storage.setAlarm(Math.max(Date.now(), next));
-}
+// ../../shared/budget.ts
+var BudgetExhaustedError = class extends Error {
+  constructor() {
+    super("Subrequest budget for this invocation is used up");
+    this.name = "BudgetExhaustedError";
+  }
+};
+var REQUEST_TIMEOUT_MS = 6e4;
+var Budget = class {
+  constructor(limit, fetchImpl = (request) => fetch(request), timeoutMs = REQUEST_TIMEOUT_MS) {
+    this.limit = limit;
+    this.fetchImpl = fetchImpl;
+    this.timeoutMs = timeoutMs;
+  }
+  limit;
+  fetchImpl;
+  timeoutMs;
+  used = 0;
+  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;
+    return this.fetchImpl(new Request(request, { signal: AbortSignal.timeout(this.timeoutMs) }));
+  };
+};
 
 // ../../shared/chatwoot/api.ts
 import createClient from "openapi-fetch";
@@ -194,13 +108,11 @@ import { z as z2 } from "zod";
 var ChatwootError = class extends Error {
   status;
   conversationMissing;
-  retryAfterMs;
-  constructor(status, operation, conversationMissing = false, retryAfterMs) {
+  constructor(status, operation, conversationMissing = false) {
     super(`Chatwoot ${operation} failed with HTTP ${status}`);
     this.name = "ChatwootError";
     this.status = status;
     this.conversationMissing = conversationMissing;
-    this.retryAfterMs = retryAfterMs;
   }
 };
 var text = z2.string().nullish();
@@ -252,33 +164,18 @@ 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()
 });
-function chatwootClient(baseUrl, token, fetch2, limits) {
+function chatwootClient(baseUrl, token, fetch2) {
   const client = createClient({
     baseUrl: baseUrl.replace(/\/+$/, ""),
     headers: { api_access_token: token },
     // A redirect is an error, never followed: it could carry the token to another host, and each
     // hop would be a subrequest the budget does not count. Configure Chatwoot's final URL.
-    fetch: async (request) => {
-      const account = /\/accounts\/(\d+)\//.exec(new URL(request.url).pathname)?.[1] ?? "profile";
-      const key = `chatwoot:limit:${baseUrl}:${account}`;
-      const wait = Number(limits?.get(key) ?? 0) - Date.now();
-      if (wait > 0) throw new ChatwootError(429, "rate limited", false, wait);
-      const response = await fetch2(new Request(request, { redirect: "manual" }));
-      if (response.status === 429) {
-        const header = response.headers.get("retry-after");
-        const seconds = Number(header);
-        const delay = header === null ? 5e3 : Number.isFinite(seconds) ? seconds * 1e3 : Date.parse(header) - Date.now();
-        const retryAfterMs = Number.isFinite(delay) ? Math.max(1, delay) : 5e3;
-        limits?.set(key, String(Date.now() + retryAfterMs), retryAfterMs);
-        await response.body?.cancel();
-        throw new ChatwootError(429, "rate limited", false, retryAfterMs);
-      }
-      return response;
-    }
+    fetch: (request) => fetch2(new Request(request, { redirect: "manual" }))
   });
   async function data(operation, pending) {
     const { data: data2, response } = await pending;
@@ -559,17 +456,12 @@ function retryDelay(attempts) {
   return Math.min(5e3 * 2 ** attempts, 30 * 60 * 1e3);
 }
 var QueueStore = class {
-  constructor(sql, now = Date.now, atomic = (write2) => write2()) {
+  constructor(sql, now = Date.now) {
     this.sql = sql;
     this.now = now;
-    this.atomic = atomic;
   }
   sql;
   now;
-  atomic;
-  transaction(write2) {
-    return this.atomic(write2);
-  }
   migrate() {
     this.sql.exec(`CREATE TABLE IF NOT EXISTS jobs (
       key TEXT PRIMARY KEY, priority INTEGER NOT NULL, payload TEXT NOT NULL,
@@ -578,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) {
@@ -608,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,
@@ -618,24 +506,18 @@ var QueueStore = class {
     );
   }
   nextDueJob() {
-    return this.nextDueJobs(1)[0];
-  }
-  /** A bounded due batch; independent scan and delivery work can select their own keys. */
-  nextDueJobs(limit, prefix = "") {
-    return this.sql.exec(
-      `SELECT key, payload, version, attempts, created_at AS createdAt FROM jobs
-         WHERE suspended != 2 AND not_before <= ? AND substr(key, 1, ?) = ?
-         ORDER BY MAX(0, priority - CAST((? - created_at) / 30000 AS INTEGER)), not_before, created_at LIMIT ?`,
-      this.now(),
-      prefix.length,
-      prefix,
-      this.now(),
-      limit
-    ).toArray();
+    const row = this.sql.exec(
+      `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];
+    if (!row) return void 0;
+    const { created_at: createdAt, ...job } = row;
+    return { ...job, createdAt };
   }
   /** 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. */
@@ -660,47 +542,35 @@ 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());
   }
 };
 
-// src/router.ts
-import { DurableObject } from "cloudflare:workers";
-import { z as z6 } from "zod";
-
 // src/routing.ts
 import ipRegex from "ip-regex";
 import { z as z4 } from "zod";
 
-// ../../shared/concurrent.ts
-async function parallel(...reads) {
-  await Promise.allSettled(reads);
-  return Promise.all(reads);
-}
-
 // 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, freshPages = []) {
+async function replyHistory(chatwoot, accountId2, conversationId, botId) {
   let before;
   for (let page = 0; page < 5; page += 1) {
-    const messages = freshPages[page] ?? await chatwoot.listMessages(accountId2, conversationId, before === void 0 ? {} : { before });
+    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;
@@ -778,14 +648,12 @@ var ActivityPendingError = class extends Error {
 };
 async function readTurn(chatwoot, store, accountId2, conversationId) {
   const messages = [];
-  const pages = [];
   let before;
   let boundary;
   let complete = false;
   let deleted = false;
   for (let page = 0; page < 5; page += 1) {
     const batch = await chatwoot.listMessages(accountId2, conversationId, before === void 0 ? {} : { before });
-    pages.push(batch);
     for (const message of batch.toReversed()) {
       if (message.message_type === 2 && message.content_attributes?.deleted) {
         deleted = true;
@@ -823,7 +691,7 @@ async function readTurn(chatwoot, store, accountId2, conversationId) {
   }
   if (deleted || missing || !complete) guard.handoff = true;
   saveGuard(store, accountId2, conversationId, guard);
-  return { pages, messages: messages.toReversed(), boundary: boundary?.id ?? 0, handoff: guard.handoff };
+  return { messages: messages.toReversed(), boundary: boundary?.id ?? 0, handoff: guard.handoff };
 }
 
 // src/routing.ts
@@ -953,9 +821,8 @@ async function routeConversation(ctx, accountId2, conversationId) {
     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 || inputs(latest.messages).text !== input.text)
-      return "defer";
-    return { ...current2, pages: latest.pages, handoff: latest.handoff || requiresHandoff(latest.messages) };
+    if (latest.boundary !== turn.boundary || inputs(latest.messages).key !== input.key) return "defer";
+    return { ...current2, handoff: latest.handoff || requiresHandoff(latest.messages) };
   };
   const handoff = async (current2) => {
     requestHandoff(store, accountId2, conversationId);
@@ -965,12 +832,7 @@ async function routeConversation(ctx, accountId2, conversationId) {
     return void 0;
   };
   if (turn.handoff || requiresHandoff(turn.messages) || input.count === 0) return handoff();
-  const fingerprint = await crypto.subtle.digest(
-    "SHA-256",
-    new TextEncoder().encode(JSON.stringify({ text: input.text, routing }))
-  );
-  const hash = Array.from(new Uint8Array(fingerprint), (byte) => byte.toString(16).padStart(2, "0")).join("");
-  const memoKey = `decision:${accountId2}:${conversationId}:${input.key}:${hash}`;
+  const memoKey = `decision:${accountId2}:${conversationId}:${input.key}`;
   const memo = decisionSchema.safeParse(parseJson(store.get(memoKey)));
   let decision = memo.success ? memo.data : void 0;
   if (!decision) {
@@ -979,14 +841,6 @@ async function routeConversation(ctx, accountId2, conversationId) {
   }
   const kind = decision.kind && decision.kindConfidence >= routing.minConfidence ? kinds[decision.kind] : void 0;
   const assignee = decision.owner && decision.ownerConfidence >= routing.minConfidence ? owners[decision.owner]?.assignee : void 0;
-  const replyKey = `reply:${accountId2}:${conversationId}`;
-  if (store.get(replyKey) === void 0 && turn.pages.some((page) => page.some((message) => confirmedReply(message, botId))))
-    store.set(replyKey, "observed");
-  const actionable = kind !== void 0 || !decision.noRequest || input.count >= MAX_MESSAGES;
-  const [content, agents] = await parallel(
-    kind?.cannedResponse && store.get(replyKey) === void 0 ? chatwoot.cannedResponse(accountId2, kind.cannedResponse) : Promise.resolve(void 0),
-    actionable && assignee !== void 0 && !kind?.status ? chatwoot.listAgents(accountId2) : Promise.resolve(void 0)
-  );
   let current = await fresh();
   if (current === "defer" || !current) return current;
   if (current.handoff) return handoff(current);
@@ -998,21 +852,12 @@ async function routeConversation(ctx, accountId2, conversationId) {
       ...[topic, kind ? decision.kind : null].filter((label) => label !== null)
     ])
   ];
-  let changed = false;
-  if (labels.length !== current.conversation.labels.length) {
-    await bot.setLabels(accountId2, conversationId, labels);
-    changed = true;
-  }
+  if (labels.length !== current.conversation.labels.length) await bot.setLabels(accountId2, conversationId, labels);
+  const replyKey = `reply:${accountId2}:${conversationId}`;
   if (kind?.cannedResponse) {
     let history;
     try {
-      if (changed) {
-        current = await fresh();
-        if (current === "defer" || !current) return current;
-        if (current.handoff) return handoff(current);
-        changed = false;
-      }
-      history = await replyHistory(chatwoot, accountId2, conversationId, botId, current.pages);
+      history = await replyHistory(chatwoot, accountId2, conversationId, botId);
     } catch (error) {
       log.warn("reply history unavailable; handing off", { accountId: accountId2, conversationId, ...errorFields(error) });
       return handoff();
@@ -1020,6 +865,7 @@ async function routeConversation(ctx, accountId2, conversationId) {
     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;
@@ -1028,7 +874,6 @@ async function routeConversation(ctx, accountId2, conversationId) {
       try {
         const message = await bot.createMessage(accountId2, conversationId, { content, private: false, files: [] });
         if (!confirmedReply(message, botId) || message?.conversation_id !== conversationId) return handoff();
-        changed = true;
       } catch (error) {
         log.warn("reply creation unconfirmed; handing off", { accountId: accountId2, conversationId, ...errorFields(error) });
         return handoff();
@@ -1036,13 +881,12 @@ async function routeConversation(ctx, accountId2, conversationId) {
     }
   }
   if (assignee !== void 0 && !kind?.status) {
-    if (!agents?.some((agent) => agent.id === assignee)) return handoff();
-  }
-  if (changed) {
-    current = await fresh();
-    if (current === "defer" || !current) return current;
-    if (current.handoff) return handoff(current);
+    const agents = await chatwoot.listAgents(accountId2);
+    if (!agents.some((agent) => agent.id === assignee)) return handoff();
   }
+  current = await fresh();
+  if (current === "defer" || !current) return current;
+  if (current.handoff) return handoff(current);
   if (kind?.status) {
     await bot.setStatus(accountId2, conversationId, { status: kind.status });
     expectActivity(store, accountId2, conversationId, { status: kind.status });
@@ -1112,10 +956,7 @@ async function decide(ctx, owners, kinds, text2) {
       body: JSON.stringify({ model: routing.model, state: { ticket: text2 }, questions })
     })
   );
-  if (!response.ok) {
-    await response.body?.cancel();
-    throw new JevError(`HTTP ${response.status}`);
-  }
+  if (!response.ok) throw new JevError(`HTTP ${response.status}`);
   const parsed = jevResponseSchema.safeParse(await response.json().catch(() => void 0));
   if (!parsed.success) throw new JevError("invalid response");
   const answer = (question) => {
@@ -1157,7 +998,7 @@ async function readConfig(env) {
   if (env.CONFIG_KEY === void 0) return typeof env.CONFIG === "string" ? parseJson(env.CONFIG) : env.CONFIG;
   if (env.CONFIG !== void 0) throw new ConfigError("Invalid CONFIG: set either CONFIG or CONFIG_KEY");
   if (!env.CONFIG_STORE) throw new ConfigError("Invalid CONFIG_KEY: requires the CONFIG_STORE KV namespace");
-  const config = await within(env.CONFIG_STORE.get(env.CONFIG_KEY, "json"), AbortSignal.timeout(1500));
+  const config = await env.CONFIG_STORE.get(env.CONFIG_KEY, "json");
   if (config === null) throw new ConfigError("Invalid CONFIG_KEY: not in CONFIG_STORE");
   return config;
 }
@@ -1263,14 +1104,19 @@ function buildSettings(config, secrets) {
 var loadSettings = settingsLoader(parseSettings);
 
 // src/router.ts
-function conversationName(accountId2, conversationId) {
-  return `${accountId2}:${conversationId}`;
+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 ROUTE_BUDGET = 45;
 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("route"), accountId: id, conversationId: id }),
+  z6.object({ type: z6.literal("sweep"), accountId: id, status: z6.enum(["pending", "open"]) })
 ]);
 var Router = class extends DurableObject {
   store;
@@ -1284,7 +1130,14 @@ var Router = class extends DurableObject {
     if (!routesAccount(settings, accountId2)) return;
     if (transition) expectActivity(this.store, accountId2, conversationId, transition);
     this.enqueue({ type: "route", accountId: accountId2, conversationId });
-    await scheduleAlarm(this.ctx, this.store.nextWakeup());
+    await this.schedule();
+  }
+  async requestSweep() {
+    for (const accountId2 of Object.keys((await loadSettings(this.env)).config.routing.accounts)) {
+      for (const status of ["pending", "open"])
+        this.enqueue({ type: "sweep", accountId: Number(accountId2), status });
+    }
+    await this.schedule();
   }
   async alarm() {
     const settings = await loadSettings(this.env);
@@ -1301,18 +1154,28 @@ var Router = class extends DurableObject {
         continue;
       }
       const payload = parsed.data;
-      if (budget.remaining < ROUTE_BUDGET || Date.now() - started > RUN_WALL_MS) {
+      if (budget.remaining < BUDGET[payload.type] || Date.now() - started > RUN_WALL_MS) {
         yielded = true;
         break;
       }
       try {
-        const ctx = { settings, chatwoot, store: this.store, fetch: budget.fetchWith(JOB_SLICE_MS) };
-        if (await routeConversation(ctx, payload.accountId, payload.conversationId) === "defer") {
-          this.store.deferJob(job);
-          yielded = true;
-          break;
+        const ctx = { settings, chatwoot, store: this.store, fetch: budget.fetch };
+        if (payload.type === "route") {
+          if (await routeConversation(ctx, payload.accountId, payload.conversationId) === "defer") {
+            this.store.deferJob(job);
+            yielded = true;
+            break;
+          }
+          clearFailures(this.store, payload.accountId, payload.conversationId);
+        } else if (routesAccount(settings, payload.accountId)) {
+          await this.sweep(
+            chatwoot,
+            budget,
+            payload.accountId,
+            payload.status,
+            settings.config.routing.botIds[String(payload.accountId)]
+          );
         }
-        clearFailures(this.store, payload.accountId, payload.conversationId);
         this.store.completeJob(job);
       } catch (error) {
         if (error instanceof ChatwootError && error.conversationMissing) {
@@ -1325,7 +1188,7 @@ var Router = class extends DurableObject {
           yielded = true;
           break;
         }
-        const attempts = recordFailure(this.store, payload.accountId, payload.conversationId);
+        const attempts = payload.type === "route" ? recordFailure(this.store, payload.accountId, payload.conversationId) : job.attempts + 1;
         const delay = retryDelay(attempts - 1);
         const logAt = attempts >= 3 ? log.error : log.warn;
         logAt("job failed; will retry", {
@@ -1337,126 +1200,62 @@ var Router = class extends DurableObject {
         this.store.retryJob(job, delay);
       }
     }
-    await scheduleAlarm(this.ctx, yielded ? Date.now() : this.store.nextWakeup());
+    await this.schedule(yielded ? Date.now() : void 0);
+  }
+  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, String(page + 1));
+    this.enqueue({ type: "sweep", accountId: accountId2, status });
   }
   enqueue(payload) {
-    this.store.enqueue(`route:${payload.accountId}:${payload.conversationId}`, 0, JSON.stringify(payload));
+    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));
   }
-};
-
-// src/coordinator.ts
-var COORDINATOR_NAME = "global";
-var sweepSchema = z7.object({ accountId: z7.number().int().positive(), status: z7.enum(["pending", "open"]) });
-var pageSchema = z7.object({
-  page: z7.number().int().positive()
-});
-var deliverySchema = z7.object({
-  accountId: z7.number().int().positive(),
-  conversationId: z7.number().int().positive()
-});
-var Coordinator = class extends DurableObject2 {
-  store;
-  constructor(ctx, env) {
-    super(ctx, env);
-    this.store = new QueueStore(ctx.storage.sql);
-    this.store.migrate();
-  }
-  async requestSweep() {
-    for (const accountId2 of Object.keys((await loadSettings(this.env)).config.routing.accounts)) {
-      for (const status of ["pending", "open"]) {
-        this.store.enqueue(`sweep:${accountId2}:${status}`, 0, JSON.stringify({ accountId: Number(accountId2), status }));
-      }
-    }
-    await scheduleAlarm(this.ctx, this.store.nextWakeup());
-  }
-  async alarm() {
-    const settings = await loadSettings(this.env);
-    const budget = new Budget(settings.config.subrequestBudget);
-    budget.startSlice();
-    const job = this.store.nextDueJobs(1, "sweep:")[0];
-    if (job) {
-      const parsed = sweepSchema.safeParse(parseJson(job.payload));
-      if (!parsed.success) this.store.deleteJob(job.key);
-      else {
-        try {
-          const { accountId: accountId2, status } = parsed.data;
-          const chatwoot = chatwootClient(
-            settings.config.chatwoot.baseUrl,
-            settings.secrets.CHATWOOT_TOKEN,
-            budget.fetch
-          );
-          const saved = pageSchema.safeParse(parseJson(this.store.get(job.key)));
-          const checkpoint = saved.success ? saved.data : { page: 1 };
-          const botId = settings.config.routing.botIds[String(accountId2)];
-          const conversations = await chatwoot.listConversations(accountId2, checkpoint.page, status);
-          this.ctx.storage.transactionSync(() => {
-            for (const conversation of conversations) {
-              if (conversation.id !== void 0 && (status === "pending" || conversation.meta?.assignee_type === "AgentBot" && conversation.meta.assignee?.id === botId))
-                this.store.enqueue(
-                  `delivery:${accountId2}:${conversation.id}`,
-                  1,
-                  JSON.stringify({ accountId: accountId2, conversationId: conversation.id })
-                );
-            }
-            if (conversations.length === 0) {
-              this.store.delete(job.key);
-              this.store.completeJob(job);
-            } else {
-              this.store.set(job.key, JSON.stringify({ page: checkpoint.page + 1 }));
-              this.store.deferJob(job);
-            }
-          });
-        } catch (error) {
-          this.store.retryJob(job, retryDelay(job.attempts));
-          log.warn("sweep page failed; will retry", { job: job.key, ...errorFields(error) });
-        }
-      }
-    }
-    const deliveries = this.store.nextDueJobs(12, "delivery:");
-    for (let start = 0; start < deliveries.length; start += 3) {
-      if (budget.remaining < 3) break;
-      await Promise.all(
-        deliveries.slice(start, start + 3).map(async (child) => {
-          const target = deliverySchema.safeParse(parseJson(child.payload));
-          if (!target.success) {
-            this.store.deleteJob(child.key);
-            return;
-          }
-          const { accountId: accountId2, conversationId } = target.data;
-          try {
-            budget.consume();
-            await within(
-              this.env.ROUTER.getByName(conversationName(accountId2, conversationId)).enqueueConversation(
-                accountId2,
-                conversationId
-              ),
-              budget.controlSignal(200)
-            );
-            this.store.completeJob(child);
-          } catch (error) {
-            this.store.retryJob(child, retryDelay(child.attempts));
-            log.warn("sweep child delivery delayed", { accountId: accountId2, conversationId, ...errorFields(error) });
-          }
-        })
-      );
-    }
-    await scheduleAlarm(this.ctx, this.store.nextWakeup());
+  async schedule(at) {
+    const next = at ?? this.store.nextWakeup();
+    if (next === void 0) return;
+    const current = await this.ctx.storage.getAlarm();
+    if (current === null || current > next) await this.ctx.storage.setAlarm(next);
   }
 };
 
 // src/webhook.ts
-import { z as z8 } from "zod";
-var id2 = z8.number().int().positive();
-var eventSchema = z8.object({
-  event: z8.string(),
-  account: z8.object({ id: id2 }),
+import { z as z7 } from "zod";
+var id2 = z7.number().int().positive();
+var eventSchema = z7.object({
+  event: z7.string(),
+  account: z7.object({ id: id2 }),
   id: id2.optional(),
-  conversation: z8.object({ id: id2 }).optional(),
-  message_type: z8.union([z8.string(), z8.number()]).optional(),
-  private: z8.boolean().optional(),
-  updated_at: z8.number().optional(),
-  changed_attributes: z8.array(z8.object({ status: z8.object({ previous_value: z8.string(), current_value: z8.string() }).optional() })).optional(),
-  sender: z8.object({ type: z8.string().optional() }).nullish()
+  conversation: z7.object({ id: id2 }).optional(),
+  message_type: z7.union([z7.string(), z7.number()]).optional(),
+  private: z7.boolean().optional(),
+  updated_at: z7.number().optional(),
+  changed_attributes: z7.array(z7.object({ status: z7.object({ previous_value: z7.string(), current_value: z7.string() }).optional() })).optional(),
+  sender: z7.object({ type: z7.string().optional() }).nullish()
 });
 var CONVERSATION_EVENTS = /* @__PURE__ */ new Set([
   "conversation_opened",
@@ -1520,13 +1319,10 @@ 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 within(
-    context.env.ROUTER.getByName(conversationName(target.accountId, target.conversationId)).enqueueConversation(
-      target.accountId,
-      target.conversationId,
-      target.transition
-    ),
-    AbortSignal.timeout(METADATA_TIMEOUT_MS)
+  await conversationRouter(context.env, target.accountId, target.conversationId).enqueueConversation(
+    target.accountId,
+    target.conversationId,
+    target.transition
   );
   return context.json({ ok: true });
 });
@@ -1538,13 +1334,10 @@ app.onError((error, context) => {
 var src_default = {
   fetch: app.fetch,
   async scheduled(_controller, env, context) {
-    context.waitUntil(
-      within(env.COORDINATOR.getByName(COORDINATOR_NAME).requestSweep(), AbortSignal.timeout(METADATA_TIMEOUT_MS))
-    );
+    context.waitUntil(sweeper(env).requestSweep());
   }
 };
 export {
-  Coordinator,
   Router,
   src_default as default
 };

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

@@ -2,4 +2,4 @@ import { type ChatwootClient, type ChatwootMessage } from "../../../shared/chatw
 /** 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, freshPages?: readonly ChatwootMessage[][]): Promise<"found" | "complete-none" | "unknown">;
+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,11 +1,15 @@
 import { DurableObject } from "cloudflare:workers";
 import type { Env } from "./env.ts";
 import type { Transition } from "./webhook.ts";
-export declare function conversationName(accountId: number, conversationId: number): string;
+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);
     enqueueConversation(accountId: number, conversationId: number, transition?: Transition): Promise<void>;
+    requestSweep(): Promise<void>;
     alarm(): Promise<void>;
+    private sweep;
     private enqueue;
+    private schedule;
 }

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

@@ -9,58 +9,6 @@ export declare function requestHandoff(store: RoutingStore, accountId: number, c
 export declare function recordFailure(store: RoutingStore, accountId: number, conversationId: number): number;
 export declare function clearFailures(store: RoutingStore, accountId: number, conversationId: number): void;
 export declare function readTurn(chatwoot: ChatwootClient, store: RoutingStore, accountId: number, conversationId: number): Promise<{
-    pages: {
-        id: number;
-        conversation_id?: number | undefined;
-        content?: string | null | undefined;
-        message_type: number;
-        content_type?: string | null | undefined;
-        status?: string | null | undefined;
-        created_at?: number | null | undefined;
-        private?: boolean | null | undefined;
-        content_attributes?: {
-            email?: {
-                subject?: string | null | undefined;
-                auto_reply?: boolean | null | undefined;
-                text_content?: {
-                    quoted?: string | null | undefined;
-                } | null | undefined;
-                html_content?: {
-                    quoted?: string | null | undefined;
-                } | null | undefined;
-            } | null | undefined;
-            deleted?: boolean | null | undefined;
-            external_error?: string | null | undefined;
-            activity?: {
-                type?: string | null | undefined;
-                status?: string | null | undefined;
-            } | null | undefined;
-            submitted_values?: unknown;
-            submitted_email?: unknown;
-            items?: unknown;
-        } | null | undefined;
-        sender?: {
-            id?: number | null | undefined;
-            name?: string | null | undefined;
-            email?: string | null | undefined;
-            type?: string | null | undefined;
-            thumbnail?: string | null | undefined;
-            avatar_url?: string | null | undefined;
-        } | null | undefined;
-        attachments?: {
-            file_type?: string | null | undefined;
-            data_url?: string | null | undefined;
-            fallback_title?: string | null | undefined;
-            coordinates_lat?: number | null | undefined;
-            coordinates_long?: number | null | undefined;
-            meta?: {
-                firstName?: string | null | undefined;
-                lastName?: string | null | undefined;
-                first_name?: string | null | undefined;
-                last_name?: string | null | undefined;
-            } | null | undefined;
-        }[] | null | undefined;
-    }[][];
     messages: {
         id: number;
         conversation_id?: number | undefined;

package/lib/shared/budget.d.ts

@@ -2,25 +2,14 @@ import type { Fetch } from "./chatwoot/api.ts";
 export declare class BudgetExhaustedError extends Error {
     constructor();
 }
-export { JobDeadlineError } from "./deadline.ts";
-export declare const METADATA_TIMEOUT_MS = 1500;
-export declare const TRANSFER_TIMEOUT_MS = 8000;
-export declare const JOB_SLICE_MS = 10000;
 export declare class Budget {
     readonly limit: number;
     private readonly fetchImpl;
+    private readonly timeoutMs;
     private used;
-    private slice;
-    private sliceEnds;
-    constructor(limit: number, fetchImpl?: Fetch);
+    constructor(limit: number, fetchImpl?: Fetch, timeoutMs?: number);
     get remaining(): number;
-    startSlice(ms?: number): void;
-    requireTime(ms: number): void;
-    checkpoint(): void;
+    /** Counts a request that is not a fetch, such as a call to another Durable Object. */
     consume(): void;
-    require(requests: number): void;
-    controlSignal(ms: number): AbortSignal;
-    fetchWith(timeoutMs: number): Fetch;
     readonly fetch: Fetch;
-    private request;
 }

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

@@ -1,5 +1,4 @@
 import { z } from "zod";
-import type { RateLimitStore } from "../rate-limit.ts";
 import type { RelayConversation, RelayMessage } from "../types.ts";
 import type { components, operations } from "./schema.ts";
 export type Fetch = (input: Request) => Promise<Response>;
@@ -7,8 +6,7 @@ export type Fetch = (input: Request) => Promise<Response>;
 export declare class ChatwootError extends Error {
     readonly status: number;
     readonly conversationMissing: boolean;
-    readonly retryAfterMs: number | undefined;
-    constructor(status: number, operation: string, conversationMissing?: boolean, retryAfterMs?: number);
+    constructor(status: number, operation: string, conversationMissing?: boolean);
 }
 /**
  * A conversation as returned by GET conversations/{id} and in the conversation list. The spec's
@@ -99,7 +97,7 @@ export type ChatwootClient = ReturnType<typeof chatwootClient>;
 type MessageQuery = NonNullable<operations["list-all-messages"]["parameters"]["query"]> & {
     filter_internal_messages?: true;
 };
-export declare function chatwootClient(baseUrl: string, token: string, fetch: Fetch, limits?: RateLimitStore): {
+export declare function chatwootClient(baseUrl: string, token: string, fetch: Fetch): {
     /** The conversation, or undefined when it does not exist (it was deleted). */
     getConversation(accountId: number, conversationId: number): Promise<ChatwootConversation | undefined>;
     /** Messages with an id above `after`, oldest first; without `after`, the latest page. */

package/lib/shared/store.d.ts

@@ -1,18 +1,16 @@
 export declare function retryDelay(attempts: number): number;
-export type Job = {
+export interface Job {
     key: string;
     payload: string;
     version: number;
     attempts: number;
     /** When the job was first queued (ms since the epoch). */
     createdAt: number;
-};
+}
 export declare class QueueStore {
     protected readonly sql: SqlStorage;
     protected readonly now: () => number;
-    private readonly atomic;
-    constructor(sql: SqlStorage, now?: () => number, atomic?: <T>(write: () => T) => T);
-    transaction<T>(write: () => T): T;
+    constructor(sql: SqlStorage, now?: () => number);
     migrate(): void;
     get(key: string): string | undefined;
     set(key: string, value: string, ttlMs?: number): void;
@@ -23,8 +21,6 @@ export declare class QueueStore {
      */
     enqueue(key: string, priority: number, payload: string, notBefore?: number): void;
     nextDueJob(): Job | undefined;
-    /** A bounded due batch; independent scan and delivery work can select their own keys. */
-    nextDueJobs(limit: number, prefix?: string): Job[];
     /** Earliest due time. */
     nextWakeup(): number | undefined;
     /** Removes a finished job unless it was enqueued again while running. */
@@ -36,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.3.0",
+  "version": "0.4.0",
   "description": "Route Chatwoot conversations with TypeSafe Jev on Cloudflare Workers.",
   "keywords": [
     "chatwoot",

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

@@ -1,10 +0,0 @@
-import { DurableObject } from "cloudflare:workers";
-import type { Env } from "./env.ts";
-export declare const COORDINATOR_NAME = "global";
-/** Lists one page per alarm. Conversation state belongs exclusively to the conversation's Router. */
-export declare class Coordinator extends DurableObject<Env> {
-    private readonly store;
-    constructor(ctx: DurableObjectState, env: Env);
-    requestSweep(): Promise<void>;
-    alarm(): Promise<void>;
-}

package/lib/shared/alarm.d.ts

@@ -1,2 +0,0 @@
-/** Set the one Durable Object alarm for the earliest durable wake-up. */
-export declare function scheduleAlarm(state: DurableObjectState, next: number | undefined): Promise<void>;

package/lib/shared/concurrent.d.ts

@@ -1,4 +0,0 @@
-/** Finish or cancel every independent read before the caller can yield to another job. */
-export declare function parallel<T extends readonly unknown[]>(...reads: {
-    [K in keyof T]: Promise<T[K]>;
-}): Promise<T>;

package/lib/shared/deadline.d.ts

@@ -1,6 +0,0 @@
-/** Bounds non-fetch dependencies too, including an RPC whose enqueue outcome can be unknown. */
-export declare function within<T>(pending: Promise<T>, signal: AbortSignal): Promise<T>;
-export declare class JobDeadlineError extends Error {
-    readonly requestStarted: boolean;
-    constructor(requestStarted?: boolean);
-}

package/lib/shared/rate-limit.d.ts

@@ -1,5 +0,0 @@
-/** Cache-aside state shared by upstream clients' durable cooldown stores. */
-export interface RateLimitStore {
-    get(key: string): string | undefined;
-    set(key: string, value: string, ttlMs?: number): void;
-}