chatwoot-router 0.3.0 → 0.5.0

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,15 +108,18 @@ 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;
   }
 };
+function snoozedUntil(conversation) {
+  const value = conversation.snoozed_until;
+  const ms = typeof value === "string" ? Date.parse(value) : Number.NaN;
+  return Number.isNaN(ms) ? null : Math.floor(ms / 1e3);
+}
 var text = z2.string().nullish();
 var attachmentSchema = z2.object({
   file_type: text,
@@ -252,33 +169,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;
@@ -536,6 +438,8 @@ function toRelayConversation(conversationId, conversation) {
     },
     assignee: assignee ? { id: assignee.id, name: assignee.name } : null,
     assigneeType: meta?.assignee_type ?? null,
+    waitingSince: conversation.waiting_since || null,
+    snoozedUntil: snoozedUntil(conversation),
     customAttributes: conversation.custom_attributes ?? {}
   };
 }
@@ -559,17 +463,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 +477,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 +503,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 +513,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 +549,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 +655,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 +698,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
@@ -913,8 +788,7 @@ async function routeConversation(ctx, accountId2, conversationId) {
       return;
     }
     const conversation = toRelayConversation(conversationId, raw);
-    if (conversation.assignee) return;
-    if (raw.meta?.assignee && (raw.meta.assignee_type !== "AgentBot" || raw.meta.assignee.id !== botId)) return;
+    if (raw.meta?.assignee_type === "AgentBot" && raw.meta.assignee?.id !== botId) return;
     if ((await chatwoot.inboxBot(accountId2, raw.inbox_id))?.id !== botId) {
       if (owns(raw)) {
         const latest = await chatwoot.getConversation(accountId2, conversationId);
@@ -953,9 +827,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 +838,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,18 +847,10 @@ 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);
-  if (!kind && decision.noRequest && input.count < MAX_MESSAGES) return;
+  if (!kind && decision.noRequest && input.count < MAX_MESSAGES && !current.conversation.assignee) return;
   const topic = !kind?.status && decision.topic !== null && Object.hasOwn(routing.topics ?? {}, decision.topic) && decision.topicConfidence >= routing.minConfidence && current.conversation.labels.every((label) => Object.hasOwn(kinds, label)) ? decision.topic : null;
   const labels = [
     .../* @__PURE__ */ new Set([
@@ -998,21 +858,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 +871,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 +880,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 +887,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 +962,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 +1004,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 +1110,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 +1136,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 +1160,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 +1194,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 +1206,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 +1325,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 +1340,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
 };