manychat-ai-agent 0.22.0 → 0.23.1

package/CHANGELOG.md

@@ -1,5 +1,33 @@
 # Changelog
 
+## [0.23.1](https://github.com/pedronastasi/manychat-ai-agent/compare/v0.23.0...v0.23.1) (2026-10-13)
+
+
+### Bug Fixes
+
+* continue an offering already selected in conversation ([e9d8353](https://github.com/pedronastasi/manychat-ai-agent/commit/e9d8353ce2c1dc134810f9632c09447a46970faf))
+* continue an offering already selected in conversation ([d9b6aa4](https://github.com/pedronastasi/manychat-ai-agent/commit/d9b6aa4e5f9812538efcdda44e624bede5ef180f))
+* **deps:** update patch dependencies ([#208](https://github.com/pedronastasi/manychat-ai-agent/issues/208)) ([d9ba610](https://github.com/pedronastasi/manychat-ai-agent/commit/d9ba6101326ba47f231a58de295e488c4189fc9a))
+
+
+### Specs and Docs
+
+* specify complete conversation evals ([d8a0a48](https://github.com/pedronastasi/manychat-ai-agent/commit/d8a0a48fe3a8971424dc53ed83ce7de29204bc09))
+* specify complete conversation evals ([81c4f83](https://github.com/pedronastasi/manychat-ai-agent/commit/81c4f83d6ea728ee85d41d19b8e07e3ac3a105f7))
+
+## [0.23.0](https://github.com/pedronastasi/manychat-ai-agent/compare/v0.22.0...v0.23.0) (2026-10-08)
+
+
+### Features
+
+* mount plugin channels beside ManyChat's route (spec 038) ([366c646](https://github.com/pedronastasi/manychat-ai-agent/commit/366c646a7223d959603b0f6f5159725d368bf33c))
+* mount plugin channels beside ManyChat's route (spec 038) ([e53d5ed](https://github.com/pedronastasi/manychat-ai-agent/commit/e53d5ed9ea667246d4788faa087226049350ab96))
+
+
+### Specs and Docs
+
+* record PR 206 in spec 038 ([f61a13e](https://github.com/pedronastasi/manychat-ai-agent/commit/f61a13ea2448920db388d842da52bfb7a655a698))
+
 ## [0.22.0](https://github.com/pedronastasi/manychat-ai-agent/compare/v0.21.0...v0.22.0) (2026-10-08)
 
 

package/dist/agent/prompt.js

@@ -307,8 +307,13 @@ function offeringsSection(tools) {
         `The field ${offering.id} records the offering this contact is buying, one of: ${offering.values.join(', ')}.`,
         'Record it with set_field as soon as the contact chooses an offering or the fit is clear.',
         'A flow listed with an offering is accepted only once that is the contact’s offering;',
-        'setting the offering earlier in the same turn is enough. With no offering recorded, ask',
-        'which one before sending its content: one question, not a list of every offering.',
+        'setting the offering earlier in the same turn is enough. An absent recorded offering',
+        'does not mean the contact has not chosen. Check the current message and conversation',
+        'history, including an offering name or catalog page they supplied and your earlier',
+        'acknowledgment of that choice. If one offering is already clear, record it and continue',
+        'without asking them to choose or confirm it again. A short answer to a qualification',
+        'question does not reset that choice. Ask which offering only when it is still unknown,',
+        'before sending offering-specific content: one question, not a list of every offering.',
         ...(funnelField(tools)
             ? [
                 'The offering may change until the stage is offered. From offered on it is locked: a',
@@ -348,8 +353,9 @@ export function intentNotice(intent, advertOffering) {
  * travels with the turn's message like the funnel note, outside the fence.
  */
 export function offeringNotice(offering, changedFrom) {
-    if (offering === undefined)
-        return 'OFFERING: No offering is recorded for this contact yet.';
+    if (offering === undefined) {
+        return 'OFFERING: No offering is recorded for this contact yet. This is missing saved state, not proof of an unknown choice. If the message or history already identifies an offering, record it and continue without asking again.';
+    }
     if (changedFrom !== undefined) {
         return `OFFERING: This contact's offering changed from ${changedFrom} to ${offering} since you last saw it. Confirm which offering they want before continuing.`;
     }

package/dist/agent/runner.d.ts

@@ -109,6 +109,12 @@ export interface AgentTurnInput {
     nudge?: {
         since: Date;
     } | undefined;
+    /**
+     * False on a plugin channel's turn: `tools.json`'s tools write to ManyChat,
+     * so neither they nor their prompt lines are offered there. Plugin tools
+     * still are (specs/038).
+     */
+    builtInTools?: boolean | undefined;
 }
 /**
  * The port every caller depends on. Implemented with `generateText`: a single
@@ -150,7 +156,8 @@ export interface RunnerOptions {
 }
 export declare class GenerateTextRunner implements AgentRunner {
     private readonly opts;
-    private cached;
+    /** One per kind of turn: with `tools.json`'s tools, and without them (specs/038). */
+    private readonly cached;
     constructor(opts: RunnerOptions);
     /**
      * Rebuilds only when ConfigStore swaps in a new object, so the prefix stays
@@ -159,5 +166,5 @@ export declare class GenerateTextRunner implements AgentRunner {
      * An activated playbook version rebuilds it once, not on every turn.
      */
     private current;
-    run({ text, history, signal, media, stage, contact, reads, pluginReads, flows, beforeFlow, nudge, }: AgentTurnInput): Promise<AgentResult>;
+    run({ text, history, signal, media, stage, contact, reads, pluginReads, flows, beforeFlow, nudge, builtInTools, }: AgentTurnInput): Promise<AgentResult>;
 }

package/dist/agent/runner.js

@@ -79,7 +79,8 @@ function nudgeMessage(since, contactNotices) {
 }
 export class GenerateTextRunner {
     opts;
-    cached;
+    /** One per kind of turn: with `tools.json`'s tools, and without them (specs/038). */
+    cached = new Map();
     constructor(opts) {
         this.opts = opts;
     }
@@ -89,43 +90,46 @@ export class GenerateTextRunner {
      * failed reload keeps the previous object, so it correctly rebuilds nothing.
      * An activated playbook version rebuilds it once, not on every turn.
      */
-    current() {
+    current(builtInTools) {
         const config = this.opts.config();
         const playbook = this.opts.playbook?.current();
-        if (this.cached?.config !== config || this.cached.loadedPlaybook !== playbook?.id) {
-            const tools = config.tools ?? NO_TOOLS;
-            // The staged-tool lines follow write tools only: a read is not staged
-            // (specs/039 § The prompt changes only when a plugin adds a read tool).
-            const pluginTools = this.opts.plugins?.hasWriteTools ?? false;
-            const pluginReadTools = this.opts.plugins?.hasReadTools ?? false;
-            const withTools = offersTools(tools) || pluginTools || pluginReadTools;
-            const prompt = buildSystemPrompt(config.persona, config.catalog, config.rules, tools, {
-                pluginTools,
-                pluginReadTools,
-            });
-            // After the catalog and before the cache breakpoint, so a version is
-            // cached with the rest of the prefix (specs/031). Without `learning`
-            // the prefix is what it was before that spec.
-            const rendered = config.rules.learning ? renderPlaybook(playbook) : undefined;
-            this.cached = {
-                config,
-                loadedPlaybook: playbook?.id,
-                playbook: rendered ? playbook : undefined,
-                withTools,
-                staticPrefix: prompt.staticPrefix,
-                catalogBlock: rendered ? `${prompt.catalogBlock}\n\n${rendered}` : prompt.catalogBlock,
-            };
-        }
-        return this.cached;
+        const cached = this.cached.get(builtInTools);
+        if (cached?.config === config && cached.loadedPlaybook === playbook?.id)
+            return cached;
+        const tools = builtInTools ? (config.tools ?? NO_TOOLS) : NO_TOOLS;
+        // The staged-tool lines follow write tools only: a read is not staged
+        // (specs/039 § The prompt changes only when a plugin adds a read tool).
+        const pluginTools = this.opts.plugins?.hasWriteTools ?? false;
+        const pluginReadTools = this.opts.plugins?.hasReadTools ?? false;
+        const withTools = offersTools(tools) || pluginTools || pluginReadTools;
+        const prompt = buildSystemPrompt(config.persona, config.catalog, config.rules, tools, {
+            pluginTools,
+            pluginReadTools,
+        });
+        // After the catalog and before the cache breakpoint, so a version is
+        // cached with the rest of the prefix (specs/031). Without `learning`
+        // the prefix is what it was before that spec.
+        const rendered = config.rules.learning ? renderPlaybook(playbook) : undefined;
+        const built = {
+            config,
+            loadedPlaybook: playbook?.id,
+            playbook: rendered ? playbook : undefined,
+            withTools,
+            tools,
+            staticPrefix: prompt.staticPrefix,
+            catalogBlock: rendered ? `${prompt.catalogBlock}\n\n${rendered}` : prompt.catalogBlock,
+        };
+        this.cached.set(builtInTools, built);
+        return built;
     }
-    async run({ text, history, signal, media, stage = new ActionStage(), contact, reads, pluginReads, flows, beforeFlow, nudge, }) {
+    async run({ text, history, signal, media, stage = new ActionStage(), contact, reads, pluginReads, flows, beforeFlow, nudge, builtInTools = true, }) {
         const started = Date.now();
         // Resolved once per turn: a reload landing mid-turn must not produce a
         // reply built from one config and guarded by another.
-        const { config, playbook, staticPrefix, catalogBlock, withTools } = this.current();
+        const { config, playbook, staticPrefix, catalogBlock, withTools, tools: tenantTools, } = this.current(builtInTools);
         const playbookVersion = playbook?.id ?? null;
         const tools = withTools
-            ? buildTools(config.tools ?? NO_TOOLS, stage, contact, reads, {
+            ? buildTools(tenantTools, stage, contact, reads, {
                 nudgeTurn: nudge !== undefined,
                 flows,
                 beforeFlow,
@@ -135,13 +139,11 @@ export class GenerateTextRunner {
             : undefined;
         // The opening is no longer known before the loop runs: the prospect write
         // that queues it says so, and the reply step is told below (specs/034).
-        const opening = contact?.openingDue ? openingFlow(config.tools ?? NO_TOOLS) : undefined;
+        const opening = contact?.openingDue ? openingFlow(tenantTools) : undefined;
         const contactNotices = [
-            ...(intentField(config.tools ?? NO_TOOLS)
-                ? [intentNotice(contact?.intent, contact?.advertOffering)]
-                : []),
-            ...(funnelField(config.tools ?? NO_TOOLS) ? [funnelNotice(contact?.funnelStage)] : []),
-            ...(offeringField(config.tools ?? NO_TOOLS)
+            ...(intentField(tenantTools) ? [intentNotice(contact?.intent, contact?.advertOffering)] : []),
+            ...(funnelField(tenantTools) ? [funnelNotice(contact?.funnelStage)] : []),
+            ...(offeringField(tenantTools)
                 ? [offeringNotice(contact?.offering, contact?.offeringChangedFrom)]
                 : []),
         ];
@@ -167,9 +169,7 @@ export class GenerateTextRunner {
                             ...messages,
                             {
                                 role: 'user',
-                                content: stagedNotice(stage, reads?.latest, opening && stagesProspect(stage, config.tools ?? NO_TOOLS)
-                                    ? opening
-                                    : undefined, pluginReads?.latest),
+                                content: stagedNotice(stage, reads?.latest, opening && stagesProspect(stage, tenantTools) ? opening : undefined, pluginReads?.latest),
                             },
                         ],
                     }

package/dist/channels/plugin/adapter.d.ts

@@ -0,0 +1,47 @@
+import { type AgentReply, type InboundMessage } from '../../contracts/agent.ts';
+import type { ChannelReply, PluginChannel } from '../../plugins/api.ts';
+import { type HostLogger, type Plugins } from '../../plugins/plugins.ts';
+import type { ChannelAdapter, ParseContext } from '../port.ts';
+/**
+ * How long the outbox waits for a channel's `push`. Past it the signal aborts
+ * and the delivery is retried, as a ManyChat send that timed out is. The same
+ * bound as a plugin's `perform` (specs/036); chosen, not measured.
+ */
+export declare const CHANNEL_PUSH_TIMEOUT_MS = 10000;
+/** A request that fails the channel's own schema: refused with a 400 before any turn (specs/038). */
+export declare class ChannelInputError extends Error {
+    constructor(channel: string);
+}
+/** The route a channel is mounted at, beside ManyChat's (specs/038). */
+export declare const channelRoute: (name: string) => string;
+/**
+ * A plugin's channel behind the `ChannelAdapter` port (specs/038, ADR-0005).
+ * The plugin translates; everything it does not translate is decided here,
+ * the same way for every plugin channel: the tenant, the channel, and that
+ * the request carries no contact token and no offering.
+ *
+ * The contact's ID is prefixed with the channel's name, so a contact on one
+ * channel never shares a conversation, an order or an outbox lane with one on
+ * another whose platform happens to use the same ID.
+ */
+export declare class PluginChannelAdapter implements ChannelAdapter<unknown, unknown> {
+    readonly name: string;
+    readonly plugin: string;
+    readonly route: string;
+    private readonly channel;
+    private readonly logger;
+    private readonly prefix;
+    constructor(plugin: string, channel: PluginChannel, logger: HostLogger);
+    /** Whether the request passes the channel's schema; checked before anything reads it (C3). */
+    accepts(raw: unknown): boolean;
+    parse(raw: unknown, ctx: ParseContext): InboundMessage;
+    render(reply: AgentReply): unknown;
+    /** Delivers a lost race's reply (specs/038 § Outbound delivery is the adapter's `push`). */
+    push(to: {
+        subscriberId: string;
+    }, reply: AgentReply): Promise<void>;
+    /** What `push` sends, from what the outbox keeps of a reply. */
+    deliver(to: string, reply: ChannelReply): Promise<void>;
+}
+/** An adapter for each channel the plugins add, by name, logging through `logger`. */
+export declare function channelAdapters(plugins: Plugins, logger: HostLogger): ReadonlyMap<string, PluginChannelAdapter>;

package/dist/channels/plugin/adapter.js

@@ -0,0 +1,108 @@
+import { ChannelMessage } from "../../contracts/agent.js";
+import { pluginLogger } from "../../plugins/plugins.js";
+/**
+ * How long the outbox waits for a channel's `push`. Past it the signal aborts
+ * and the delivery is retried, as a ManyChat send that timed out is. The same
+ * bound as a plugin's `perform` (specs/036); chosen, not measured.
+ */
+export const CHANNEL_PUSH_TIMEOUT_MS = 10_000;
+/** A request that fails the channel's own schema: refused with a 400 before any turn (specs/038). */
+export class ChannelInputError extends Error {
+    constructor(channel) {
+        super(`request does not match channel ${channel}'s schema`);
+        this.name = 'ChannelInputError';
+    }
+}
+/** The route a channel is mounted at, beside ManyChat's (specs/038). */
+export const channelRoute = (name) => `/v1/channels/${name}/message`;
+/**
+ * A plugin's channel behind the `ChannelAdapter` port (specs/038, ADR-0005).
+ * The plugin translates; everything it does not translate is decided here,
+ * the same way for every plugin channel: the tenant, the channel, and that
+ * the request carries no contact token and no offering.
+ *
+ * The contact's ID is prefixed with the channel's name, so a contact on one
+ * channel never shares a conversation, an order or an outbox lane with one on
+ * another whose platform happens to use the same ID.
+ */
+export class PluginChannelAdapter {
+    name;
+    plugin;
+    route;
+    channel;
+    logger;
+    prefix;
+    constructor(plugin, channel, logger) {
+        this.plugin = plugin;
+        this.channel = channel;
+        this.logger = logger;
+        this.name = channel.name;
+        this.route = channelRoute(channel.name);
+        this.prefix = `${channel.name}:`;
+    }
+    /** Whether the request passes the channel's schema; checked before anything reads it (C3). */
+    accepts(raw) {
+        return this.channel.inbound.safeParse(raw).success;
+    }
+    parse(raw, ctx) {
+        const checked = this.channel.inbound.safeParse(raw);
+        if (!checked.success)
+            throw new ChannelInputError(this.name);
+        // What the plugin returns is an external boundary too (C3).
+        const message = ChannelMessage.parse(this.channel.parse(checked.data));
+        return {
+            tenantId: ctx.tenantId,
+            subscriberId: `${this.prefix}${message.subscriberId}`,
+            text: message.text,
+            channel: this.name,
+            contactName: message.contactName ?? null,
+            locale: message.locale ?? null,
+            // The channel's own auth binds its contacts: there is no token to
+            // present, and none is issued (specs/038 § A plugin channel carries no
+            // contact token).
+            contactToken: null,
+            offering: null,
+            receivedAt: new Date(),
+        };
+    }
+    render(reply) {
+        return this.channel.render({ messages: reply.messages, escalate: reply.escalate });
+    }
+    /** Delivers a lost race's reply (specs/038 § Outbound delivery is the adapter's `push`). */
+    async push(to, reply) {
+        await this.deliver(to.subscriberId, { messages: reply.messages, escalate: reply.escalate });
+    }
+    /** What `push` sends, from what the outbox keeps of a reply. */
+    async deliver(to, reply) {
+        const subscriberId = to.startsWith(this.prefix) ? to.slice(this.prefix.length) : to;
+        const controller = new AbortController();
+        let timer;
+        const timedOut = new Promise((_resolve, reject) => {
+            timer = setTimeout(() => {
+                controller.abort();
+                reject(new Error(`channel ${this.name} push timed out after ${CHANNEL_PUSH_TIMEOUT_MS} ms`));
+            }, CHANNEL_PUSH_TIMEOUT_MS);
+        });
+        try {
+            await Promise.race([
+                Promise.resolve().then(() => this.channel.push({
+                    subscriberId,
+                    reply,
+                    logger: pluginLogger(this.logger, this.plugin, subscriberId),
+                    signal: controller.signal,
+                })),
+                timedOut,
+            ]);
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+}
+/** An adapter for each channel the plugins add, by name, logging through `logger`. */
+export function channelAdapters(plugins, logger) {
+    return new Map(plugins.channels.map(({ plugin, channel }) => [
+        channel.name,
+        new PluginChannelAdapter(plugin, channel, logger),
+    ]));
+}

package/dist/cli/run.js

@@ -112,11 +112,13 @@ export async function run(argv) {
                 }
                 throw error;
             }
-            // Each plugin's read tools beside its write tools (specs/039).
+            // Each plugin's read tools beside its write tools (specs/039), and its channels.
             const tools = (names) => (names.length > 0 ? names.join(', ') : 'none');
             const loaded = summary.length > 0
                 ? `; plugins: ${summary
-                    .map(entry => `${entry.plugin} (writes: ${tools(entry.writes)}; reads: ${tools(entry.reads)})`)
+                    .map(entry => `${entry.plugin} (writes: ${tools(entry.writes)}; reads: ${tools(entry.reads)}` +
+                    // Only a plugin that adds one says so (specs/038).
+                    (entry.channels.length > 0 ? `; channels: ${entry.channels.join(', ')})` : ')'))
                     .join(', ')}`
                 : '';
             console.log(`config check passed (${configDir}${loaded})`);

package/dist/contracts/agent.d.ts

@@ -114,6 +114,17 @@ export declare const InboundMessage: z.ZodObject<{
     receivedAt: z.ZodDate;
 }, z.core.$strip>;
 export type InboundMessage = z.infer<typeof InboundMessage>;
+/**
+ * What a plugin channel's `parse` returns, checked before the turn reads it
+ * (specs/038, C3). The bounds are ManyChat's inbound ones.
+ */
+export declare const ChannelMessage: z.ZodObject<{
+    subscriberId: z.ZodString;
+    text: z.ZodString;
+    contactName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    locale: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strict>;
+export type ChannelMessage = z.infer<typeof ChannelMessage>;
 /** Why a turn ended the way it did — recorded per turn for observability. */
 export declare const TurnOutcome: z.ZodEnum<{
     error: "error";

package/dist/contracts/agent.js

@@ -116,6 +116,18 @@ export const InboundMessage = z.object({
     offering: z.string().nullish(),
     receivedAt: z.date(),
 });
+/**
+ * What a plugin channel's `parse` returns, checked before the turn reads it
+ * (specs/038, C3). The bounds are ManyChat's inbound ones.
+ */
+export const ChannelMessage = z
+    .object({
+    subscriberId: z.string().min(1).max(256),
+    text: z.string().max(4096),
+    contactName: z.string().max(256).nullish(),
+    locale: z.string().max(64).nullish(),
+})
+    .strict();
 /** Why a turn ended the way it did — recorded per turn for observability. */
 export const TurnOutcome = z.enum([
     'answered_inline', // model won the race

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 /**
  * The bare `manychat-ai-agent` entry point: the plugin API (specs/036, with
- * read tools from specs/039). The agent itself is run through its CLI or
+ * read tools from specs/039 and provisional channels from specs/038). The agent itself is run through its CLI or
  * image, never imported.
  */
-export { definePlugin, defineReadTool, defineTool, PLUGIN_API_VERSION, SUPPORTED_PLUGIN_API_VERSIONS, } from './plugins/api.ts';
-export type { ParamsOf, Plugin, PluginCall, PluginLogger, PluginParameter, PluginParameters, PluginReadTool, PluginTool, ReadParameter, ReadParameters, ResultField, ResultFields, ResultOf, } from './plugins/api.ts';
+export { CHANNEL_API_VERSION, defineChannel, definePlugin, defineReadTool, defineTool, PLUGIN_API_VERSION, SUPPORTED_CHANNEL_API_VERSIONS, SUPPORTED_PLUGIN_API_VERSIONS, } from './plugins/api.ts';
+export type { ChannelMessage, ChannelPush, ChannelReply, InboundSchema, ParamsOf, Plugin, PluginCall, PluginChannel, PluginLogger, PluginParameter, PluginParameters, PluginReadTool, PluginTool, ReadParameter, ReadParameters, ResultField, ResultFields, ResultOf, } from './plugins/api.ts';

package/dist/index.js

@@ -1,6 +1,6 @@
 /**
  * The bare `manychat-ai-agent` entry point: the plugin API (specs/036, with
- * read tools from specs/039). The agent itself is run through its CLI or
+ * read tools from specs/039 and provisional channels from specs/038). The agent itself is run through its CLI or
  * image, never imported.
  */
-export { definePlugin, defineReadTool, defineTool, PLUGIN_API_VERSION, SUPPORTED_PLUGIN_API_VERSIONS, } from "./plugins/api.js";
+export { CHANNEL_API_VERSION, defineChannel, definePlugin, defineReadTool, defineTool, PLUGIN_API_VERSION, SUPPORTED_CHANNEL_API_VERSIONS, SUPPORTED_PLUGIN_API_VERSIONS, } from "./plugins/api.js";

package/dist/outbox/queue.d.ts

@@ -15,6 +15,10 @@ export interface ReplyPayload {
     messages: string[];
     actions?: StagedAction[];
     turnId?: string;
+    /** The plugin channel that delivers it, through its adapter's `push`; ManyChat when absent (specs/038). */
+    channel?: string;
+    /** Set on a handoff queued for a plugin channel, which is told so (specs/038). */
+    escalate?: true;
 }
 /**
  * A deferred reply, or the retry of a contact token's write (specs/019). The
@@ -45,6 +49,8 @@ export declare class OutboxQueue {
         } | undefined;
         /** Held until then: a flow sent this turn is still playing (specs/030). */
         notBefore?: Date | undefined;
+        /** A plugin channel's name; ManyChat when absent (specs/038). */
+        channel?: string | undefined;
     }): Promise<string>;
     /**
      * Whether a reply to the contact is still queued: pending, or being

package/dist/outbox/queue.js

@@ -8,6 +8,11 @@ export class OutboxQueue {
     }
     async enqueue(input) {
         const payload = { messages: input.reply.messages };
+        if (input.channel !== undefined) {
+            payload.channel = input.channel;
+            if (input.reply.escalate)
+                payload.escalate = true;
+        }
         if (input.actions && input.actions.staged.length > 0) {
             payload.actions = [...input.actions.staged];
             payload.turnId = input.actions.turnId;

package/dist/outbox/worker.d.ts

@@ -1,6 +1,13 @@
 import type { Database } from '../db/client.ts';
 import type { ManyChatClient } from '../channels/manychat/client.ts';
 import type { Plugins } from '../plugins/plugins.ts';
+/**
+ * A reply queued for a channel no plugin adds any more, because the process
+ * restarted without it. Never retried and never sent to ManyChat (specs/038).
+ */
+export declare class ChannelNotLoadedError extends Error {
+    constructor(channel: string);
+}
 export interface WorkerLogger {
     info: (obj: object, msg: string) => void;
     warn: (obj: object, msg: string) => void;
@@ -30,6 +37,8 @@ export declare class OutboxWorker {
     private readonly store;
     private readonly nudges;
     private readonly actions;
+    /** The plugins' channels, which deliver their own replies (specs/038). */
+    private readonly channels;
     private running;
     /**
      * Set by the stop function. A contact's rows after the one being sent go

package/dist/outbox/worker.js

@@ -6,6 +6,17 @@ import { performActions, performedOffering } from "../conversation/actions.js";
 import { recordOf } from "../agent/tools.js";
 import { NudgeStore } from "../nudge/store.js";
 import { NudgingPerformer } from "../nudge/performer.js";
+import { channelAdapters } from "../channels/plugin/adapter.js";
+/**
+ * A reply queued for a channel no plugin adds any more, because the process
+ * restarted without it. Never retried and never sent to ManyChat (specs/038).
+ */
+export class ChannelNotLoadedError extends Error {
+    constructor(channel) {
+        super(`channel ${channel} is not loaded`);
+        this.name = 'ChannelNotLoadedError';
+    }
+}
 export class OutboxWorker {
     opts;
     queue;
@@ -13,6 +24,8 @@ export class OutboxWorker {
     store;
     nudges;
     actions;
+    /** The plugins' channels, which deliver their own replies (specs/038). */
+    channels;
     running = false;
     /**
      * Set by the stop function. A contact's rows after the one being sent go
@@ -28,6 +41,7 @@ export class OutboxWorker {
         this.store = new ConversationStore(opts.db);
         this.nudges = new NudgeStore(opts.db);
         this.actions = opts.plugins ? opts.plugins.performer(opts.client, opts.logger) : opts.client;
+        this.channels = opts.plugins ? channelAdapters(opts.plugins, opts.logger) : new Map();
     }
     /**
      * The actions deferred with a reply, performed once, after its first
@@ -69,7 +83,17 @@ export class OutboxWorker {
     }
     async deliver(row) {
         if (row.kind === 'reply') {
-            await this.opts.client.sendText(row.subscriberId, row.payload.messages);
+            const { channel, messages, escalate } = row.payload;
+            if (channel === undefined) {
+                await this.opts.client.sendText(row.subscriberId, messages);
+                return;
+            }
+            // A plugin channel's reply goes out through its own adapter, never
+            // through ManyChat (specs/038).
+            const adapter = this.channels.get(channel);
+            if (!adapter)
+                throw new ChannelNotLoadedError(channel);
+            await adapter.deliver(row.subscriberId, { messages, escalate: escalate === true });
             return;
         }
         // The token that failed to land was never stored, so a fresh one replaces
@@ -140,7 +164,10 @@ export class OutboxWorker {
             // ManyChat's own verdict when it is ManyChat's error, and a retry
             // otherwise: an unknown failure, such as the database, must not
             // discard a reply (specs/022 § Retries follow the SDK's retryable).
-            const retryable = error instanceof ManyChatError ? error.retryable : true;
+            const retryable = error instanceof ManyChatError
+                ? error.retryable
+                : // A channel that is gone will not come back by retrying (specs/038).
+                    !(error instanceof ChannelNotLoadedError);
             // A token write's error is kept to its status: ManyChat's answer to it
             // could quote the value it was sent (specs/019).
             const message = row.kind === 'contact_token'