manychat-ai-agent 0.25.0 → 0.26.0

package/CHANGELOG.md

@@ -1,5 +1,32 @@
 # Changelog
 
+## [0.26.0](https://github.com/pedronastasi/manychat-ai-agent/compare/v0.25.0...v0.26.0) (2026-10-17)
+
+
+### Features
+
+* wait for a burst to end before calling the model ([729bfca](https://github.com/pedronastasi/manychat-ai-agent/commit/729bfca32c20ea1d44d6eef2438ab852ec1b9bfb))
+* wait for a burst to end before calling the model ([2cd1d91](https://github.com/pedronastasi/manychat-ai-agent/commit/2cd1d915b046b0972b0ca303e34bc3286ac08ebd))
+
+
+### Bug Fixes
+
+* **deps:** update patch dependencies ([#239](https://github.com/pedronastasi/manychat-ai-agent/issues/239)) ([371bfaf](https://github.com/pedronastasi/manychat-ai-agent/commit/371bfaf4dbb525f23f73f4dfbc3691afd393ccf8))
+
+
+### Specs and Docs
+
+* record PR 244 in spec 047 ([52fd1bd](https://github.com/pedronastasi/manychat-ai-agent/commit/52fd1bda1af595c7094a05aaa97c82213e84c585))
+* specify a burst window before the model (spec 047) ([3351037](https://github.com/pedronastasi/manychat-ai-agent/commit/3351037174ab519bb7a9387c9a878db72e7747d9))
+
+
+### Dependencies
+
+* **deps:** lock file maintenance ([5c22bf0](https://github.com/pedronastasi/manychat-ai-agent/commit/5c22bf0622de025e5ade1155b9f9dd1ebcbac90c))
+* **deps:** lock file maintenance ([ca4b49b](https://github.com/pedronastasi/manychat-ai-agent/commit/ca4b49b3deee81c3951b4aa9ae80d24d73676ad2))
+* **deps:** update pnpm to v12.14.0 ([6599f97](https://github.com/pedronastasi/manychat-ai-agent/commit/6599f97b7e27f4b41d1dced8e90c8a188db66c42))
+* **deps:** update pnpm to v12.14.0 ([c68b87e](https://github.com/pedronastasi/manychat-ai-agent/commit/c68b87ee8e72786f201b372f037304cb387fa42b))
+
 ## [0.25.0](https://github.com/pedronastasi/manychat-ai-agent/compare/v0.24.1...v0.25.0) (2026-10-16)
 
 

package/dist/contracts/config.d.ts

@@ -85,6 +85,8 @@ export declare const LearningSchema: z.ZodObject<{
     maxRunCostUsd: z.ZodNumber;
 }, z.core.$strict>;
 export type Learning = z.infer<typeof LearningSchema>;
+/** The longest `burstWindowMs`: it leaves the model most of the race (specs/047). */
+export declare const BURST_WINDOW_MAX_MS = 4000;
 export declare const RulesSchema: z.ZodObject<{
     messages: z.ZodObject<{
         acknowledgement: z.ZodString;
@@ -109,6 +111,7 @@ export declare const RulesSchema: z.ZodObject<{
         turnsPerSubscriberPerHour: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strip>;
     foldBursts: z.ZodDefault<z.ZodBoolean>;
+    burstWindowMs: z.ZodDefault<z.ZodNumber>;
     learning: z.ZodOptional<z.ZodObject<{
         language: z.ZodString;
         convertedTag: z.ZodString;

package/dist/contracts/config.js

@@ -133,6 +133,8 @@ export const LearningSchema = z
     maxRunCostUsd: z.number().positive(),
 })
     .strict();
+/** The longest `burstWindowMs`: it leaves the model most of the race (specs/047). */
+export const BURST_WINDOW_MAX_MS = 4_000;
 export const RulesSchema = z.object({
     messages: MessagesSchema,
     confidenceThreshold: z.number().min(0).max(1).default(0.6),
@@ -172,6 +174,13 @@ export const RulesSchema = z.object({
      * Bubbles that wait behind a running turn are folded whatever this says.
      */
     foldBursts: z.boolean().default(false),
+    /**
+     * How long a turn waits for the contact to write again before it calls the
+     * model (specs/047). A bubble that arrives in that time folds this turn's
+     * message into its own. The wait counts against the race deadline (C7), so
+     * it is capped well inside it. 0, the default, waits for nothing.
+     */
+    burstWindowMs: z.number().int().min(0).max(BURST_WINDOW_MAX_MS).default(0),
     /**
      * Learning from outcomes (specs/031). Absent, no learning job runs, no
      * playbook is loaded, and the prompt is what it was before that spec.

package/dist/conversation/turns.d.ts

@@ -18,6 +18,11 @@ export interface TurnSlot {
      * yet: the contact kept writing, and that turn answers them (specs/046).
      */
     followed: () => boolean;
+    /**
+     * Settles with `true` as soon as this turn is followed, or with `false` once
+     * `ms` have passed without it: the contact has gone quiet (specs/047).
+     */
+    quiet: (ms: number) => Promise<boolean>;
 }
 /**
  * One turn at a time per contact, in the order their requests arrived

package/dist/conversation/turns.js

@@ -28,6 +28,11 @@ export class TurnLanes {
         const places = this.places.get(contact) ?? [];
         places.push(place);
         this.places.set(contact, places);
+        const followed = () => {
+            const current = this.places.get(contact) ?? [];
+            const index = current.indexOf(place);
+            return index >= 0 && current.slice(index + 1).some(later => later.claimed);
+        };
         const gone = () => {
             const current = this.places.get(contact);
             if (!current)
@@ -47,12 +52,24 @@ export class TurnLanes {
             },
             claim: () => {
                 place.claimed = true;
-            },
-            followed: () => {
                 const current = this.places.get(contact) ?? [];
-                const index = current.indexOf(place);
-                return index >= 0 && current.slice(index + 1).some(later => later.claimed);
+                for (const earlier of current.slice(0, current.indexOf(place)))
+                    earlier.wake?.();
             },
+            followed,
+            quiet: ms => new Promise(resolve => {
+                if (followed())
+                    return resolve(true);
+                const timer = setTimeout(() => {
+                    place.wake = undefined;
+                    resolve(false);
+                }, ms);
+                place.wake = () => {
+                    clearTimeout(timer);
+                    place.wake = undefined;
+                    resolve(true);
+                };
+            }),
         };
     }
     bounded(before) {

package/dist/routes/turn.js

@@ -150,58 +150,67 @@ export class TurnHandler {
         };
         const leave = () => void background.then(slot.leave, slot.leave);
         const expired = () => logger.error({ conversation: known?.id }, 'turn wait expired');
-        if (slot.waited) {
-            let timer;
-            const late = new Promise(resolve => {
-                timer = setTimeout(() => resolve('late'), Math.max(0, deadlineAt - Date.now()));
-            });
-            const waited = await Promise.race([slot.ready, late]);
-            clearTimeout(timer);
-            if (waited === 'late') {
-                void slot.ready
-                    .then(async (ready) => {
-                    if (ready === 'expired')
-                        expired();
-                    if (readsHistory && slot.followed() && this.foldable(inbound)) {
-                        await this.fold(inbound, binding);
-                    }
-                    else
-                        await this.run(inbound, { ...opts, late: true });
-                })
-                    .catch(async (error) => {
-                    logger.error({ conversation: known?.id, err: String(error) }, 'waiting turn failed');
-                    await this.handOffSilent(inbound);
-                })
-                    .finally(leave);
-                // The previous turn has started the conversation by now; its reply,
-                // or its holding line, is the contact's answer for the moment.
-                const current = known ?? (await this.store.find(inbound.tenantId, inbound.subscriberId));
-                logger.info({ conversation: current?.id }, 'turn waits for the previous one');
-                return {
-                    reply: {
-                        messages: [],
-                        escalate: false,
-                        escalation_reason: null,
-                        confidence: 1,
-                        closing_question: null,
-                    },
-                    outcome: 'deferred',
-                    conversationId: current?.id ?? '',
-                    binding,
-                    silent: true,
-                };
-            }
-            if (waited === 'expired')
+        /**
+         * Whether this turn only records its message, which a later turn of the
+         * contact answers (specs/046): the contact wrote again while it waited for
+         * their previous turn, or, with a burst window, before that window passed
+         * in silence (specs/047). Only a turn that reads history folds: any other
+         * runs, and is bound by the token state it finds then (specs/019).
+         */
+        const folds = async () => {
+            if (!readsHistory || !this.foldable(inbound))
+                return false;
+            if (slot.waited && slot.followed())
+                return true;
+            const windowMs = this.deps.rules.burstWindowMs;
+            return windowMs > 0 && (await slot.quiet(windowMs));
+        };
+        // The wait for the previous turn and the burst window both count against
+        // the deadline (C7): a turn still deciding at it is answered silently now.
+        const decided = (async () => {
+            if (slot.waited && (await slot.ready) === 'expired')
                 expired();
+            return (await folds()) ? 'fold' : 'run';
+        })();
+        let timer;
+        const late = new Promise(resolve => {
+            timer = setTimeout(() => resolve('late'), Math.max(0, deadlineAt - Date.now()));
+        });
+        const first = await Promise.race([decided, late]).finally(() => clearTimeout(timer));
+        if (first === 'late') {
+            void decided
+                .then(async (decision) => {
+                if (decision === 'fold')
+                    await this.fold(inbound, binding);
+                else
+                    await this.run(inbound, { ...opts, late: true });
+            })
+                .catch(async (error) => {
+                logger.error({ conversation: known?.id, err: String(error) }, 'waiting turn failed');
+                await this.handOffSilent(inbound);
+            })
+                .finally(leave);
+            // The previous turn has started the conversation by now; its reply,
+            // or its holding line, is the contact's answer for the moment.
+            const current = known ?? (await this.store.find(inbound.tenantId, inbound.subscriberId));
+            logger.info({ conversation: current?.id }, 'turn answered silently while it waits');
+            return {
+                reply: {
+                    messages: [],
+                    escalate: false,
+                    escalation_reason: null,
+                    confidence: 1,
+                    closing_question: null,
+                },
+                outcome: 'deferred',
+                conversationId: current?.id ?? '',
+                binding,
+                silent: true,
+            };
         }
         try {
-            // The contact wrote again while this message waited: the later turn
-            // answers both, so this one only records it (specs/046). Only a turn
-            // that reads history folds: any other runs, and is bound by the token
-            // state it finds then (specs/019).
-            if (readsHistory && slot.waited && slot.followed() && this.foldable(inbound)) {
+            if (first === 'fold')
                 return await this.fold(inbound, binding);
-            }
             return await this.run(inbound, opts);
         }
         finally {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "manychat-ai-agent",
-  "version": "0.25.0",
+  "version": "0.26.0",
   "description": "A provider-agnostic conversational AI agent gateway that bridges no-code chat platforms to any LLM.",
   "license": "MIT",
   "repository": {
@@ -36,7 +36,7 @@
   "engines": {
     "node": ">=22"
   },
-  "packageManager": "pnpm@12.11.2",
+  "packageManager": "pnpm@12.14.0",
   "scripts": {
     "dev": "node --experimental-strip-types --disable-warning=ExperimentalWarning --env-file=.env --watch src/main.ts",
     "bootstrap": "node scripts/setup.mjs",
@@ -71,7 +71,7 @@
     "@ai-sdk/anthropic": "^4.0.53",
     "@ai-sdk/google": "^4.0.69",
     "@ai-sdk/openai": "^4.0.66",
-    "@ai-sdk/provider": "4.0.28",
+    "@ai-sdk/provider": "4.0.29",
     "@fastify/helmet": "^13.1.1",
     "@fastify/rate-limit": "^11.2.0",
     "@fastify/swagger": "^9.8.1",