chatwoot-router 0.1.0 → 0.2.0

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

@@ -67,7 +67,7 @@ function errorFields(error) {
 
 // src/router.ts
 import { DurableObject } from "cloudflare:workers";
-import { z as z7 } from "zod";
+import { z as z6 } from "zod";
 
 // ../../shared/budget.ts
 var BudgetExhaustedError = class extends Error {
@@ -148,6 +148,7 @@ var messageSchema = z2.object({
     email: emailSchema.nullish(),
     deleted: z2.boolean().nullish(),
     external_error: text,
+    activity: z2.object({ type: text, status: text }).nullish(),
     submitted_values: z2.unknown().optional(),
     submitted_email: z2.unknown().optional(),
     items: z2.unknown().optional()
@@ -157,7 +158,10 @@ var messageSchema = z2.object({
   attachments: z2.array(attachmentSchema).nullish()
 });
 var messageListSchema = z2.object({ payload: z2.array(messageSchema) });
-var MESSAGE_PAGE_SIZE = 100;
+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) {
   const client = createClient({
     baseUrl: baseUrl.replace(/\/+$/, ""),
@@ -174,7 +178,7 @@ function chatwootClient(baseUrl, token, fetch2) {
   async function dataUnlessNotFound(operation, pending) {
     const { data: data2, response } = await pending;
     if (notFound(response)) {
-      log.info("conversation deleted", { operation });
+      log.info("Chatwoot resource deleted", { operation });
       return void 0;
     }
     if (!response.ok || data2 === void 0) throw new ChatwootError(response.status, operation);
@@ -227,6 +231,30 @@ 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",
+        client.GET("/api/v1/accounts/{account_id}/inboxes/{id}/agent_bot", {
+          params: { path: { account_id: accountId2, id: inboxId } }
+        })
+      );
+      if (value === void 0) return void 0;
+      const parsed = inboxBotSchema.safeParse(value);
+      if (!parsed.success) throw new Error("Chatwoot returned an invalid inbox bot");
+      const bot = parsed.data.agent_bot;
+      if (bot?.id === void 0) return void 0;
+      if (bot.account_id !== accountId2) throw new Error("Chatwoot inbox bot does not belong to the account");
+      return { id: bot.id };
+    },
     async inboxName(accountId2, inboxId) {
       const inbox = await data(
         "get inbox",
@@ -295,12 +323,13 @@ function chatwootClient(baseUrl, token, fetch2) {
         false
       );
     },
-    assign(accountId2, conversationId, assigneeId) {
+    assign(accountId2, conversationId, assigneeId, assigneeType = "User") {
+      const body = { assignee_id: assigneeId, assignee_type: assigneeType };
       return ensureOk(
         "assign conversation",
         client.POST("/api/v1/accounts/{account_id}/conversations/{conversation_id}/assignments", {
           params: { path: { account_id: accountId2, conversation_id: conversationId } },
-          body: { assignee_id: assigneeId }
+          body
         })
       );
     },
@@ -382,9 +411,13 @@ function chatwootClient(baseUrl, token, fetch2) {
 function notFound(response) {
   return response.status === 404 && (response.headers.get("content-type")?.includes("application/json") ?? false);
 }
+function personAssignee(conversation) {
+  const type = conversation.meta?.assignee_type;
+  return type == null || type === "User" ? conversation.meta?.assignee : void 0;
+}
 function toRelayConversation(conversationId, conversation) {
   const meta = conversation.meta;
-  const assignee = meta?.assignee;
+  const assignee = personAssignee(conversation);
   return {
     id: conversationId,
     status: conversation.status,
@@ -399,6 +432,7 @@ function toRelayConversation(conversationId, conversation) {
       avatarUrl: meta?.sender?.thumbnail ?? null
     },
     assignee: assignee ? { id: assignee.id, name: assignee.name } : null,
+    assigneeType: meta?.assignee_type ?? null,
     customAttributes: conversation.custom_attributes ?? {}
   };
 }
@@ -436,6 +470,10 @@ 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) {
@@ -454,14 +492,6 @@ var QueueStore = class {
   delete(key) {
     this.sql.exec("DELETE FROM cache WHERE key = ?", key);
   }
-  list(start, end) {
-    return this.sql.exec(
-      "SELECT value FROM cache WHERE key >= ? AND key < ? AND (expires_at IS NULL OR expires_at > ?) ORDER BY key",
-      start,
-      end,
-      this.now()
-    ).toArray().map((row) => row.value);
-  }
   // Jobs
   /**
    * Adds a job, or marks an existing one as needing another run (its version changes). A job
@@ -470,7 +500,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,
+       ON CONFLICT (key) DO UPDATE SET version = version + 1, payload = excluded.payload, suspended = 0,
          not_before = CASE WHEN attempts > 0 THEN not_before ELSE MIN(not_before, excluded.not_before) END`,
       key,
       priority,
@@ -481,7 +511,7 @@ var QueueStore = class {
   }
   nextDueJob() {
     const row = this.sql.exec(
-      `SELECT key, payload, version, attempts, created_at FROM jobs WHERE not_before <= ?
+      `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];
@@ -491,7 +521,7 @@ var QueueStore = class {
   }
   /** Earliest due time. */
   nextWakeup() {
-    const row = this.sql.exec("SELECT MIN(not_before) AS at FROM jobs").toArray()[0];
+    const row = this.sql.exec("SELECT MIN(not_before) AS at FROM jobs WHERE suspended != 2").toArray()[0];
     return row?.at ?? void 0;
   }
   /** Removes a finished job unless it was enqueued again while running. */
@@ -516,73 +546,136 @@ 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) {
+    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,
+      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());
   }
 };
 
-// ../../shared/sweep.ts
+// src/routing.ts
+import ipRegex from "ip-regex";
+import { z as z4 } from "zod";
+
+// src/turn.ts
 import { z as z3 } from "zod";
-var passSchema = z3.object({ cutoff: z3.number(), page: z3.number().int().positive(), startedAt: z3.number() });
-var PASS_TTL_MS = 24 * 60 * 60 * 1e3;
-function readSweepPass(store, accountId2, reconcile) {
-  const parsed = passSchema.safeParse(parseJson(store.get(`sweep:${accountId2}:pass`)));
-  if (parsed.success) return parsed.data;
-  const now = Date.now();
-  const last = Number(store.get(`sweep:${accountId2}:last`) ?? 0);
-  const { lookbackSeconds, maxCatchUpSeconds } = reconcile;
-  const sinceLast = last > 0 ? (now - last) / 1e3 + 60 : lookbackSeconds;
-  const window = Math.min(Math.max(sinceLast, lookbackSeconds), maxCatchUpSeconds);
-  return { cutoff: now / 1e3 - window, page: 1, startedAt: now };
+var guardSchema = z3.object({
+  boundary: z3.number().optional(),
+  claimed: z3.boolean().optional(),
+  pending: z3.boolean().optional(),
+  transitionAt: z3.number().optional(),
+  expected: z3.object({ status: z3.string(), at: z3.number().optional(), after: z3.number().optional() }).optional(),
+  handoff: z3.boolean().default(false),
+  failures: z3.number().int().min(0).default(0)
+});
+function readGuard(store, accountId2, conversationId) {
+  const parsed = guardSchema.safeParse(parseJson(store.get(`turn:${accountId2}:${conversationId}`)));
+  return parsed.success ? parsed.data : { handoff: false, failures: 0 };
 }
-function saveSweepPass(store, accountId2, pass, nextPage) {
-  const key = `sweep:${accountId2}:pass`;
-  if (nextPage === void 0) {
-    store.set(`sweep:${accountId2}:last`, String(pass.startedAt));
-    store.delete(key);
-  } else {
-    store.set(key, JSON.stringify({ ...pass, page: nextPage }), PASS_TTL_MS);
+function saveGuard(store, accountId2, conversationId, guard) {
+  store.set(`turn:${accountId2}:${conversationId}`, JSON.stringify(guard));
+}
+function expectActivity(store, accountId2, conversationId, transition) {
+  const guard = readGuard(store, accountId2, conversationId);
+  if (transition.at !== void 0 && transition.at <= (guard.transitionAt ?? 0)) return;
+  if (transition.at === void 0 && guard.expected?.status === transition.status) return;
+  const claimed = guard.claimed ?? guard.transitionAt !== void 0;
+  const after = transition.at === void 0 || claimed ? guard.boundary ?? 0 : 0;
+  saveGuard(store, accountId2, conversationId, {
+    ...guard,
+    // A first webhook must not relax a newer activity requirement already observed locally.
+    expected: { ...transition, after: Math.max(guard.expected?.after ?? 0, after) },
+    transitionAt: transition.at ?? guard.transitionAt,
+    handoff: false,
+    failures: 0
+  });
+}
+function observeStatus(store, accountId2, conversationId, status) {
+  const guard = readGuard(store, accountId2, conversationId);
+  const pending = status === "pending";
+  if (guard.pending && !pending) expectActivity(store, accountId2, conversationId, { status });
+  if (guard.pending !== pending) {
+    saveGuard(store, accountId2, conversationId, { ...readGuard(store, accountId2, conversationId), pending });
   }
 }
-
-// src/routing.ts
-import ipRegex from "ip-regex";
-import { z as z5 } from "zod";
-
-// ../../shared/attributes.ts
-var ROUTING_ATTRIBUTES = {
-  seen: "routing_seen",
-  handled: "routing_handled",
-  kind: "routing_kind"
-};
-function messageWatermark(value) {
-  const number = typeof value === "string" ? Number(value) : value;
-  return typeof number === "number" && Number.isSafeInteger(number) && number >= 0 ? number : 0;
+function requestHandoff(store, accountId2, conversationId) {
+  saveGuard(store, accountId2, conversationId, { ...readGuard(store, accountId2, conversationId), handoff: true });
 }
-
-// src/effects.ts
-import { z as z4 } from "zod";
-var effectSchema = z4.object({
-  inputId: z4.number().int().min(0),
-  kind: z4.string().nullable(),
-  handled: z4.number().int().min(0)
-});
-async function actOnce(ctx, key, effect, record, act) {
-  if (ctx.store.get(key) !== void 0) return;
-  if (record === "before") ctx.store.set(key, JSON.stringify({ ...effect, handled: 0 }));
-  await act();
-  ctx.store.set(key, JSON.stringify(effect));
+function recordFailure(store, accountId2, conversationId) {
+  const guard = readGuard(store, accountId2, conversationId);
+  guard.failures += 1;
+  if (guard.failures >= 3) guard.handoff = true;
+  saveGuard(store, accountId2, conversationId, guard);
+  return guard.failures;
 }
-function readEffects(store, accountId2, conversationId) {
-  return [
-    store.get(`reply:${accountId2}:${conversationId}`),
-    ...["assign", "labels", "status"].flatMap(
-      (effect) => store.list(`${effect}:${accountId2}:${conversationId}:`, `${effect}:${accountId2}:${conversationId};`)
-    )
-  ].flatMap((value) => {
-    const parsed = effectSchema.safeParse(parseJson(value));
-    return parsed.success ? [parsed.data] : [];
-  }).sort((left, right) => left.inputId - right.inputId);
+function clearFailures(store, accountId2, conversationId) {
+  const guard = readGuard(store, accountId2, conversationId);
+  if (guard.failures) saveGuard(store, accountId2, conversationId, { ...guard, failures: 0 });
+}
+var ActivityPendingError = class extends Error {
+  constructor() {
+    super("Chatwoot status activity is not available yet");
+    this.name = "ActivityPendingError";
+  }
+};
+async function readTurn(chatwoot, store, accountId2, conversationId) {
+  const messages = [];
+  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 });
+    for (const message of batch.toReversed()) {
+      if (message.message_type === 2 && message.content_attributes?.deleted) {
+        deleted = true;
+        break;
+      }
+      if (message.message_type === 2 && message.content_attributes?.activity?.type === "conversation_status_changed") {
+        boundary = message;
+        break;
+      }
+      messages.push(message);
+    }
+    complete = boundary !== void 0 || batch.length < MESSAGE_HISTORY_PAGE_SIZE;
+    if (complete || deleted) break;
+    const next = batch[0]?.id;
+    if (next === void 0 || before !== void 0 && next >= before) break;
+    before = next;
+  }
+  const guard = readGuard(store, accountId2, conversationId);
+  const missing = guard.boundary !== void 0 && (boundary?.id ?? 0) < guard.boundary;
+  const expected = guard.expected;
+  const activity = boundary?.content_attributes?.activity;
+  const late = expected && (!boundary || boundary.id <= (expected.after ?? 0) || expected.at !== void 0 && (boundary.created_at ?? 0) < Math.floor(expected.at) || activity?.status !== expected.status);
+  if (late && !guard.handoff && !deleted && !missing) throw new ActivityPendingError();
+  if (boundary && boundary.id !== guard.boundary && guard.boundary !== void 0 && !missing && !late) {
+    guard.handoff = false;
+    guard.failures = 0;
+  }
+  if (!missing && complete) {
+    if (guard.boundary !== (boundary?.id ?? 0)) guard.claimed = false;
+    guard.boundary = boundary?.id ?? 0;
+  }
+  if (expected && !late) {
+    guard.claimed = expected.at !== void 0;
+    delete guard.expected;
+  }
+  if (deleted || missing || !complete) guard.handoff = true;
+  saveGuard(store, accountId2, conversationId, guard);
+  return { messages: messages.toReversed(), boundary: boundary?.id ?? 0, handoff: guard.handoff };
 }
 
 // src/routing.ts
@@ -594,7 +687,6 @@ var REQUEST_CRITERIA = {
 };
 var NO_KIND = "none";
 var NO_KIND_CRITERION = "None of the other kinds.";
-var JEV_URL = "https://api.typesafe.ai/v1/systemone";
 var MAX_MESSAGES = 3;
 var MAX_TEXT = 1600;
 var REDACTIONS = [
@@ -619,23 +711,23 @@ var REDACTIONS = [
   /(?<!\w)@[A-Za-z0-9_.-]{2,}/g
   // handles
 ];
-var decisionSchema = z5.object({
-  owner: z5.string().nullable(),
-  ownerConfidence: z5.number(),
-  topic: z5.string().nullable(),
-  topicConfidence: z5.number(),
-  kind: z5.string().nullable().default(null),
-  kindConfidence: z5.number().default(0),
-  /** Jev is confident the customer asked for nothing yet (asked with `snoozeUnclear` only). */
-  noRequest: z5.boolean().default(false)
+var decisionSchema = z4.object({
+  owner: z4.string().nullable(),
+  ownerConfidence: z4.number(),
+  topic: z4.string().nullable(),
+  topicConfidence: z4.number(),
+  kind: z4.string().nullable().default(null),
+  kindConfidence: z4.number().default(0),
+  /** Jev is confident the customer asked for nothing yet. */
+  noRequest: z4.boolean().default(false)
 });
-var jevResponseSchema = z5.object({
-  answers: z5.record(
-    z5.string(),
-    z5.object({
-      choice: z5.string(),
-      probabilities: z5.record(z5.string(), z5.number()).optional(),
-      confidence: z5.number().optional()
+var jevResponseSchema = z4.object({
+  answers: z4.record(
+    z4.string(),
+    z4.object({
+      choice: z4.string(),
+      probabilities: z4.record(z4.string(), z4.number()).optional(),
+      confidence: z4.number().optional()
     })
   )
 });
@@ -652,143 +744,112 @@ async function routeConversation(ctx, accountId2, conversationId) {
   const { settings, store, chatwoot } = ctx;
   const routing = settings.config.routing;
   const owners = routing.accounts[String(accountId2)];
-  if (!owners) return;
+  const token = settings.secrets.CHATWOOT_AGENT_BOT_TOKENS[String(accountId2)];
+  if (!owners || !token) return;
+  const bot = chatwootClient(settings.config.chatwoot.baseUrl, token, ctx.fetch);
   const kinds = routing.kinds?.[String(accountId2)] ?? {};
-  const raw = await chatwoot.getConversation(accountId2, conversationId);
-  if (!raw) return;
-  const conversation = toRelayConversation(conversationId, raw);
-  const latest = await chatwoot.listMessages(accountId2, conversationId, { filter_internal_messages: true });
-  const identities = [conversation.contact?.name, conversation.contact?.email];
-  const inputs = await customerInputs(ctx, accountId2, conversationId, identities);
-  let seen = Math.max(inputs.seen, ...latest.filter(isCustomer).map((message) => message.id));
-  const key = inputs.ids.join(",");
-  const memoKey = `decision:${accountId2}:${conversationId}:${key}`;
-  const cached = inputs.ids.map(
-    (_, index) => readDecision(store.get(`decision:${accountId2}:${conversationId}:${inputs.ids.slice(0, index + 1).join(",")}`))
-  );
-  let decision = cached.at(-1);
-  const previous = cached.findLast((entry) => entry !== void 0);
-  const kindFor = (answer) => answer?.kind && answer.kindConfidence >= routing.minConfidence ? kinds[answer.kind] : void 0;
-  const assigneeFor = (answer) => answer?.owner && answer.ownerConfidence >= routing.minConfidence ? owners[answer.owner]?.assignee : void 0;
-  const eligible = (observed2, answer) => conversationId > (settings.config.startAfterConversationId[String(accountId2)] ?? 0) && !observed2.contact?.blocked && observed2.status === "open" && (!observed2.assignee || observed2.assignee.id === assigneeFor(answer));
-  let observed = raw;
-  if (inputs.ids.length > 0 && eligible(conversation, previous)) {
-    if (!decision) {
-      decision = await decide(ctx, owners, routing.kinds?.[String(accountId2)], inputs.text);
-      store.set(memoKey, JSON.stringify(decision));
-    }
-    const freshInputs = await customerInputs(ctx, accountId2, conversationId, identities);
-    if (freshInputs.ids.join(",") !== key) return "defer";
-    seen = Math.max(seen, freshInputs.seen);
-    const fresh = await chatwoot.getConversation(accountId2, conversationId);
-    if (!fresh) return;
-    observed = fresh;
-    const current = toRelayConversation(conversationId, fresh);
-    if (eligible(current, decision)) {
-      const kind = kindFor(decision);
-      const kindName = kind ? decision.kind : null;
-      const assignee = kind?.status ? void 0 : assigneeFor(decision);
-      const inputId = inputs.ids.at(-1) ?? 0;
-      if (assignee !== void 0) {
-        await actOnce(
-          ctx,
-          `assign:${accountId2}:${conversationId}:${key}`,
-          { inputId, kind: null, handled: 0 },
-          "after",
-          async () => {
-            if (!current.assignee) await chatwoot.assign(accountId2, conversationId, assignee);
-          }
-        );
-      }
-      const topic = !kind?.status && decision.topic !== null && Object.hasOwn(routing.topics ?? {}, decision.topic) && decision.topicConfidence >= routing.minConfidence && current.labels.every((label) => Object.hasOwn(kinds, label)) ? decision.topic : null;
-      const labels = [.../* @__PURE__ */ new Set([...current.labels, ...[topic, kindName].filter((label) => label !== null)])];
-      await actOnce(
-        ctx,
-        `labels:${accountId2}:${conversationId}:${key}`,
-        { inputId, kind: kindName, handled: 0 },
-        "after",
-        async () => {
-          if (labels.length !== current.labels.length) await chatwoot.setLabels(accountId2, conversationId, labels);
-        }
-      );
-      const replyKey = `reply:${accountId2}:${conversationId}`;
-      const botToken = settings.botToken(accountId2);
-      if (kind?.cannedResponse && botToken && store.get(replyKey) === void 0) {
-        const content = await chatwoot.cannedResponse(accountId2, kind.cannedResponse);
-        if (content === void 0) throw new Error("Chatwoot canned response is missing");
-        const bot = chatwootClient(settings.config.chatwoot.baseUrl, botToken, ctx.fetch);
-        await actOnce(
-          ctx,
-          replyKey,
-          { inputId, kind: kindName, handled: inputId },
-          "before",
-          () => bot.createMessage(accountId2, conversationId, { content, private: false, files: [] })
-        );
-      }
-      const snooze = !assignee && inputs.ids.length < MAX_MESSAGES && routing.snoozeUnclear && decision.noRequest;
-      const status = freshInputs.complete ? kind?.status ?? (snooze ? "snoozed" : void 0) : void 0;
-      if (status) {
-        await actOnce(
-          ctx,
-          `status:${accountId2}:${conversationId}:${key}`,
-          { inputId, kind: kindName, handled: kind?.status ? inputId : 0 },
-          "before",
-          () => chatwoot.setStatus(accountId2, conversationId, { status })
-        );
-      }
+  const botId = routing.botIds[String(accountId2)];
+  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");
+      return;
     }
-  }
-  await syncAttributes(ctx, accountId2, conversationId, observed, seen);
-}
-async function syncAttributes(ctx, accountId2, conversationId, observed, seen) {
-  const current = observed.custom_attributes ?? {};
-  const names = ROUTING_ATTRIBUTES;
-  const key = `seen:${accountId2}:${conversationId}`;
-  const checkpoint = Math.max(messageWatermark(ctx.store.get(key)), seen, messageWatermark(current[names.seen]));
-  ctx.store.set(key, String(checkpoint));
-  const effects = readEffects(ctx.store, accountId2, conversationId);
-  const handled = Math.max(0, ...effects.map((effect) => effect.handled));
-  const kind = effects.findLast((effect) => effect.kind !== null)?.kind ?? null;
-  const attributes = {
-    [names.seen]: checkpoint,
-    ...handled > 0 ? { [names.handled]: Math.max(handled, messageWatermark(current[names.handled])) } : {},
-    ...kind === null ? {} : { [names.kind]: kind }
+    const conversation = toRelayConversation(conversationId, raw);
+    if (conversation.contact.blocked || 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;
+    observeStatus(store, accountId2, conversationId, "pending");
+    return { raw, conversation };
   };
-  if (Object.entries(attributes).some(
-    ([name, value]) => (name === names.kind ? current[name] : messageWatermark(current[name])) !== value
-  ))
-    await ctx.chatwoot.setCustomAttributes(accountId2, conversationId, attributes);
-}
-function isCustomer(message) {
-  return message.message_type === 0 && !message.private;
-}
-async function customerInputs(ctx, accountId2, conversationId, identities) {
-  const ids = [];
-  const parts = [];
-  let after = 0;
-  let seen = 0;
-  let complete = false;
-  for (let page = 0; page < 3 && ids.length < MAX_MESSAGES; page += 1) {
-    const messages = await ctx.chatwoot.listMessages(accountId2, conversationId, {
-      after,
-      filter_internal_messages: true
-    });
-    for (const message of messages.filter(isCustomer)) {
-      seen = Math.max(seen, message.id);
+  const initial = await snapshot();
+  if (!initial) return;
+  const identities = [initial.conversation.contact.name, initial.conversation.contact.email];
+  const inputs = (messages) => {
+    const texts = messages.filter(isCustomer).flatMap((message) => {
       const text2 = sanitize(
         [message.content_attributes?.email?.subject ?? "", messageContent(message)].join("\n"),
         identities
       );
-      if (ids.length < MAX_MESSAGES && text2.replaceAll("[REDACTED]", "").trim()) {
-        ids.push(message.id);
-        parts.push(text2);
-      }
-    }
-    complete = ids.length === MAX_MESSAGES || messages.length < MESSAGE_PAGE_SIZE;
-    if (complete) break;
-    after = messages.at(-1)?.id ?? after;
+      return text2.replaceAll("[REDACTED]", "").trim() ? [{ id: message.id, text: text2 }] : [];
+    }).slice(0, MAX_MESSAGES);
+    return {
+      key: texts.map((entry) => entry.id).join(","),
+      text: texts.map((entry) => entry.text).join(" ").slice(0, MAX_TEXT),
+      count: texts.length
+    };
+  };
+  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 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) };
+  };
+  const handoff = async (current2) => {
+    requestHandoff(store, accountId2, conversationId);
+    current2 ??= await fresh();
+    if (current2 === "defer") return "defer";
+    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 (!decision) {
+    decision = await decide(ctx, owners, routing.kinds?.[String(accountId2)], input.text);
+    store.set(memoKey, JSON.stringify(decision));
   }
-  return { ids, text: parts.join(" ").slice(0, MAX_TEXT), complete, seen };
+  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;
+  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;
+  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([
+      ...current.conversation.labels,
+      ...[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();
+    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 });
+  } else if (assignee !== void 0 && current.raw.meta?.assignee_type === "AgentBot") {
+    await bot.assign(accountId2, conversationId, assignee);
+    expectActivity(store, accountId2, conversationId, { status: "open" });
+  } else {
+    return handoff(current);
+  }
+  return void 0;
+}
+function isCustomer(message) {
+  return message.message_type === 0 && !message.private && !message.content_attributes?.deleted && !message.content_attributes?.email?.auto_reply && (message.sender?.type == null || message.sender.type === "contact");
 }
 function sanitize(text2, identities) {
   let value = text2.normalize("NFKC");
@@ -803,7 +864,6 @@ function sanitize(text2, identities) {
 async function decide(ctx, owners, kinds, text2) {
   const routing = ctx.settings.config.routing;
   const apiKey = ctx.settings.secrets.TYPESAFE_API_KEY;
-  if (!routing || !apiKey) throw new JevError("routing is not configured");
   const ownerCriteria = Object.fromEntries(
     Object.entries(owners).map(([route, owner2]) => [route, owner2.covers])
   );
@@ -822,13 +882,11 @@ async function decide(ctx, owners, kinds, text2) {
       criteria: routing.topics
     };
   }
-  if (routing.snoozeUnclear) {
-    questions.request = {
-      type: "choice",
-      instructions: "Select whether the customer asks for anything in this support ticket, using only the ticket.",
-      criteria: REQUEST_CRITERIA
-    };
-  }
+  questions.request = {
+    type: "choice",
+    instructions: "Select whether the customer asks for anything in this support ticket, using only the ticket.",
+    criteria: REQUEST_CRITERIA
+  };
   if (kinds) {
     questions.kind = {
       type: "choice",
@@ -840,7 +898,7 @@ async function decide(ctx, owners, kinds, text2) {
     };
   }
   const response = await ctx.fetch(
-    new Request(JEV_URL, {
+    new Request(routing.endpoint, {
       method: "POST",
       redirect: "manual",
       headers: { authorization: `Bearer ${apiKey}`, "content-type": "application/json" },
@@ -899,83 +957,84 @@ async function readConfig(env) {
 }
 
 // src/config.ts
-import { z as z6 } from "zod";
-var accountId = z6.string().regex(/^[1-9]\d*$/, "must be a Chatwoot account id").refine((value) => Number.isSafeInteger(Number(value)), "must be a safe integer");
-var configSchema = z6.strictObject({
-  chatwoot: z6.strictObject({ baseUrl: z6.url({ protocol: /^https?$/ }) }),
-  reconcile: reconcileSchema,
-  startAfterConversationId: z6.record(accountId, z6.number().int().min(0)).default({}),
-  subrequestBudget: z6.number().int().min(20).max(1e3).default(45),
-  routing: z6.strictObject({
-    model: z6.string().min(1).default("jev-1.13.0"),
+import { z as z5 } from "zod";
+var accountId = z5.string().regex(/^[1-9]\d*$/, "must be a Chatwoot account id").refine((value) => Number.isSafeInteger(Number(value)), "must be a safe integer");
+var configSchema = z5.strictObject({
+  chatwoot: z5.strictObject({ baseUrl: z5.url({ protocol: /^https?$/ }) }),
+  subrequestBudget: z5.number().int().min(45).max(1e3).default(45),
+  routing: z5.strictObject({
+    /** TypeSafe's System One API (/v1/systemone), or another deployment such as a proxy or gateway. */
+    endpoint: z5.url({ protocol: /^https$/ }).default("https://api.typesafe.ai/v1/systemone"),
+    /** Model sent to TypeSafe's System One API; Jev by default. */
+    model: z5.string().min(1).default("jev-1.13.0"),
     /** Jev's probability an answer needs before it is applied. */
-    minConfidence: z6.number().min(0.5).max(1).default(0.7),
-    /**
-     * Snooze a ticket Jev cannot assign yet, and in which the customer asked for nothing yet, until
-     * their next message (see src/routing.ts).
-     */
-    snoozeUnclear: z6.boolean().default(false),
+    minConfidence: z5.number().min(0.5).max(1).default(0.7),
+    /** The account's native Chatwoot agent bot. */
+    botIds: z5.record(accountId, z5.number().int().positive()),
     /** Per Chatwoot account id: the owners Jev chooses from, by a short name. */
-    accounts: z6.record(
+    accounts: z5.record(
       accountId,
-      z6.record(
-        z6.string().regex(/^[a-z0-9_]{1,40}$/, "must be a short lower-case name").refine((name) => name !== "unclear", "unclear is reserved"),
-        z6.strictObject({
+      z5.record(
+        z5.string().regex(/^[a-z0-9_]{1,40}$/, "must be a short lower-case name").refine((name) => name !== "unclear", "unclear is reserved"),
+        z5.strictObject({
           /** Chatwoot user id to assign. */
-          assignee: z6.number().int().positive(),
+          assignee: z5.number().int().positive(),
           /** What the owner handles, as Jev's criterion for choosing them. */
-          covers: z6.string().min(1).max(1e3)
+          covers: z5.string().min(1).max(1e3)
         })
       ).refine((owners) => Object.keys(owners).length > 0, "needs at least one owner")
     ),
     /** Topic labels (Chatwoot label names, lower case) and what each covers. Unset: no topic. */
-    topics: z6.record(
-      z6.string().regex(/^[a-z0-9_-]{1,255}$/, "must be a Chatwoot label name (lower case)"),
-      z6.string().min(1).max(1e3)
+    topics: z5.record(
+      z5.string().regex(/^[a-z0-9_-]{1,255}$/, "must be a Chatwoot label name (lower case)"),
+      z5.string().min(1).max(1e3)
     ).optional(),
     /**
      * Per Chatwoot account id: kinds of ticket Jev recognizes, by a short name, and what is done,
      * once, when it does (see src/routing.ts). Unset: none.
      */
-    kinds: z6.record(
+    kinds: z5.record(
       accountId,
-      z6.record(
-        z6.string().regex(/^[a-z0-9_-]{1,40}$/, "must be a short lower-case name").refine((name) => name !== "none", "none is reserved"),
-        z6.strictObject({
+      z5.record(
+        z5.string().regex(/^[a-z0-9_-]{1,40}$/, "must be a short lower-case name").refine((name) => name !== "none", "none is reserved"),
+        z5.strictObject({
           /** What the kind is, as Jev's criterion for recognizing it. */
-          covers: z6.string().min(1).max(1e3),
+          covers: z5.string().min(1).max(1e3),
           /**
            * Short code of the account's Chatwoot canned response sent to the customer once, as
-           * the account's agent bot (CHATWOOT_BOT_TOKENS). None is sent while it does not exist.
+           * the account's agent bot (CHATWOOT_AGENT_BOT_TOKENS). Missing responses hand off to people.
            */
-          cannedResponse: z6.string().trim().min(1).max(255).optional(),
+          cannedResponse: z5.string().trim().min(1).max(255).optional(),
           /**
            * Set instead of routing the ticket (after the reply, with cannedResponse): `resolved`,
            * or `snoozed` until the customer's next message. A new message from the customer
            * reopens either.
            */
-          status: z6.enum(["resolved", "snoozed"]).optional()
+          status: z5.enum(["resolved", "snoozed"]).optional()
         })
       )
     ).optional()
   })
-}).refine((config) => Object.keys(config.startAfterConversationId).every((id3) => config.routing.accounts[id3]), {
-  path: ["startAfterConversationId"],
-  message: "must only name routed accounts"
-}).refine((config) => Object.keys(config.routing?.kinds ?? {}).every((id3) => config.routing?.accounts[id3]), {
+}).refine(
+  (config) => {
+    const accounts = Object.keys(config.routing.accounts);
+    return accounts.length > 0 && accounts.length === Object.keys(config.routing.botIds).length && accounts.every((id3) => config.routing.botIds[id3] !== void 0);
+  },
+  { path: ["routing", "botIds"], message: "must name exactly the routed accounts" }
+).refine((config) => Object.keys(config.routing.kinds ?? {}).every((id3) => config.routing.accounts[id3]), {
   path: ["routing", "kinds"],
   message: "must only name routed accounts"
 }).refine(
-  (config) => Object.values(config.routing?.kinds ?? {}).every(
-    (kinds) => Object.keys(kinds).every((kind) => !Object.hasOwn(config.routing?.topics ?? {}, kind))
+  (config) => Object.values(config.routing.kinds ?? {}).every(
+    (kinds) => Object.keys(kinds).every((kind) => !Object.hasOwn(config.routing.topics ?? {}, kind))
   ),
   { path: ["routing", "kinds"], message: "a kind cannot be named as a topic: they are labels of two families" }
 );
-var secretsSchema = z6.object({
-  CHATWOOT_TOKEN: z6.string().min(1),
-  CHATWOOT_WEBHOOK_SECRETS: jsonRecord,
-  TYPESAFE_API_KEY: z6.string().min(1),
-  CHATWOOT_BOT_TOKENS: jsonRecord.default({})
+var secretsSchema = z5.object({
+  CHATWOOT_TOKEN: z5.string().min(1),
+  CHATWOOT_AGENT_BOT_SECRETS: jsonRecord,
+  TYPESAFE_API_KEY: z5.string().min(1),
+  CHATWOOT_AGENT_BOT_TOKENS: jsonRecord
 });
 function parseSettings(rawConfig, rawSecrets) {
   const config = configSchema.safeParse(rawConfig);
@@ -985,17 +1044,13 @@ function parseSettings(rawConfig, rawSecrets) {
   return buildSettings(config.data, secrets.data);
 }
 function buildSettings(config, secrets) {
-  for (const accountId2 of Object.keys(config.routing.accounts)) {
-    if (!secrets.CHATWOOT_WEBHOOK_SECRETS[accountId2]) {
-      throw new ConfigError(`Invalid secrets: CHATWOOT_WEBHOOK_SECRETS: account ${accountId2} needs a webhook secret`);
-    }
-  }
-  for (const [accountId2, kinds] of Object.entries(config.routing.kinds ?? {})) {
-    if (Object.values(kinds).some((kind) => kind.cannedResponse) && !secrets.CHATWOOT_BOT_TOKENS[accountId2]) {
-      throw new ConfigError(`Invalid secrets: CHATWOOT_BOT_TOKENS: account ${accountId2} has kinds that reply`);
+  const accounts = Object.keys(config.routing.accounts);
+  for (const name of ["CHATWOOT_AGENT_BOT_SECRETS", "CHATWOOT_AGENT_BOT_TOKENS"]) {
+    if (Object.keys(secrets[name]).length !== accounts.length || accounts.some((id3) => !secrets[name][id3]?.trim())) {
+      throw new ConfigError(`Invalid secrets: ${name}: needs exactly the routed accounts`);
     }
   }
-  return { config, secrets, botToken: (accountId2) => secrets.CHATWOOT_BOT_TOKENS[String(accountId2)] };
+  return { config, secrets };
 }
 
 // src/settings.ts
@@ -1003,24 +1058,39 @@ var loadSettings = settingsLoader(parseSettings);
 
 // src/router.ts
 var ROUTER_NAME = "global";
-var ROUTE_BUDGET = 15;
-var BUDGET = { route: ROUTE_BUDGET, sweep: 1 };
+var ROUTE_BUDGET = 45;
+var BUDGET = { route: ROUTE_BUDGET, sweep: 2 };
 var RUN_WALL_MS = 5 * 60 * 1e3;
-var id = z7.number().int().positive();
-var jobSchema = z7.discriminatedUnion("type", [
-  z7.object({ type: z7.literal("route"), accountId: id, conversationId: id }),
-  z7.object({ type: z7.literal("sweep"), accountId: id })
+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 })
 ]);
+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());
+    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");
+      }
+    });
   }
-  async enqueueConversation(accountId2, conversationId) {
+  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();
   }
@@ -1057,6 +1127,7 @@ var Router = class extends DurableObject {
             yielded = true;
             break;
           }
+          clearFailures(this.store, payload.accountId, payload.conversationId);
         } else if (routesAccount(settings, payload.accountId)) {
           await this.sweep(settings, chatwoot, payload.accountId);
         }
@@ -1072,11 +1143,12 @@ var Router = class extends DurableObject {
           yielded = true;
           break;
         }
-        const delay = retryDelay(job.attempts);
-        const logAt = job.attempts + 1 >= 3 ? log.error : log.warn;
+        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", {
           job: job.key,
-          attempts: job.attempts + 1,
+          attempts,
           delayMs: delay,
           ...errorFields(error)
         });
@@ -1086,24 +1158,30 @@ var Router = class extends DurableObject {
     await this.schedule(yielded ? Date.now() : void 0);
   }
   async sweep(settings, chatwoot, accountId2) {
-    const pass = readSweepPass(this.store, accountId2, settings.config.reconcile);
-    const conversations = await chatwoot.listConversations(accountId2, pass.page);
-    let finished = conversations.length === 0;
-    for (const conversation of conversations) {
-      if ((conversation.last_activity_at ?? 0) < pass.cutoff) {
-        finished = true;
-        break;
+    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);
       }
-      const conversationId = conversation.id;
-      if (conversationId === void 0) continue;
-      this.enqueue({ type: "route", accountId: accountId2, conversationId });
-    }
-    if (finished) {
-      saveSweepPass(this.store, accountId2, pass);
+      pass.remaining.shift();
     } else {
-      saveSweepPass(this.store, accountId2, pass, pass.page + 1);
-      this.enqueue({ type: "sweep", accountId: accountId2 });
+      const conversations = await chatwoot.listConversations(accountId2, pass.page, "pending");
+      for (const conversation of conversations) {
+        if (conversation.id !== void 0 && conversation.inbox_id !== void 0 && pass.routed.includes(conversation.inbox_id)) {
+          this.enqueue({ type: "route", accountId: accountId2, conversationId: conversation.id });
+        }
+      }
+      if (conversations.length === 0) {
+        this.store.delete(key);
+        return;
+      }
+      pass.page += 1;
     }
+    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}`;
@@ -1118,24 +1196,36 @@ var Router = class extends DurableObject {
 };
 
 // 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(),
-  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_created", "conversation_updated", "conversation_status_changed"]);
+var CONVERSATION_EVENTS = /* @__PURE__ */ new Set([
+  "conversation_opened",
+  "conversation_resolved",
+  "conversation_updated",
+  "conversation_status_changed"
+]);
 function eventTarget(payload) {
   const parsed = eventSchema.safeParse(payload);
   if (!parsed.success) return void 0;
   const event = parsed.data;
   if (CONVERSATION_EVENTS.has(event.event) && event.id !== void 0) {
-    return { accountId: event.account.id, conversationId: event.id };
+    const change = event.changed_attributes?.find((entry) => entry.status)?.status;
+    return {
+      accountId: event.account.id,
+      conversationId: event.id,
+      ...change && (change.previous_value === "pending" || change.current_value === "resolved" || change.current_value === "pending" && change.previous_value !== "resolved") && event.updated_at !== void 0 ? { transition: { status: change.current_value, at: event.updated_at } } : {}
+    };
   }
   if (event.event === "message_created" && (event.message_type === "incoming" || event.message_type === 0) && !event.private && event.sender?.type === "contact" && event.id !== void 0 && event.conversation) {
     return { accountId: event.account.id, conversationId: event.conversation.id };
@@ -1154,7 +1244,7 @@ app.get("/healthz", async (context) => {
     return context.json({ ok: false }, 503);
   }
 });
-app.post("/chatwoot/webhook", bodyLimit({ maxSize: 2 * 1024 * 1024 }), async (context) => {
+app.post("/chatwoot/agent-bot", bodyLimit({ maxSize: 2 * 1024 * 1024 }), async (context) => {
   const settings = await loadSettings(context.env);
   const timestamp = context.req.header("x-chatwoot-timestamp");
   if (!timestamp || !isFreshTimestamp(timestamp, Math.floor(Date.now() / 1e3))) {
@@ -1163,7 +1253,7 @@ app.post("/chatwoot/webhook", bodyLimit({ maxSize: 2 * 1024 * 1024 }), async (co
   const body = new Uint8Array(await context.req.arrayBuffer());
   const signature = context.req.header("x-chatwoot-signature");
   let signedBy;
-  for (const [accountId2, secret] of Object.entries(settings.secrets.CHATWOOT_WEBHOOK_SECRETS)) {
+  for (const [accountId2, secret] of Object.entries(settings.secrets.CHATWOOT_AGENT_BOT_SECRETS)) {
     if (await verifyChatwootSignature(secret, timestamp, body, signature)) {
       signedBy = Number(accountId2);
       break;
@@ -1181,7 +1271,11 @@ app.post("/chatwoot/webhook", bodyLimit({ maxSize: 2 * 1024 * 1024 }), async (co
   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);
+  await context.env.ROUTER.getByName(ROUTER_NAME).enqueueConversation(
+    target.accountId,
+    target.conversationId,
+    target.transition
+  );
   return context.json({ ok: true });
 });
 app.notFound((context) => context.text("not found", 404));