manychat-ai-agent 0.24.1 → 0.26.0

package/CHANGELOG.md

@@ -1,5 +1,50 @@
 # 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)
+
+
+### Features
+
+* a silent payment-link flow leaves the link to the reply ([b4d019e](https://github.com/pedronastasi/manychat-ai-agent/commit/b4d019e275fc0073acc82f1361eec0e59a68c163))
+* a silent payment-link flow leaves the link to the reply ([11d3929](https://github.com/pedronastasi/manychat-ai-agent/commit/11d3929ae3c4e734d42fab62022dab33ac214e3b))
+
+
+### Bug Fixes
+
+* an offering's link does not count as one it is a prefix of ([426ade9](https://github.com/pedronastasi/manychat-ai-agent/commit/426ade9850e3e72354697c9961218558ad8b6d05))
+
+
+### Specs and Docs
+
+* **specs:** a silent payment flow leaves the link to the reply ([4611b15](https://github.com/pedronastasi/manychat-ai-agent/commit/4611b15744f4a81bd3cf6943a2a1f39644d2bb7f))
+
 ## [0.24.1](https://github.com/pedronastasi/manychat-ai-agent/compare/v0.24.0...v0.24.1) (2026-10-16)
 
 

package/dist/agent/guardrails.d.ts

@@ -54,8 +54,14 @@ export declare function escalationReply(reason: EscalationReason, message: strin
  *
  * `earlierReplies` is the text of the agent's earlier turns in the
  * conversation, which the repetition check compares against (specs/013).
+ *
+ * `paymentLink` is the link the reply must carry because the turn sent a
+ * silent payment-link flow (specs/023 § A silent payment flow leaves the link
+ * to the reply).
  */
-export declare function applyGuardrails(raw: unknown, rules: Rules, earlierReplies?: readonly string[]): GuardedReply;
+export declare function applyGuardrails(raw: unknown, rules: Rules, earlierReplies?: readonly string[], options?: {
+    paymentLink?: string | undefined;
+}): GuardedReply;
 /**
  * Flags prices that do not appear in the catalog.
  *

package/dist/agent/guardrails.js

@@ -110,8 +110,12 @@ export function escalationReply(reason, message) {
  *
  * `earlierReplies` is the text of the agent's earlier turns in the
  * conversation, which the repetition check compares against (specs/013).
+ *
+ * `paymentLink` is the link the reply must carry because the turn sent a
+ * silent payment-link flow (specs/023 § A silent payment flow leaves the link
+ * to the reply).
  */
-export function applyGuardrails(raw, rules, earlierReplies = []) {
+export function applyGuardrails(raw, rules, earlierReplies = [], options = {}) {
     const interventions = [];
     const parsed = AgentReply.safeParse(raw);
     if (!parsed.success) {
@@ -200,12 +204,14 @@ export function applyGuardrails(raw, rules, earlierReplies = []) {
     // matters is that exactly one question ends the turn, not which.
     const bodyMessages = reply.messages;
     const body = bodyMessages.at(-1);
+    let questionAppended = false;
     if (reply.closing_question !== null && !reply.escalate) {
         if (body !== undefined && endsWithQuestion(body)) {
             interventions.push('closing_question_already_in_body');
         }
         else {
             reply = { ...reply, messages: [...reply.messages, reply.closing_question] };
+            questionAppended = true;
         }
     }
     // Verbatim repetition, most often an earlier answer replayed in reply to a
@@ -231,10 +237,59 @@ export function applyGuardrails(raw, rules, earlierReplies = []) {
             // is nothing to ask and nothing to hand off.
             interventions.push('duplicate_replaced');
             reply = { ...reply, messages: [closer], closing_question: null };
+            questionAppended = false;
         }
     }
+    // A silent payment-link flow sent nothing, so a reply without the link
+    // leaves the contact recorded at link_sent with no way to pay (specs/023
+    // § A silent payment flow leaves the link to the reply). Checked last, on
+    // what would be delivered. The link goes on its own line at the end of the
+    // body, so the turn still ends on its one question. Skipped on an
+    // escalation: the person taking over sends it.
+    const link = options.paymentLink;
+    if (link !== undefined && !reply.escalate && !carriesLink(reply.messages, link)) {
+        interventions.push('payment_link_added');
+        reply = { ...reply, messages: withLink(reply.messages, link, questionAppended) };
+    }
     return { reply, interventions, ...(escalatedBy ? { escalatedBy } : {}) };
 }
+/**
+ * The messages with the link on its own line after the body's last one, or as
+ * a message of its own ahead of a question the body ends on or that would not
+ * fit beside it.
+ */
+function withLink(messages, link, questionAppended) {
+    const last = messages.length - 1;
+    const asked = questionAppended || endsWithQuestion(messages[last] ?? '');
+    const at = asked ? last - 1 : last;
+    const target = messages[at];
+    if (target === undefined || target.length + link.length + 1 > MAX_MESSAGE_CHARS) {
+        return messages.toSpliced(at + 1, 0, link);
+    }
+    return messages.with(at, `${target}\n${link}`);
+}
+/**
+ * Whether any message carries the link, as the catalog writes it or with its
+ * percent-encoding undone, which is how a model often copies a URL with an
+ * accented path. A trailing slash is optional.
+ *
+ * The link must end where the URL in the message ends: another offering's
+ * link that starts with this one (`…/foundation-plus` for `…/foundation`) is
+ * not this link, and counting it would leave the contact with the wrong one.
+ */
+function carriesLink(messages, link) {
+    const bare = (url) => url.replace(/\/+$/, '');
+    let decoded = link;
+    try {
+        decoded = decodeURI(link);
+    }
+    catch {
+        // A malformed escape: only the link as written can match.
+    }
+    const patterns = [...new Set([bare(link), bare(decoded)])].map(form => new RegExp(`${escapeRegExp(form)}/?(?![\\p{L}\\p{N}_%/-])`, 'u'));
+    return messages.some(message => patterns.some(pattern => pattern.test(message)));
+}
+const escapeRegExp = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 /** Numbers with a currency cue nearby, e.g. "$45.000", "45000 pesos". */
 const PRICE_PATTERN = /(?:\$\s?)([\d][\d.,]{2,})|([\d][\d.,]{2,})\s?(?:pesos|ars|usd)/gi;
 /** Digits only, so "45.000", "45,000" and "45000" compare equal. */

package/dist/agent/prompt.d.ts

@@ -99,6 +99,12 @@ opening?: {
 reads?: readonly {
     tool: string;
     result: ReadResult;
+}[], 
+/** The tenant's flows, for which of them send the contact nothing (specs/023). */
+flows?: readonly {
+    id: string;
+    role?: string | undefined;
+    silent?: boolean | undefined;
 }[]): string;
 /**
  * The server's note on an earlier turn of what it performed, or null when it

package/dist/agent/prompt.js

@@ -409,7 +409,16 @@ function salesSection(tools) {
                     'moves forward: a write to an earlier stage is refused.',
                     ...(link
                         ? [
-                            `The payment link is the flow ${link.id}. It is refused before prepared, unless the contact`,
+                            ...(link.silent
+                                ? [
+                                    `The payment link is recorded by the flow ${link.id}, which is silent: it sends the`,
+                                    'contact nothing. Every time you send it, write the link of the contact’s offering from',
+                                    'the CATALOG in the same reply: the flow does not deliver it. It is refused before',
+                                    'prepared, unless the contact',
+                                ]
+                                : [
+                                    `The payment link is the flow ${link.id}. It is refused before prepared, unless the contact`,
+                                ]),
                             'asks for it: a contact whose message asks for the link, the payment methods or how to pay',
                             'gets it, qualified or not, and you pass contactAsked true. Never pass it otherwise.',
                         ]
@@ -528,15 +537,35 @@ contact,
 /** The opening the turn's prospect write queued, if it did (specs/034). */
 opening, 
 /** Each plugin read tool's last successful read, its text still fenced (specs/039). */
-reads = []) {
+reads = [], 
+/** The tenant's flows, for which of them send the contact nothing (specs/023). */
+flows = []) {
     // Flows only: a stage write sent ahead of a payment link is not news to the contact.
     const sent = (stage.sent ?? []).filter(entry => entry.action.tool === 'send_flow');
-    const went = sent.filter(entry => entry.records[0]?.status === 'performed');
+    const flowOf = (entry) => flows.find(flow => flow.id === entry.action.id);
+    const performed = sent.filter(entry => entry.records[0]?.status === 'performed');
+    const went = performed.filter(entry => !flowOf(entry)?.silent);
+    // A silent flow is not something the contact received, and a reply that
+    // treats it as one leaves out what it stands for (specs/023 § A silent
+    // payment flow leaves the link to the reply).
+    const recorded = performed.filter(entry => flowOf(entry)?.silent);
+    const silentLink = (action) => {
+        const flow = flows.find(entry => entry.id === action.id);
+        return action.tool === 'send_flow' && flow?.silent === true && flow.role === 'payment_link';
+    };
+    const link = recorded.some(entry => silentLink(entry.action));
+    const stagedLink = stage.staged.some(silentLink);
     const failed = sent.filter(entry => entry.records[0]?.status !== 'performed');
     const lines = [
         went.length > 0
             ? `SENT: Already sent to the contact, who receives it before your reply: ${went.map(entry => describeAction(entry.action)).join(', ')}. Your reply follows it; do not repeat what it contains.`
             : null,
+        recorded.length > 0
+            ? `RECORDED: ${recorded.map(entry => describeAction(entry.action)).join(', ')}. Silent: the contact received nothing from it. Write your reply in full, as if it had not been sent.` +
+                (link
+                    ? ' The payment link is yours to write: put the link of the contact’s offering from the CATALOG in this reply.'
+                    : '')
+            : null,
         failed.length > 0
             ? `NOT SENT: ManyChat refused: ${failed.map(entry => describeAction(entry.action)).join(', ')}. Do not say it was sent.`
             : null,
@@ -545,6 +574,9 @@ reads = []) {
             : sent.length > 0
                 ? null
                 : 'ACTIONS: None of your tool calls were staged.',
+        stagedLink
+            ? 'The payment link flow is silent and sends the contact nothing: put the link of the contact’s offering from the CATALOG in this reply.'
+            : null,
         stage.dropped.length > 0
             ? `Not staged, over the limit of ${MAX_ACTIONS_PER_TURN} per turn: ${stage.dropped.map(describeAction).join(', ')}.`
             : null,

package/dist/agent/runner.js

@@ -4,7 +4,7 @@ import { NO_TOOLS, offersTools } from "../contracts/config.js";
 import { actionsNote, buildSystemPrompt, offeringNotice, fenceUserText, funnelNotice, mediaNotice, intentNotice, nudgeNotice, stagedNotice, } from "./prompt.js";
 import { applyGuardrails, escalationReply } from "./guardrails.js";
 import { estimateCostUsd, supportsTemperature } from "./registry.js";
-import { ActionStage, buildTools, offeringField, funnelField, intentField, MAX_STEPS, openingFlow, stagesProspect, } from "./tools.js";
+import { ActionStage, buildTools, offeringField, funnelField, intentField, MAX_STEPS, openingFlow, silentPaymentLink, stagesProspect, } from "./tools.js";
 import { renderPlaybook } from "../learning/playbook.js";
 /**
  * An earlier turn as the model reads it. An agent turn is followed by the
@@ -171,7 +171,7 @@ export class GenerateTextRunner {
                             ...messages,
                             {
                                 role: 'user',
-                                content: stagedNotice(stage, reads?.latest, opening && stagesProspect(stage, tenantTools) ? opening : undefined, pluginReads?.latest),
+                                content: stagedNotice(stage, reads?.latest, opening && stagesProspect(stage, tenantTools) ? opening : undefined, pluginReads?.latest, tenantTools.flows),
                             },
                         ],
                     }
@@ -242,7 +242,21 @@ export class GenerateTextRunner {
             };
         }
         const earlierReplies = history.filter(turn => turn.role === 'agent').map(turn => turn.text);
-        const guarded = applyGuardrails(output, config.rules, earlierReplies);
+        const paymentLink = silentPaymentLink(tenantTools, config.catalog, stage, contact);
+        let guarded = applyGuardrails(output, config.rules, earlierReplies, {
+            paymentLink: paymentLink ?? undefined,
+        });
+        // Sent, with no link to put in the reply: the loader's checks leave only a
+        // contact with no offering recorded. A reply without the link would leave
+        // them at link_sent with no way to pay, so a person finishes the turn
+        // (specs/023 § A silent payment flow leaves the link to the reply, C6).
+        if (paymentLink === null && !guarded.reply.escalate) {
+            guarded = {
+                reply: escalationReply('low_confidence', config.rules.messages.escalation),
+                interventions: [...guarded.interventions, 'payment_link_unknown'],
+                escalatedBy: 'error',
+            };
+        }
         return {
             reply: guarded.reply,
             interventions: guarded.interventions,

package/dist/agent/tools.d.ts

@@ -1,5 +1,5 @@
 import { type ToolSet } from 'ai';
-import type { Tools, INTENT_VALUES } from '../contracts/config.ts';
+import type { Catalog, Tools, INTENT_VALUES } from '../contracts/config.ts';
 import type { ActionRecord, ActionStatus, PerformableAction, StagedAction } from '../contracts/agent.ts';
 import type { ContactReads } from './contact.ts';
 import type { FlowSends, SendFlowAction } from './flows.ts';
@@ -122,7 +122,22 @@ export declare function paymentLinkFlow(config: Tools): {
     onStage?: "qualifying" | "nurturing" | "offered" | "prepared" | undefined;
     offering?: string | undefined;
     settleSeconds?: number | undefined;
+    silent?: boolean | undefined;
 } | undefined;
+/**
+ * The link a reply must carry because the turn sent a silent payment-link
+ * flow, which leaves the link to the reply (specs/023 § A silent payment flow
+ * leaves the link to the reply). `undefined` when the turn neither sent such
+ * a flow nor staged it to be sent after the reply.
+ *
+ * The link is the catalog `url` of the turn's offering: one written this turn,
+ * else the contact's, else the catalog's only offering. `null` when the flow
+ * went out and no offering or link is known, which the loader's checks leave
+ * to a contact with no offering recorded yet.
+ */
+export declare function silentPaymentLink(config: Tools, catalog: Catalog, stage: ActionStage, contact: {
+    offering?: string | undefined;
+} | undefined): string | null | undefined;
 /** The flow the server sends on a contact's prospect turn, if the tenant marked one (specs/034). */
 export declare function openingFlow(config: Tools): {
     id: string;
@@ -133,6 +148,7 @@ export declare function openingFlow(config: Tools): {
     onStage?: "qualifying" | "nurturing" | "offered" | "prepared" | undefined;
     offering?: string | undefined;
     settleSeconds?: number | undefined;
+    silent?: boolean | undefined;
 } | undefined;
 /** The field the contact's offering is kept in, if the tenant marked one (specs/028). */
 export declare function offeringField(config: Tools): {

package/dist/agent/tools.js

@@ -192,6 +192,33 @@ export function funnelField(config) {
 export function paymentLinkFlow(config) {
     return config.flows.find(flow => flow.role === 'payment_link');
 }
+/**
+ * The link a reply must carry because the turn sent a silent payment-link
+ * flow, which leaves the link to the reply (specs/023 § A silent payment flow
+ * leaves the link to the reply). `undefined` when the turn neither sent such
+ * a flow nor staged it to be sent after the reply.
+ *
+ * The link is the catalog `url` of the turn's offering: one written this turn,
+ * else the contact's, else the catalog's only offering. `null` when the flow
+ * went out and no offering or link is known, which the loader's checks leave
+ * to a contact with no offering recorded yet.
+ */
+export function silentPaymentLink(config, catalog, stage, contact) {
+    const link = paymentLinkFlow(config);
+    if (!link?.silent)
+        return undefined;
+    const sent = stage.sent.some(entry => entry.action.tool === 'send_flow' &&
+        entry.action.id === link.id &&
+        entry.records[0]?.status === 'performed');
+    const staged = stage.staged.some(action => action.tool === 'send_flow' && action.id === link.id);
+    if (!sent && !staged)
+        return undefined;
+    const written = stage.staged.findLast((action) => action.tool === 'set_field' && action.offering === true);
+    const id = written?.value ??
+        contact?.offering ??
+        (catalog.offerings.length === 1 ? catalog.offerings[0].id : undefined);
+    return catalog.offerings.find(offering => offering.id === id)?.url ?? null;
+}
 /** The flow the server sends on a contact's prospect turn, if the tenant marked one (specs/034). */
 export function openingFlow(config) {
     return config.flows.find(flow => flow.role === 'opening');
@@ -299,12 +326,18 @@ const catalogOf = (entries) => entries
     const notes = [
         entry.offering === undefined ? null : `offering ${entry.offering}`,
         entry.onStage === undefined ? null : `sent by the system when you record ${entry.onStage}`,
+        entry.silent ? 'silent: sends the contact nothing' : null,
     ].filter(Boolean);
     return `- ${entry.id}${notes.length > 0 ? ` (${notes.join('; ')})` : ''}: ${entry.description}`;
 })
     .join('\n');
 const STAGED = 'The action is staged, not performed: it happens after your reply is sent, and not at all if the turn escalates.';
 const SENT_NOW = 'The flow is sent when you call this, before your reply: the contact receives it first and your reply follows it. Do not repeat what it contains. The result says whether it went out.';
+const SILENT = 'A silent flow sends the contact nothing: write your reply in full, as if it had not been sent.';
+/** The note a silent flow's result carries; the payment link's names the link. */
+const silentResult = (role) => role === 'payment_link'
+    ? 'The contact received nothing from this flow. Your reply must carry the link of the contact’s offering from the CATALOG.'
+    : 'The contact received nothing from this flow. Write your reply in full, as if it had not been sent.';
 const CONTACT_ASKED = 'The payment link is refused before the stage is prepared. Pass contactAsked: true only when the contact’s message this turn asks for the link, the payment methods or how to pay; it is recorded.';
 const STAGED_NOTE = 'The note is staged, not written: it is written after your reply is sent. It replaces what the note held, so read it first with get_contact to add to it.';
 /**
@@ -419,6 +452,7 @@ options = {}) {
         const gated = funnel !== undefined && unsent.some(flow => flow.role === 'payment_link');
         tools.send_flow = tool({
             description: `Send the contact one of these flows.\n${listing}\n${sends ? SENT_NOW : STAGED}` +
+                (unsent.some(flow => flow.silent) ? `\n${SILENT}` : '') +
                 (gated ? `\n${CONTACT_ASKED}` : ''),
             inputSchema: gated
                 ? z.object({ flow: z.enum(idsOf(unsent)), contactAsked: z.boolean().optional() })
@@ -466,8 +500,14 @@ options = {}) {
                     ...(followOn ? { followOn } : {}),
                     ...(asked ? { contactAsked: true } : {}),
                 };
-                if (!sends)
-                    return { staged: stage.stage(action) };
+                // What a silent flow leaves to the reply, said where the model reads
+                // the outcome (specs/023 § A silent payment flow leaves the link to
+                // the reply).
+                const silent = entry.silent ? { silent: silentResult(entry.role) } : {};
+                if (!sends) {
+                    const staged = stage.stage(action);
+                    return staged ? { staged, ...silent } : { staged };
+                }
                 // The opening goes first on the prospect turn (specs/034). A payment
                 // link is counted at link_sent before the await, so a funnel or offering
                 // write made beside it is refused rather than landing after it (specs/029).
@@ -490,7 +530,9 @@ options = {}) {
                     ? stage.staged.filter(staged => staged.tool === 'set_field' && staged.id === funnel.id)
                     : [];
                 const sent = await stage.send(action, sends, first);
-                return sent === undefined ? { sent: false, reason: 'over the per-turn limit' } : { sent };
+                if (sent === undefined)
+                    return { sent: false, reason: 'over the per-turn limit' };
+                return sent ? { sent, ...silent } : { sent };
             },
         });
     }

package/dist/config/loader.js

@@ -84,6 +84,22 @@ function offeringMismatches(tools, catalog) {
             : tools.flows
                 .filter(flow => flow.offering !== undefined)
                 .map(flow => `flow '${flow.id}' has an offering, but no field is marked "offering"`)),
+        // A silent payment flow leaves the link to the reply, and the server puts
+        // the contact's offering's link there when the reply leaves it out, so
+        // that link must exist and the offering must be knowable (specs/023
+        // § A silent payment flow leaves the link to the reply).
+        ...tools.flows
+            .filter(flow => flow.role === 'payment_link' && flow.silent)
+            .flatMap(flow => [
+            ...catalog.offerings
+                .filter(offering => offering.url === null)
+                .map(offering => `flow '${flow.id}' is a silent payment link, so offering '${offering.id}' needs a url`),
+            ...(field || ids.length === 1
+                ? []
+                : [
+                    `flow '${flow.id}' is a silent payment link, so with several offerings a field must be marked "offering"`,
+                ]),
+        ]),
     ];
 }
 const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);

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;
@@ -186,6 +189,7 @@ export declare const ToolsSchema: z.ZodObject<{
         }> & z.ZodType<"qualifying" | "nurturing" | "offered" | "prepared", "new" | "qualifying" | "nurturing" | "offered" | "prepared" | "link_sent", z.core.$ZodTypeInternals<"qualifying" | "nurturing" | "offered" | "prepared", "new" | "qualifying" | "nurturing" | "offered" | "prepared" | "link_sent">>>;
         offering: z.ZodOptional<z.ZodString>;
         settleSeconds: z.ZodOptional<z.ZodNumber>;
+        silent: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>>;
     tags: z.ZodDefault<z.ZodArray<z.ZodObject<{
         id: 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.
@@ -315,8 +324,9 @@ export const ToolsSchema = z
         repeatable: z.boolean().optional(),
         /**
          * `payment_link`: performing it writes the funnel field to `link_sent`
-         * (specs/023). `opening`: the server sends it on the contact's first
-         * model turn, and the model never does (specs/032).
+         * (specs/023); with `silent`, the reply carries the link. `opening`:
+         * the server sends it on the contact's first model turn, and the
+         * model never does (specs/032).
          */
         role: z.enum(['payment_link', 'opening']).optional(),
         /**
@@ -338,9 +348,20 @@ export const ToolsSchema = z
          * (specs/030). Absent, it does not wait.
          */
         settleSeconds: z.number().int().min(0).max(MAX_SETTLE_SECONDS).optional(),
+        /**
+         * The flow sends the contact no message: it only records something
+         * in ManyChat, such as a tracking event. On the payment-link flow it
+         * means the reply carries the link (specs/023 § A silent payment
+         * flow leaves the link to the reply).
+         */
+        silent: z.boolean().optional(),
     }))
         .default([])
         .refine(uniqueIds, 'flow ids must be unique')
+        // Nothing plays, so there is nothing for the reply to wait for (specs/030).
+        .refine(flows => !flows.some(flow => flow.silent && flow.settleSeconds !== undefined), 'a "silent" flow may not have "settleSeconds"')
+        // The opening is the contact's first message from the tenant (specs/032).
+        .refine(flows => !flows.some(flow => flow.silent && flow.role === 'opening'), 'the "opening" flow may not be "silent"')
         .refine(flows => flows.filter(flow => flow.role === 'payment_link').length <= 1, 'only one flow may have role "payment_link"')
         // One payment flow serves every offering and branches on the offering
         // field inside ManyChat (specs/028 § One payment flow serves every offering).

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.24.1",
+  "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",