chatwoot-router 0.2.0 → 0.3.0

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

@@ -2,6 +2,118 @@
 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();
@@ -65,37 +177,16 @@ function errorFields(error) {
   return error instanceof Error ? { error: error.name, detail: error.message } : { error: String(error) };
 }
 
-// src/router.ts
-import { DurableObject } from "cloudflare:workers";
-import { z as z6 } from "zod";
+// src/coordinator.ts
+import { DurableObject as DurableObject2 } from "cloudflare:workers";
+import { z as z7 } from "zod";
 
-// ../../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;
-  }
-  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/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/chatwoot/api.ts
 import createClient from "openapi-fetch";
@@ -103,11 +194,13 @@ import { z as z2 } from "zod";
 var ChatwootError = class extends Error {
   status;
   conversationMissing;
-  constructor(status, operation, conversationMissing = false) {
+  retryAfterMs;
+  constructor(status, operation, conversationMissing = false, retryAfterMs) {
     super(`Chatwoot ${operation} failed with HTTP ${status}`);
     this.name = "ChatwootError";
     this.status = status;
     this.conversationMissing = conversationMissing;
+    this.retryAfterMs = retryAfterMs;
   }
 };
 var text = z2.string().nullish();
@@ -136,6 +229,7 @@ var emailSchema = z2.object({
 });
 var messageSchema = z2.object({
   id: z2.number(),
+  conversation_id: z2.number().optional(),
   content: text,
   message_type: z2.number(),
   content_type: text,
@@ -162,13 +256,29 @@ 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) {
+function chatwootClient(baseUrl, token, fetch2, limits) {
   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: (request) => fetch2(new Request(request, { redirect: "manual" }))
+    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;
+    }
   });
   async function data(operation, pending) {
     const { data: data2, response } = await pending;
@@ -197,15 +307,6 @@ function chatwootClient(baseUrl, token, fetch2) {
     );
     return list && messageListSchema.parse(list).payload.toSorted((a, b) => a.id - b.id);
   }
-  function setCustomAttributes(accountId2, conversationId, attributes) {
-    return ensureOk(
-      "set custom attribute",
-      client.POST("/api/v1/accounts/{account_id}/conversations/{conversation_id}/custom_attributes", {
-        params: { path: { account_id: accountId2, conversation_id: conversationId } },
-        body: { custom_attributes: attributes, merge: true }
-      })
-    );
-  }
   return {
     /** The conversation, or undefined when it does not exist (it was deleted). */
     getConversation(accountId2, conversationId) {
@@ -231,15 +332,6 @@ function chatwootClient(baseUrl, token, fetch2) {
       const messages = await listMessages(accountId2, conversationId, { after: messageId - 1, before: messageId + 1 });
       return messages?.find((message) => message.id === messageId);
     },
-    async listInboxes(accountId2) {
-      const list = await data(
-        "list inboxes",
-        client.GET("/api/v1/accounts/{account_id}/inboxes", {
-          params: { path: { account_id: accountId2 } }
-        })
-      );
-      return (list.payload ?? []).flatMap((inbox) => inbox.id === void 0 ? [] : [inbox.id]);
-    },
     async inboxBot(accountId2, inboxId) {
       const value = await dataUnlessNotFound(
         "get inbox agent bot",
@@ -375,13 +467,21 @@ function chatwootClient(baseUrl, token, fetch2) {
         })
       );
     },
-    setCustomAttributes,
+    setCustomAttributes(accountId2, conversationId, attributes) {
+      return ensureOk(
+        "set custom attribute",
+        client.POST("/api/v1/accounts/{account_id}/conversations/{conversation_id}/custom_attributes", {
+          params: { path: { account_id: accountId2, conversation_id: conversationId } },
+          body: { custom_attributes: attributes, merge: true }
+        })
+      );
+    },
     /**
      * Sends an outgoing message (or private note). With files it is sent as the spec's
      * multipart/form-data body; the generated type renders its `attachments[]` binaries as
      * strings, so the serializer appends the files itself.
      */
-    createMessage(accountId2, conversationId, message) {
+    async createMessage(accountId2, conversationId, message) {
       const fields = {
         content: message.content,
         message_type: "outgoing",
@@ -397,14 +497,17 @@ function chatwootClient(baseUrl, token, fetch2) {
         for (const file of message.files) form.append("attachments[]", file.blob, file.filename);
         return form;
       };
-      return ensureOk(
-        "create message",
-        client.POST("/api/v1/accounts/{account_id}/conversations/{conversation_id}/messages", {
+      const { data: data2, response } = await client.POST(
+        "/api/v1/accounts/{account_id}/conversations/{conversation_id}/messages",
+        {
           params: { path: { account_id: accountId2, conversation_id: conversationId } },
           body: fields,
           ...message.files.length === 0 ? {} : { bodySerializer: () => multipart(fields) }
-        })
+        }
       );
+      if (!response.ok) throw new ChatwootError(response.status, "create message", notFound(response));
+      const parsed = messageSchema.safeParse(data2);
+      return parsed.success ? parsed.data : void 0;
     }
   };
 }
@@ -456,12 +559,17 @@ function retryDelay(attempts) {
   return Math.min(5e3 * 2 ** attempts, 30 * 60 * 1e3);
 }
 var QueueStore = class {
-  constructor(sql, now = Date.now) {
+  constructor(sql, now = Date.now, atomic = (write2) => write2()) {
     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,
@@ -510,14 +618,20 @@ var QueueStore = class {
     );
   }
   nextDueJob() {
-    const row = this.sql.exec(
-      `SELECT key, payload, version, attempts, created_at FROM jobs WHERE suspended != 2 AND 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 };
+    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();
   }
   /** Earliest due time. */
   nextWakeup() {
@@ -565,10 +679,42 @@ var QueueStore = class {
   }
 };
 
+// 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 = []) {
+  let before;
+  for (let page = 0; page < 5; page += 1) {
+    const messages = freshPages[page] ?? await chatwoot.listMessages(accountId2, conversationId, before === void 0 ? {} : { before });
+    for (const message of messages) {
+      if (confirmedReply(message, botId)) return "found";
+      if (message.message_type !== 1 || message.private === true) continue;
+      if (message.sender?.type == null || message.sender.type === "agent_bot" && (message.sender.id == null || message.sender.id === botId))
+        return "unknown";
+    }
+    if (messages.length < MESSAGE_HISTORY_PAGE_SIZE) return "complete-none";
+    const next = messages[0]?.id;
+    if (next === void 0 || before !== void 0 && next >= before) return "unknown";
+    before = next;
+  }
+  return "unknown";
+}
+
 // src/turn.ts
 import { z as z3 } from "zod";
 var guardSchema = z3.object({
@@ -632,12 +778,14 @@ 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;
@@ -675,7 +823,7 @@ async function readTurn(chatwoot, store, accountId2, conversationId) {
   }
   if (deleted || missing || !complete) guard.handoff = true;
   saveGuard(store, accountId2, conversationId, guard);
-  return { messages: messages.toReversed(), boundary: boundary?.id ?? 0, handoff: guard.handoff };
+  return { pages, messages: messages.toReversed(), boundary: boundary?.id ?? 0, handoff: guard.handoff };
 }
 
 // src/routing.ts
@@ -749,17 +897,33 @@ async function routeConversation(ctx, accountId2, conversationId) {
   const bot = chatwootClient(settings.config.chatwoot.baseUrl, token, ctx.fetch);
   const kinds = routing.kinds?.[String(accountId2)] ?? {};
   const botId = routing.botIds[String(accountId2)];
+  const owns = (conversation) => conversation?.meta?.assignee_type === "AgentBot" && conversation.meta.assignee?.id === botId;
+  const release = async () => {
+    const latest = await chatwoot.getConversation(accountId2, conversationId);
+    if (latest?.status !== void 0 && latest.status !== "pending" && owns(latest)) {
+      await bot.unassign(accountId2, conversationId);
+    }
+  };
   const snapshot = async (inboxId) => {
     const raw = await chatwoot.getConversation(accountId2, conversationId);
     if (!raw || raw.inbox_id === void 0 || inboxId !== void 0 && raw.inbox_id !== inboxId) return;
     if (raw.status !== "pending") {
       observeStatus(store, accountId2, conversationId, raw.status ?? "open");
+      if (raw.status !== void 0 && owns(raw)) await release();
       return;
     }
     const conversation = toRelayConversation(conversationId, raw);
-    if (conversation.contact.blocked || conversation.assignee) return;
+    if (conversation.assignee) return;
     if (raw.meta?.assignee && (raw.meta.assignee_type !== "AgentBot" || raw.meta.assignee.id !== botId)) return;
-    if ((await chatwoot.inboxBot(accountId2, raw.inbox_id))?.id !== botId) return;
+    if ((await chatwoot.inboxBot(accountId2, raw.inbox_id))?.id !== botId) {
+      if (owns(raw)) {
+        const latest = await chatwoot.getConversation(accountId2, conversationId);
+        if (latest?.status === "pending" && latest.inbox_id === raw.inbox_id && owns(latest))
+          await bot.setStatus(accountId2, conversationId, { status: "open" });
+      }
+      return;
+    }
+    if (conversation.contact.blocked) return;
     observeStatus(store, accountId2, conversationId, "pending");
     return { raw, conversation };
   };
@@ -782,15 +946,16 @@ async function routeConversation(ctx, accountId2, conversationId) {
   };
   const turn = await readTurn(chatwoot, store, accountId2, conversationId);
   const input = inputs(turn.messages);
-  const humanReply = (messages) => messages.some(
-    (message) => message.message_type === 1 && !message.private && message.sender?.type === "user" && !message.content_attributes?.deleted
+  const requiresHandoff = (messages) => messages.some(
+    (message) => message.message_type === 1 && !message.private && (message.sender?.type === "user" && !message.content_attributes?.deleted || message.sender?.type === "agent_bot" && message.sender.id === botId && (message.status === "failed" || message.content_attributes?.deleted))
   );
   const fresh = async () => {
     const current2 = await snapshot(initial.raw.inbox_id);
     if (!current2) return;
     const latest = await readTurn(chatwoot, store, accountId2, conversationId);
-    if (latest.boundary !== turn.boundary || inputs(latest.messages).key !== input.key) return "defer";
-    return { ...current2, handoff: latest.handoff || humanReply(latest.messages) };
+    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) };
   };
   const handoff = async (current2) => {
     requestHandoff(store, accountId2, conversationId);
@@ -799,15 +964,29 @@ async function routeConversation(ctx, accountId2, conversationId) {
     if (current2) await bot.setStatus(accountId2, conversationId, { status: "open" });
     return void 0;
   };
-  if (turn.handoff || humanReply(turn.messages) || input.count === 0) return handoff();
-  const memoKey = `decision:${accountId2}:${conversationId}:${input.key}`;
-  let decision = readDecision(store.get(memoKey));
+  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 memo = decisionSchema.safeParse(parseJson(store.get(memoKey)));
+  let decision = memo.success ? memo.data : void 0;
   if (!decision) {
     decision = await decide(ctx, owners, routing.kinds?.[String(accountId2)], input.text);
     store.set(memoKey, JSON.stringify(decision));
   }
   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);
@@ -819,27 +998,55 @@ async function routeConversation(ctx, accountId2, conversationId) {
       ...[topic, kind ? decision.kind : null].filter((label) => label !== null)
     ])
   ];
-  if (labels.length !== current.conversation.labels.length) await bot.setLabels(accountId2, conversationId, labels);
-  const replyKey = `reply:${accountId2}:${conversationId}`;
-  if (kind?.cannedResponse && store.get(replyKey) === void 0) {
-    const content = await chatwoot.cannedResponse(accountId2, kind.cannedResponse);
-    if (!content?.trim()) return handoff();
+  let changed = false;
+  if (labels.length !== current.conversation.labels.length) {
+    await bot.setLabels(accountId2, conversationId, labels);
+    changed = true;
+  }
+  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);
+    } catch (error) {
+      log.warn("reply history unavailable; handing off", { accountId: accountId2, conversationId, ...errorFields(error) });
+      return handoff();
+    }
+    if (history === "unknown" || history === "complete-none" && store.get(replyKey) !== void 0) return handoff();
+    if (history === "found" && store.get(replyKey) === void 0) store.set(replyKey, "observed");
+    if (history === "complete-none") {
+      if (!content?.trim()) return handoff();
+      current = await fresh();
+      if (current === "defer" || !current) return current;
+      if (current.handoff) return handoff(current);
+      store.set(replyKey, "attempted");
+      try {
+        const message = await bot.createMessage(accountId2, conversationId, { content, private: false, files: [] });
+        if (!confirmedReply(message, botId) || message?.conversation_id !== conversationId) return handoff();
+        changed = true;
+      } catch (error) {
+        log.warn("reply creation unconfirmed; handing off", { accountId: accountId2, conversationId, ...errorFields(error) });
+        return handoff();
+      }
+    }
+  }
+  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);
-    store.set(replyKey, "attempted");
-    await bot.createMessage(accountId2, conversationId, { content, private: false, files: [] });
-  }
-  if (assignee !== void 0 && !kind?.status) {
-    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 });
+    await release();
   } else if (assignee !== void 0 && current.raw.meta?.assignee_type === "AgentBot") {
     await bot.assign(accountId2, conversationId, assignee);
     expectActivity(store, accountId2, conversationId, { status: "open" });
@@ -905,7 +1112,10 @@ async function decide(ctx, owners, kinds, text2) {
       body: JSON.stringify({ model: routing.model, state: { ticket: text2 }, questions })
     })
   );
-  if (!response.ok) throw new JevError(`HTTP ${response.status}`);
+  if (!response.ok) {
+    await response.body?.cancel();
+    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) => {
@@ -929,10 +1139,6 @@ async function decide(ctx, owners, kinds, text2) {
     noRequest: request.choice === "none" && request.confidence >= routing.minConfidence
   };
 }
-function readDecision(stored) {
-  const parsed = decisionSchema.safeParse(parseJson(stored));
-  return parsed.success ? parsed.data : void 0;
-}
 
 // ../../shared/settings.ts
 function settingsLoader(parse) {
@@ -951,7 +1157,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 env.CONFIG_STORE.get(env.CONFIG_KEY, "json");
+  const config = await within(env.CONFIG_STORE.get(env.CONFIG_KEY, "json"), AbortSignal.timeout(1500));
   if (config === null) throw new ConfigError("Invalid CONFIG_KEY: not in CONFIG_STORE");
   return config;
 }
@@ -1057,48 +1263,28 @@ function buildSettings(config, secrets) {
 var loadSettings = settingsLoader(parseSettings);
 
 // src/router.ts
-var ROUTER_NAME = "global";
+function conversationName(accountId2, conversationId) {
+  return `${accountId2}:${conversationId}`;
+}
 var ROUTE_BUDGET = 45;
-var BUDGET = { route: ROUTE_BUDGET, sweep: 2 };
 var RUN_WALL_MS = 5 * 60 * 1e3;
 var id = z6.number().int().positive();
 var jobSchema = z6.discriminatedUnion("type", [
-  z6.object({ type: z6.literal("route"), accountId: id, conversationId: id }),
-  z6.object({ type: z6.literal("sweep"), accountId: id })
+  z6.object({ type: z6.literal("route"), accountId: id, conversationId: id })
 ]);
-var passSchema = z6.object({
-  page: z6.number().int().positive(),
-  remaining: z6.array(id),
-  routed: z6.array(id)
-});
 var Router = class extends DurableObject {
   store;
   constructor(context, env) {
     super(context, env);
     this.store = new QueueStore(context.storage.sql);
-    context.blockConcurrencyWhile(async () => {
-      this.store.migrate();
-      if (!this.store.get("migration:agent-bot")) {
-        context.storage.sql.exec("DELETE FROM jobs");
-        for (const prefix of ["seen:", "decision:", "assign:", "labels:", "status:", "sweep:"]) {
-          context.storage.sql.exec("DELETE FROM cache WHERE key >= ? AND key < ?", prefix, `${prefix.slice(0, -1)};`);
-        }
-        this.store.set("migration:agent-bot", "1");
-      }
-    });
+    this.store.migrate();
   }
   async enqueueConversation(accountId2, conversationId, transition) {
     const settings = await loadSettings(this.env);
     if (!routesAccount(settings, accountId2)) return;
     if (transition) expectActivity(this.store, accountId2, conversationId, transition);
     this.enqueue({ type: "route", accountId: accountId2, conversationId });
-    await this.schedule();
-  }
-  async requestSweep() {
-    for (const accountId2 of Object.keys((await loadSettings(this.env)).config.routing.accounts)) {
-      this.enqueue({ type: "sweep", accountId: Number(accountId2) });
-    }
-    await this.schedule();
+    await scheduleAlarm(this.ctx, this.store.nextWakeup());
   }
   async alarm() {
     const settings = await loadSettings(this.env);
@@ -1115,22 +1301,18 @@ var Router = class extends DurableObject {
         continue;
       }
       const payload = parsed.data;
-      if (budget.remaining < BUDGET[payload.type] || Date.now() - started > RUN_WALL_MS) {
+      if (budget.remaining < ROUTE_BUDGET || Date.now() - started > RUN_WALL_MS) {
         yielded = true;
         break;
       }
       try {
-        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(settings, chatwoot, payload.accountId);
+        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;
         }
+        clearFailures(this.store, payload.accountId, payload.conversationId);
         this.store.completeJob(job);
       } catch (error) {
         if (error instanceof ChatwootError && error.conversationMissing) {
@@ -1143,7 +1325,7 @@ var Router = class extends DurableObject {
           yielded = true;
           break;
         }
-        const attempts = payload.type === "route" ? recordFailure(this.store, payload.accountId, payload.conversationId) : job.attempts + 1;
+        const attempts = recordFailure(this.store, payload.accountId, payload.conversationId);
         const delay = retryDelay(attempts - 1);
         const logAt = attempts >= 3 ? log.error : log.warn;
         logAt("job failed; will retry", {
@@ -1155,59 +1337,126 @@ var Router = class extends DurableObject {
         this.store.retryJob(job, delay);
       }
     }
-    await this.schedule(yielded ? Date.now() : void 0);
-  }
-  async sweep(settings, chatwoot, accountId2) {
-    const key = `sweep:${accountId2}:pending`;
-    const saved = passSchema.safeParse(parseJson(this.store.get(key)));
-    const pass = saved.success ? saved.data : { page: 1, remaining: await chatwoot.listInboxes(accountId2), routed: [] };
-    const inboxId = pass.remaining[0];
-    if (inboxId !== void 0) {
-      if ((await chatwoot.inboxBot(accountId2, inboxId))?.id === settings.config.routing.botIds[String(accountId2)]) {
-        pass.routed.push(inboxId);
+    await scheduleAlarm(this.ctx, yielded ? Date.now() : this.store.nextWakeup());
+  }
+  enqueue(payload) {
+    this.store.enqueue(`route:${payload.accountId}:${payload.conversationId}`, 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 }));
       }
-      pass.remaining.shift();
-    } else {
-      const conversations = await chatwoot.listConversations(accountId2, pass.page, "pending");
-      for (const conversation of conversations) {
-        if (conversation.id !== void 0 && conversation.inbox_id !== void 0 && pass.routed.includes(conversation.inbox_id)) {
-          this.enqueue({ type: "route", accountId: accountId2, conversationId: conversation.id });
+    }
+    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) });
         }
       }
-      if (conversations.length === 0) {
-        this.store.delete(key);
-        return;
-      }
-      pass.page += 1;
     }
-    this.store.set(key, JSON.stringify(pass));
-    this.enqueue({ type: "sweep", accountId: accountId2 });
-  }
-  enqueue(payload) {
-    const key = payload.type === "sweep" ? `sweep:${payload.accountId}` : `${payload.type}:${payload.accountId}:${payload.conversationId}`;
-    this.store.enqueue(key, payload.type === "sweep" ? 1 : 0, JSON.stringify(payload));
-  }
-  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);
+    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());
   }
 };
 
 // src/webhook.ts
-import { z as z7 } from "zod";
-var id2 = z7.number().int().positive();
-var eventSchema = z7.object({
-  event: z7.string(),
-  account: z7.object({ id: id2 }),
+import { z as z8 } from "zod";
+var id2 = z8.number().int().positive();
+var eventSchema = z8.object({
+  event: z8.string(),
+  account: z8.object({ id: id2 }),
   id: id2.optional(),
-  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()
+  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()
 });
 var CONVERSATION_EVENTS = /* @__PURE__ */ new Set([
   "conversation_opened",
@@ -1271,10 +1520,13 @@ app.post("/chatwoot/agent-bot", bodyLimit({ maxSize: 2 * 1024 * 1024 }), async (
   if (target.accountId !== signedBy || !routesAccount(settings, target.accountId)) {
     return context.text("account does not match the webhook secret", 403);
   }
-  await context.env.ROUTER.getByName(ROUTER_NAME).enqueueConversation(
-    target.accountId,
-    target.conversationId,
-    target.transition
+  await within(
+    context.env.ROUTER.getByName(conversationName(target.accountId, target.conversationId)).enqueueConversation(
+      target.accountId,
+      target.conversationId,
+      target.transition
+    ),
+    AbortSignal.timeout(METADATA_TIMEOUT_MS)
   );
   return context.json({ ok: true });
 });
@@ -1286,10 +1538,13 @@ app.onError((error, context) => {
 var src_default = {
   fetch: app.fetch,
   async scheduled(_controller, env, context) {
-    context.waitUntil(env.ROUTER.getByName(ROUTER_NAME).requestSweep());
+    context.waitUntil(
+      within(env.COORDINATOR.getByName(COORDINATOR_NAME).requestSweep(), AbortSignal.timeout(METADATA_TIMEOUT_MS))
+    );
   }
 };
 export {
+  Coordinator,
   Router,
   src_default as default
 };