@theowlops/boombot 0.0.0-stage → 1.1.1

package/dist/node_modules/@boombot/channels/transports/whatsapp/transport.js

@@ -0,0 +1,189 @@
+import { createHmac, timingSafeEqual } from 'node:crypto';
+import {} from '../common/index.js';
+import { MessageDeduplicator } from '../common/index.js';
+const GRAPH_API_BASE = 'https://graph.facebook.com/v22.0';
+const MAX_TEXT_LENGTH = 4096;
+export class WhatsAppTransport {
+    kind = 'whatsapp';
+    displayName = 'WhatsApp';
+    enabled;
+    phoneNumberId;
+    accessToken;
+    verifyToken;
+    appSecret;
+    allowlist;
+    log;
+    turnService;
+    subscribeTurnDone;
+    pendingReplies = new Map();
+    deduplicator = new MessageDeduplicator();
+    unsubscribeTurnDone;
+    status = 'disconnected';
+    statusDetail = 'NOT_CONFIGURED';
+    constructor(config, log, inbound = {}) {
+        this.enabled = config.enabled !== false;
+        this.phoneNumberId = config.phoneNumberId?.trim() || undefined;
+        this.accessToken = config.accessToken?.trim() || undefined;
+        this.verifyToken = config.verifyToken?.trim() || undefined;
+        this.appSecret = config.appSecret?.trim() || undefined;
+        this.allowlist = new Set(config.allowlistChatIds ?? []);
+        this.log = log;
+        this.turnService = inbound.turnService;
+        this.subscribeTurnDone = inbound.subscribeTurnDone;
+    }
+    async start() {
+        if (!this.enabled) {
+            this.statusDetail = 'DISABLED';
+            return;
+        }
+        this.unsubscribeTurnDone ??= this.subscribeTurnDone?.((payload) => this.onTurnDone(payload));
+        if (this.phoneNumberId === undefined || this.accessToken === undefined) {
+            this.statusDetail = 'NOT_CONFIGURED';
+            return;
+        }
+        try {
+            const response = await fetch(`${GRAPH_API_BASE}/${this.phoneNumberId}?fields=id`, {
+                headers: { authorization: `Bearer ${this.accessToken}` },
+                signal: AbortSignal.timeout(15_000),
+            });
+            const data = (await response.json());
+            if (data.error !== undefined)
+                throw new Error(data.error.message ?? 'credential check failed');
+            this.status = 'connected';
+            this.statusDetail = undefined;
+            this.log.info('whatsapp: connected');
+        }
+        catch (error) {
+            this.status = 'error';
+            this.statusDetail = error instanceof Error ? error.message : 'CONNECT_FAILED';
+            this.log.error('whatsapp: credential check failed', { detail: this.statusDetail });
+        }
+    }
+    async stop() {
+        this.unsubscribeTurnDone?.();
+        this.unsubscribeTurnDone = undefined;
+        this.pendingReplies.clear();
+        if (this.status === 'connected') {
+            this.status = 'disconnected';
+            this.statusDetail = 'STOPPED';
+        }
+    }
+    getStatus() {
+        return this.statusDetail === undefined
+            ? { status: this.status }
+            : { status: this.status, detail: this.statusDetail };
+    }
+    async handleWebhook(request) {
+        if (!this.enabled)
+            return { status: 503 };
+        if (request.method === 'GET') {
+            const valid = request.query.get('hub.mode') === 'subscribe'
+                && this.verifyToken !== undefined
+                && request.query.get('hub.verify_token') === this.verifyToken;
+            return valid
+                ? { status: 200, contentType: 'text/plain; charset=utf-8', body: request.query.get('hub.challenge') ?? '' }
+                : { status: 401 };
+        }
+        if (this.appSecret === undefined ||
+            this.phoneNumberId === undefined ||
+            this.accessToken === undefined)
+            return { status: 503 };
+        const signatureValue = request.headers['x-hub-signature-256'];
+        const signature = typeof signatureValue === 'string' ? signatureValue : (signatureValue?.[0] ?? '');
+        const expected = `sha256=${createHmac('sha256', this.appSecret).update(request.rawBody).digest('hex')}`;
+        const actualBytes = Buffer.from(signature);
+        const expectedBytes = Buffer.from(expected);
+        if (actualBytes.length !== expectedBytes.length || !timingSafeEqual(actualBytes, expectedBytes)) {
+            return { status: 401 };
+        }
+        let body;
+        try {
+            body = JSON.parse(request.rawBody.toString('utf8'));
+        }
+        catch {
+            return { status: 400 };
+        }
+        for (const message of extractMessages(body)) {
+            if (message.type !== 'text' ||
+                message.text?.body?.trim() === '' ||
+                !this.allowlist.has(message.from) ||
+                !this.deduplicator.checkAndRecord(message.id) ||
+                this.turnService === undefined)
+                continue;
+            try {
+                const result = await this.turnService.submit({
+                    input: message.text?.body ?? '',
+                    channel: 'whatsapp',
+                    replyTo: message.from,
+                });
+                this.pendingReplies.set(result.turnId, message.from);
+            }
+            catch (error) {
+                this.log.error('whatsapp: submit failed', {
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                return { status: 500 };
+            }
+        }
+        return { status: 200 };
+    }
+    async send(target, text) {
+        if (this.phoneNumberId === undefined || this.accessToken === undefined) {
+            throw new Error('NOT_CONFIGURED: whatsapp phoneNumberId/accessToken missing');
+        }
+        const to = target.trim();
+        if (to === '' || text.trim() === '')
+            throw new Error('INVALID_ARGUMENT: target/text empty');
+        const points = Array.from(text);
+        for (let index = 0; index < points.length; index += MAX_TEXT_LENGTH) {
+            const response = await fetch(`${GRAPH_API_BASE}/${this.phoneNumberId}/messages`, {
+                method: 'POST',
+                headers: { authorization: `Bearer ${this.accessToken}`, 'content-type': 'application/json' },
+                body: JSON.stringify({
+                    messaging_product: 'whatsapp',
+                    to,
+                    type: 'text',
+                    text: { body: points.slice(index, index + MAX_TEXT_LENGTH).join('') },
+                }),
+                signal: AbortSignal.timeout(15_000),
+            });
+            const data = (await response.json());
+            if (data.error !== undefined)
+                throw new Error(`SEND_FAILED: ${data.error.message ?? 'unknown error'}`);
+        }
+    }
+    onTurnDone(payload) {
+        const target = this.pendingReplies.get(payload.turnId)
+            ?? (payload.channel === 'whatsapp' ? payload.replyTo : undefined);
+        if (target === undefined)
+            return;
+        this.pendingReplies.delete(payload.turnId);
+        void this.send(target, payload.status === 'completed'
+            ? (payload.output?.trim() || '(empty response)')
+            : `Turn failed${payload.error ? `: ${payload.error}` : ''}.`).catch((error) => this.log.error('whatsapp: reply failed', {
+            error: error instanceof Error ? error.message : String(error),
+        }));
+    }
+}
+function extractMessages(value) {
+    if (!isRecord(value) || !Array.isArray(value['entry']))
+        return [];
+    const messages = [];
+    for (const entry of value['entry']) {
+        if (!isRecord(entry) || !Array.isArray(entry['changes']))
+            continue;
+        for (const change of entry['changes']) {
+            if (!isRecord(change) || !isRecord(change['value']) || !Array.isArray(change['value']['messages']))
+                continue;
+            for (const message of change['value']['messages']) {
+                if (isRecord(message) && typeof message['id'] === 'string' && typeof message['from'] === 'string') {
+                    messages.push(message);
+                }
+            }
+        }
+    }
+    return messages;
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

package/dist/node_modules/@boombot/channels/transports/whatsapp.d.ts

@@ -0,0 +1,2 @@
+/** Re-export from modular whatsapp package */
+export * from './whatsapp/index.js';

package/dist/node_modules/@boombot/channels/transports/whatsapp.js

@@ -0,0 +1,2 @@
+/** Re-export from modular whatsapp package */
+export * from './whatsapp/index.js';

package/dist/node_modules/@boombot/channels/transports/zalo/index.d.ts

@@ -0,0 +1,2 @@
+export * from './oa.js';
+export * from './personal.js';

package/dist/node_modules/@boombot/channels/transports/zalo/index.js

@@ -0,0 +1,2 @@
+export * from './oa.js';
+export * from './personal.js';

package/dist/node_modules/@boombot/channels/transports/zalo/oa.d.ts

@@ -0,0 +1,28 @@
+import type { ChannelKind } from '@boombot/protocol';
+import type { ChannelLogger, ChannelRuntimeStatus, ChannelTransport } from '../common/index.js';
+export interface ZaloTransportConfig {
+    readonly enabled?: boolean;
+    readonly appId?: string;
+    readonly appSecret?: string;
+    /** Reserved for a future documented personal-Zalo bridge contract. */
+    readonly bridgeUrl?: string;
+    readonly oaToken?: string;
+}
+export declare class ZaloTransport implements ChannelTransport {
+    readonly kind: ChannelKind;
+    readonly displayName = "Zalo";
+    private readonly enabled;
+    private readonly bridgeUrl;
+    private readonly oaToken;
+    private readonly log;
+    private status;
+    private statusDetail;
+    constructor(config: ZaloTransportConfig, log: ChannelLogger);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    send(target: string, text: string): Promise<void>;
+    getStatus(): {
+        status: ChannelRuntimeStatus;
+        detail?: string;
+    };
+}

package/dist/node_modules/@boombot/channels/transports/zalo/oa.js

@@ -0,0 +1,94 @@
+const ZALO_API_BASE = 'https://openapi.zalo.me/v3.0/oa';
+export class ZaloTransport {
+    kind = 'zalo';
+    displayName = 'Zalo';
+    enabled;
+    bridgeUrl;
+    oaToken;
+    log;
+    status = 'disconnected';
+    statusDetail = 'NOT_CONFIGURED';
+    constructor(config, log) {
+        this.enabled = config.enabled !== false;
+        this.bridgeUrl = config.bridgeUrl?.trim() || undefined;
+        this.oaToken = config.oaToken?.trim() || undefined;
+        this.log = log;
+    }
+    async start() {
+        if (!this.enabled) {
+            this.statusDetail = 'DISABLED';
+            return;
+        }
+        if (this.oaToken === undefined) {
+            this.statusDetail =
+                this.bridgeUrl === undefined ? 'NOT_CONFIGURED' : 'UNSUPPORTED_BRIDGE';
+            this.log.info(this.bridgeUrl === undefined
+                ? 'zalo: missing oaToken'
+                : 'zalo: bridgeUrl is not supported without a bridge contract');
+            return;
+        }
+        try {
+            const data = encodeURIComponent(JSON.stringify({ offset: 0, count: 1 }));
+            const response = await fetch(`${ZALO_API_BASE}/user/getlist?data=${data}`, {
+                headers: { access_token: this.oaToken },
+                signal: AbortSignal.timeout(15_000),
+            });
+            const body = (await response.json());
+            if (!response.ok || body.error !== 0) {
+                throw new Error(body.error === undefined ? `HTTP ${response.status}` : `API ${body.error}`);
+            }
+            this.status = 'connected';
+            this.statusDetail = undefined;
+            this.log.info('zalo: connected (OA outbound only)');
+        }
+        catch (error) {
+            this.status = 'error';
+            this.statusDetail =
+                error instanceof Error ? error.message : 'CONNECT_FAILED';
+            this.log.error('zalo: credential check failed', {
+                detail: this.statusDetail,
+            });
+        }
+    }
+    async stop() {
+        if (this.status === 'connected') {
+            this.status = 'disconnected';
+            this.statusDetail = 'STOPPED';
+        }
+        this.log.info('zalo: stopped');
+    }
+    async send(target, text) {
+        if (!this.enabled)
+            throw new Error('DISABLED: zalo is disabled');
+        if (this.oaToken === undefined) {
+            throw new Error(this.bridgeUrl === undefined
+                ? 'NOT_CONFIGURED: zalo missing oaToken'
+                : 'UNSUPPORTED: zalo bridgeUrl has no documented bridge contract');
+        }
+        const userId = target.trim();
+        if (userId === '' || text.trim() === '') {
+            throw new Error('INVALID_ARGUMENT: target/text must not be empty');
+        }
+        const response = await fetch(`${ZALO_API_BASE}/message/cs`, {
+            method: 'POST',
+            headers: {
+                access_token: this.oaToken,
+                'content-type': 'application/json',
+            },
+            body: JSON.stringify({
+                recipient: { user_id: userId },
+                message: { text },
+            }),
+            signal: AbortSignal.timeout(15_000),
+        });
+        const data = (await response.json().catch(() => undefined));
+        if (!response.ok || data?.error !== 0) {
+            throw new Error(`SEND_FAILED: ${data?.message ?? (data?.error === undefined ? `HTTP ${response.status}` : `API ${data.error}`)}`);
+        }
+    }
+    getStatus() {
+        return this.statusDetail === undefined
+            ? { status: this.status }
+            : { status: this.status, detail: this.statusDetail };
+    }
+}

package/dist/node_modules/@boombot/channels/transports/zalo/personal.d.ts

@@ -0,0 +1,106 @@
+import type { ChannelKind } from '@boombot/protocol';
+import { type ChannelLogger, type ChannelRuntimeStatus, type ChannelTransport, type TurnDonePayload, type TurnSubmitter } from '../common/index.js';
+export interface ZaloPersonalCredentials {
+    readonly imei: string;
+    readonly userAgent: string;
+    readonly language?: string;
+    readonly cookie: unknown;
+}
+export interface ZaloPersonalMessage {
+    readonly type: number;
+    readonly threadId: string;
+    readonly isSelf: boolean;
+    readonly data: {
+        readonly content: unknown;
+    };
+}
+export interface ZaloPersonalApi {
+    readonly listener: {
+        on(event: 'message', handler: (message: ZaloPersonalMessage) => void): unknown;
+        on(event: 'error', handler: (error: unknown) => void): unknown;
+        on(event: 'closed', handler: (code: number, reason: string) => void): unknown;
+        start(options: {
+            retryOnClose: boolean;
+        }): void;
+        stop(): void;
+    };
+    sendMessage(message: {
+        msg: string;
+    }, threadId: string, type: number): Promise<unknown>;
+    getGroupInfo(threadId: string): Promise<{
+        readonly gridInfoMap: Record<string, unknown>;
+    }>;
+    getContext(): {
+        imei: string;
+        userAgent: string;
+        language?: string;
+    };
+    getCookie(): {
+        serializeSync(): {
+            cookies?: unknown[];
+        } | undefined;
+    };
+}
+export interface ZaloQrEvent {
+    readonly type: number;
+    readonly data: {
+        readonly image: string;
+    } | null;
+    readonly actions: {
+        abort(): unknown;
+    } | null;
+}
+interface ZaloPersonalClient {
+    login(credentials: ZaloPersonalCredentials): Promise<ZaloPersonalApi>;
+    loginQR(options: object, callback: (event: ZaloQrEvent) => void): Promise<ZaloPersonalApi>;
+}
+export declare const ZALO_THREAD_USER: number;
+export declare const ZALO_THREAD_GROUP: number;
+export declare const ZALO_QR_EVENT: {
+    readonly QRCodeGenerated: number;
+    readonly QRCodeExpired: number;
+    readonly QRCodeDeclined: number;
+};
+export declare function createZaloPersonalClient(): ZaloPersonalClient;
+export interface ZaloPersonalTransportOptions {
+    readonly credentials?: ZaloPersonalCredentials;
+    readonly api?: ZaloPersonalApi;
+    readonly dataDir: string;
+    readonly log: ChannelLogger;
+    readonly turnService?: TurnSubmitter;
+    readonly subscribeTurnDone?: (handler: (payload: TurnDonePayload) => void) => () => void;
+}
+export declare class ZaloPersonalTransport implements ChannelTransport {
+    readonly kind: ChannelKind;
+    readonly displayName = "Zalo Personal";
+    private api;
+    private readonly credentials;
+    private readonly log;
+    private readonly statePath;
+    private readonly turnService;
+    private readonly subscribeTurnDone;
+    private readonly allowlist;
+    private readonly pendingReplies;
+    private readonly threadTypes;
+    private pairing;
+    private status;
+    private detail;
+    private unsubscribeTurnDone;
+    constructor(options: ZaloPersonalTransportOptions);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    send(target: string, text: string): Promise<void>;
+    getStatus(): {
+        status: ChannelRuntimeStatus;
+        detail?: string;
+    };
+    createPairingCode(): string;
+    unpairThread(threadId: string): void;
+    private onMessage;
+    private onTurnDone;
+    private resolveThreadType;
+    private loadState;
+    private saveState;
+    private prunePairing;
+}
+export {};

package/dist/node_modules/@boombot/channels/transports/zalo/personal.js

@@ -0,0 +1,171 @@
+import { randomInt } from 'node:crypto';
+import { join } from 'node:path';
+import * as zca from 'zca-js';
+import { readJsonFile, writeJsonFile, } from '../common/index.js';
+const PAIRING_TTL_MS = 10 * 60 * 1000;
+const PAIRING_CODE_PATTERN = /^BOOM-\d{6}$/;
+const runtime = zca;
+export const ZALO_THREAD_USER = runtime.ThreadType.User;
+export const ZALO_THREAD_GROUP = runtime.ThreadType.Group;
+export const ZALO_QR_EVENT = runtime.LoginQRCallbackEventType;
+export function createZaloPersonalClient() {
+    return new runtime.Zalo();
+}
+export class ZaloPersonalTransport {
+    kind = 'zalo';
+    displayName = 'Zalo Personal';
+    api;
+    credentials;
+    log;
+    statePath;
+    turnService;
+    subscribeTurnDone;
+    allowlist = new Set();
+    pendingReplies = new Map();
+    threadTypes = new Map();
+    pairing = [];
+    status = 'disconnected';
+    detail = 'NOT_CONFIGURED';
+    unsubscribeTurnDone;
+    constructor(options) {
+        this.api = options.api;
+        this.credentials = options.credentials;
+        this.log = options.log;
+        this.statePath = join(options.dataDir, 'channels', 'zalo-personal', 'state.json');
+        this.turnService = options.turnService;
+        this.subscribeTurnDone = options.subscribeTurnDone;
+    }
+    async start() {
+        this.loadState();
+        try {
+            this.api ??= this.credentials
+                ? await createZaloPersonalClient().login(this.credentials)
+                : undefined;
+            if (!this.api)
+                throw new Error('NOT_CONFIGURED');
+            this.api.listener.on('message', (message) => {
+                void this.onMessage(message).catch((error) => {
+                    this.log.error('zalo personal: inbound message failed', {
+                        detail: error instanceof Error ? error.message : String(error),
+                    });
+                });
+            });
+            this.api.listener.on('error', (error) => {
+                this.log.error('zalo personal: listener error', {
+                    detail: error instanceof Error ? error.message : String(error),
+                });
+            });
+            this.api.listener.on('closed', (_code, reason) => {
+                this.status = 'error';
+                this.detail = reason || 'SESSION_CLOSED';
+            });
+            this.api.listener.start({ retryOnClose: true });
+            this.unsubscribeTurnDone = this.subscribeTurnDone?.((payload) => void this.onTurnDone(payload));
+            this.status = 'connected';
+            this.detail = undefined;
+            this.log.info('zalo personal: connected');
+        }
+        catch (error) {
+            this.status = 'error';
+            this.detail = error instanceof Error ? error.message : 'CONNECT_FAILED';
+            this.log.error('zalo personal: connection failed', { detail: this.detail });
+        }
+    }
+    async stop() {
+        this.api?.listener.stop();
+        this.unsubscribeTurnDone?.();
+        this.unsubscribeTurnDone = undefined;
+        this.saveState();
+        this.status = 'disconnected';
+        this.detail = 'STOPPED';
+    }
+    async send(target, text) {
+        if (!this.api)
+            throw new Error('NOT_CONFIGURED: zalo personal is not connected');
+        const threadId = target.trim();
+        if (!threadId || !text.trim())
+            throw new Error('INVALID_ARGUMENT: target/text must not be empty');
+        const type = await this.resolveThreadType(threadId);
+        await this.api.sendMessage({ msg: text }, threadId, type);
+    }
+    getStatus() {
+        this.prunePairing();
+        if (this.status === 'connected' && this.pairing.length > 0) {
+            return { status: 'pending', detail: 'PAIRING' };
+        }
+        return this.detail ? { status: this.status, detail: this.detail } : { status: this.status };
+    }
+    createPairingCode() {
+        this.prunePairing();
+        const code = `BOOM-${String(randomInt(0, 1_000_000)).padStart(6, '0')}`;
+        this.pairing.push({ code, createdAt: Date.now() });
+        this.saveState();
+        return code;
+    }
+    unpairThread(threadId) {
+        this.allowlist.delete(threadId.trim());
+        this.saveState();
+    }
+    async onMessage(message) {
+        if (message.isSelf)
+            return;
+        const threadId = String(message.threadId);
+        const text = typeof message.data.content === 'string' ? message.data.content.trim() : '';
+        this.threadTypes.set(threadId, message.type);
+        if (PAIRING_CODE_PATTERN.test(text.toUpperCase())) {
+            const index = this.pairing.findIndex((entry) => entry.code === text.toUpperCase());
+            if (index === -1)
+                return;
+            this.pairing.splice(index, 1);
+            this.allowlist.add(threadId);
+            this.saveState();
+            await this.send(threadId, 'Đã ghép nối chat này với BoomBot.');
+            return;
+        }
+        if (!text || !this.allowlist.has(threadId) || !this.turnService)
+            return;
+        const result = await this.turnService.submit({ input: text, channel: 'zalo', replyTo: threadId });
+        this.pendingReplies.set(result.turnId, threadId);
+    }
+    async onTurnDone(payload) {
+        const threadId = this.pendingReplies.get(payload.turnId);
+        if (!threadId)
+            return;
+        this.pendingReplies.delete(payload.turnId);
+        const text = payload.status === 'error' ? payload.error : payload.output;
+        if (text)
+            await this.send(threadId, text).catch((error) => {
+                this.log.error('zalo personal: reply failed', {
+                    detail: error instanceof Error ? error.message : String(error),
+                });
+            });
+    }
+    async resolveThreadType(threadId) {
+        const known = this.threadTypes.get(threadId);
+        if (known !== undefined)
+            return known;
+        try {
+            const info = await this.api?.getGroupInfo(threadId);
+            const type = info?.gridInfoMap[threadId] ? ZALO_THREAD_GROUP : ZALO_THREAD_USER;
+            this.threadTypes.set(threadId, type);
+            return type;
+        }
+        catch {
+            return ZALO_THREAD_USER;
+        }
+    }
+    loadState() {
+        const state = readJsonFile(this.statePath);
+        for (const id of state?.allowlist ?? [])
+            this.allowlist.add(id);
+        this.pairing = [...(state?.pairing ?? [])];
+        this.prunePairing();
+    }
+    saveState() {
+        writeJsonFile(this.statePath, { allowlist: [...this.allowlist], pairing: this.pairing });
+    }
+    prunePairing() {
+        const cutoff = Date.now() - PAIRING_TTL_MS;
+        this.pairing = this.pairing.filter((entry) => entry.createdAt >= cutoff);
+    }
+}

package/dist/node_modules/@boombot/channels/transports/zalo-personal.d.ts

@@ -0,0 +1,2 @@
+/** Re-export from modular zalo package */
+export * from './zalo/personal.js';

package/dist/node_modules/@boombot/channels/transports/zalo-personal.js

@@ -0,0 +1,2 @@
+/** Re-export from modular zalo package */
+export * from './zalo/personal.js';

package/dist/node_modules/@boombot/channels/transports/zalo.d.ts

@@ -0,0 +1,2 @@
+/** Re-export from modular zalo package */
+export * from './zalo/oa.js';

package/dist/node_modules/@boombot/channels/transports/zalo.js

@@ -0,0 +1,2 @@
+/** Re-export from modular zalo package */
+export * from './zalo/oa.js';

package/dist/node_modules/@boombot/core/agent-core/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * `@boombot/core` — transport-agnostic gateway contracts and middleware.
+ *
+ * Boundary rule: this package MUST NOT import `@boombot/protocol`
+ * or any other BoomBot package.
+ */
+export * from './types.js';
+export * from './runtime-deps.js';
+export * from './middleware.js';
+export * from './tool-errors.js';
+export * from './routing.js';
+export * from './turn-loop.js';

package/dist/node_modules/@boombot/core/agent-core/index.js

@@ -0,0 +1,12 @@
+/**
+ * `@boombot/core` — transport-agnostic gateway contracts and middleware.
+ *
+ * Boundary rule: this package MUST NOT import `@boombot/protocol`
+ * or any other BoomBot package.
+ */
+export * from './types.js';
+export * from './runtime-deps.js';
+export * from './middleware.js';
+export * from './tool-errors.js';
+export * from './routing.js';
+export * from './turn-loop.js';