botinabox 2.9.1 → 2.9.3

package/README.md

@@ -13,7 +13,8 @@ A modular TypeScript framework for building multi-agent bots with LLM orchestrat
 - **Message interpretation** -- Async structured extraction from messages into tasks, memories, files, and user context. Pluggable extractors for custom data types. Programmatic task creation (no LLM dependency).
 - **Triage routing** -- Content-aware message routing with keyword/regex matching, priority rules, and LLM fallback. Ownership chain logging for every routing decision.
 - **Multi-agent orchestration** -- Define agents with different models, roles, and execution adapters. Task queue with priority scheduling, retry policies, and followup chains.
-- **Loop detection and circuit breakers** -- Pattern-based loop detection (self-loops, ping-pong, blocked re-entry) plus circuit breakers with automatic human escalation.
+- **Loop detection and circuit breakers** -- Pattern-based loop detection (self-loops, ping-pong, blocked re-entry) plus circuit breakers with automatic human escalation. Scheduler connector syncs are circuit-broken per key — persistent connector failures trip the breaker instead of retrying endlessly.
+- **Safe tool merging** -- `mergeTools(nativeTools, localSkills)` deduplicates tool arrays with last-wins semantics. Prevents Anthropic API 400 errors from duplicate tool names when combining built-in and custom tools.
 - **Learning pipeline** -- Structured feedback capture with auto-promotion: 3+ similar records become a playbook, 3+ agents become a reusable skill.
 - **Governance gates** -- Independent QA, quality, and drift gates that validate agent output and report to the human operator.
 - **Permission relay** -- Remote approval via messaging platforms (Slack, Discord, Telegram). Dual approval: local + remote, first wins.

package/bin/botinabox.mjs

@@ -1,2 +1,2 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 import('../dist/cli.js').then(m => m.main(process.argv.slice(2)));

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

@@ -0,0 +1,32 @@
+/**
+ * DiscordAdapter — ChannelAdapter implementation for Discord.
+ * Story 4.6
+ */
+import type { ChannelAdapter, ChannelCapabilities, ChannelMeta, ChannelConfig, InboundMessage, OutboundPayload, SendResult, HealthStatus } from "../../shared/index.js";
+/** Minimal Discord client interface for mockability. */
+export interface DiscordClient {
+    sendMessage(channelId: string, content: string): Promise<{
+        id: string;
+    }>;
+}
+export declare class DiscordAdapter implements ChannelAdapter {
+    readonly id = "discord";
+    readonly meta: ChannelMeta;
+    readonly capabilities: ChannelCapabilities;
+    onMessage?: (message: InboundMessage) => Promise<void>;
+    private connected;
+    private config;
+    private client;
+    constructor(client?: DiscordClient);
+    connect(config: ChannelConfig): Promise<void>;
+    disconnect(): Promise<void>;
+    healthCheck(): Promise<HealthStatus>;
+    send(target: {
+        peerId: string;
+        threadId?: string;
+    }, payload: OutboundPayload): Promise<SendResult>;
+    /** Simulate receiving an inbound message (for testing/webhooks). */
+    receive(event: Record<string, unknown>): Promise<void>;
+}
+/** Factory function — default export for auto-discovery. */
+export default function createDiscordAdapter(client?: DiscordClient): DiscordAdapter;

package/dist/channels/discord/inbound.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Discord inbound message parsing.
+ * Story 4.6
+ */
+import type { InboundMessage } from "../../shared/index.js";
+export interface DiscordEvent {
+    id?: string;
+    channel_id?: string;
+    guild_id?: string;
+    author?: {
+        id?: string;
+        username?: string;
+    };
+    content?: string;
+    message_reference?: {
+        message_id?: string;
+        channel_id?: string;
+    };
+    timestamp?: string;
+    [key: string]: unknown;
+}
+/**
+ * Parse a Discord message event into an InboundMessage.
+ */
+export declare function parseDiscordEvent(event: DiscordEvent): InboundMessage;

package/dist/channels/discord/index.d.ts

@@ -1,87 +1,11 @@
-import { C as ChannelAdapter, d as ChannelMeta, b as ChannelCapabilities, I as InboundMessage, c as ChannelConfig, H as HealthStatus, O as OutboundPayload, S as SendResult } from '../../channel-CVm1AWUF.js';
-import '../../provider-BHkqkSdq.js';
-
 /**
- * DiscordAdapter — ChannelAdapter implementation for Discord.
+ * @botinabox/channel-discord — Discord channel adapter.
  * Story 4.6
  */
-
-/** Minimal Discord client interface for mockability. */
-interface DiscordClient {
-    sendMessage(channelId: string, content: string): Promise<{
-        id: string;
-    }>;
-}
-declare class DiscordAdapter implements ChannelAdapter {
-    readonly id = "discord";
-    readonly meta: ChannelMeta;
-    readonly capabilities: ChannelCapabilities;
-    onMessage?: (message: InboundMessage) => Promise<void>;
-    private connected;
-    private config;
-    private client;
-    constructor(client?: DiscordClient);
-    connect(config: ChannelConfig): Promise<void>;
-    disconnect(): Promise<void>;
-    healthCheck(): Promise<HealthStatus>;
-    send(target: {
-        peerId: string;
-        threadId?: string;
-    }, payload: OutboundPayload): Promise<SendResult>;
-    /** Simulate receiving an inbound message (for testing/webhooks). */
-    receive(event: Record<string, unknown>): Promise<void>;
-}
-/** Factory function — default export for auto-discovery. */
-declare function createDiscordAdapter(client?: DiscordClient): DiscordAdapter;
-
-/**
- * Discord inbound message parsing.
- * Story 4.6
- */
-
-interface DiscordEvent {
-    id?: string;
-    channel_id?: string;
-    guild_id?: string;
-    author?: {
-        id?: string;
-        username?: string;
-    };
-    content?: string;
-    message_reference?: {
-        message_id?: string;
-        channel_id?: string;
-    };
-    timestamp?: string;
-    [key: string]: unknown;
-}
-/**
- * Parse a Discord message event into an InboundMessage.
- */
-declare function parseDiscordEvent(event: DiscordEvent): InboundMessage;
-
-/**
- * Discord outbound formatting.
- * Discord uses native markdown — just enforce the 2000-char limit.
- * Story 4.6
- */
-/**
- * Split text into Discord-compatible chunks (2000 char max each).
- */
-declare function chunkForDiscord(text: string): string[];
-/**
- * Discord uses native markdown — no conversion needed.
- * Returns the text unchanged (Discord renders it natively).
- */
-declare function formatForDiscord(text: string): string;
-
-/**
- * Discord channel configuration types.
- * Story 4.6
- */
-interface DiscordConfig {
-    token: string;
-    guildId?: string;
-}
-
-export { DiscordAdapter, type DiscordClient, type DiscordConfig, type DiscordEvent, chunkForDiscord, createDiscordAdapter as default, formatForDiscord, parseDiscordEvent };
+export { DiscordAdapter } from "./adapter.js";
+export type { DiscordClient } from "./adapter.js";
+export { parseDiscordEvent } from "./inbound.js";
+export type { DiscordEvent } from "./inbound.js";
+export { formatForDiscord, chunkForDiscord } from "./outbound.js";
+export type { DiscordConfig } from "./models.js";
+export { default } from "./adapter.js";

package/dist/channels/discord/models.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Discord channel configuration types.
+ * Story 4.6
+ */
+export interface DiscordConfig {
+    token: string;
+    guildId?: string;
+}

package/dist/channels/discord/outbound.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Discord outbound formatting.
+ * Discord uses native markdown — just enforce the 2000-char limit.
+ * Story 4.6
+ */
+/**
+ * Split text into Discord-compatible chunks (2000 char max each).
+ */
+export declare function chunkForDiscord(text: string): string[];
+/**
+ * Discord uses native markdown — no conversion needed.
+ * Returns the text unchanged (Discord renders it natively).
+ */
+export declare function formatForDiscord(text: string): string;

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

@@ -0,0 +1,33 @@
+/**
+ * SlackAdapter — ChannelAdapter implementation for Slack.
+ * Story 4.5
+ */
+import type { ChannelAdapter, ChannelCapabilities, ChannelMeta, ChannelConfig, InboundMessage, OutboundPayload, SendResult, HealthStatus } from "../../shared/index.js";
+/** Minimal Bolt-compatible client interface for mockability. */
+export interface BoltClient {
+    postMessage(channel: string, text: string, threadTs?: string): Promise<{
+        ok: boolean;
+        ts?: string;
+    }>;
+}
+export declare class SlackAdapter implements ChannelAdapter {
+    readonly id = "slack";
+    readonly meta: ChannelMeta;
+    readonly capabilities: ChannelCapabilities;
+    onMessage?: (message: InboundMessage) => Promise<void>;
+    private connected;
+    private config;
+    private client;
+    constructor(client?: BoltClient);
+    connect(config: ChannelConfig): Promise<void>;
+    disconnect(): Promise<void>;
+    healthCheck(): Promise<HealthStatus>;
+    send(target: {
+        peerId: string;
+        threadId?: string;
+    }, payload: OutboundPayload): Promise<SendResult>;
+    /** Simulate receiving an inbound message (for testing/webhooks). */
+    receive(event: Record<string, unknown>): Promise<void>;
+}
+/** Factory function — default export for auto-discovery. */
+export default function createSlackAdapter(client?: BoltClient): SlackAdapter;

package/dist/channels/slack/bolt-adapter.d.ts

@@ -0,0 +1,31 @@
+/**
+ * SlackBoltAdapter — real Bolt Socket Mode integration for botinabox.
+ *
+ * Handles:
+ * - Bolt app lifecycle (start, stop)
+ * - Inbound message parsing + self-filtering
+ * - response.ready → Slack message delivery
+ * - file.deliver → Slack file upload
+ *
+ * Apps just instantiate and start:
+ *   const slack = new SlackBoltAdapter({ botToken, appToken, hooks, pipeline });
+ *   await slack.start();
+ */
+import type { HookBus } from '../../core/hooks/hook-bus.js';
+import type { ChatPipeline } from '../../core/chat/chat-pipeline.js';
+import type { AttachmentEnricherMap } from './enrichers/types.js';
+export interface SlackBoltAdapterConfig {
+    botToken: string;
+    appToken: string;
+    hooks: HookBus;
+    pipeline: ChatPipeline;
+    /** Optional per-type attachment enrichers. */
+    attachmentEnrichers?: AttachmentEnricherMap;
+}
+export declare class SlackBoltAdapter {
+    private app;
+    private config;
+    constructor(config: SlackBoltAdapterConfig);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+}

package/dist/channels/slack/enrichers/enrich.d.ts

@@ -0,0 +1,12 @@
+import type { InboundMessage } from "../../../shared/types/channel.js";
+import type { AttachmentEnricherMap, EnrichmentContext } from "./types.js";
+/**
+ * Run enrichers over each attachment on an InboundMessage. Text blocks get
+ * appended to `body`; image/document blocks get stored on `attachmentBlocks`
+ * so ChatPipeline can assemble a multimodal user message.
+ *
+ * Enrichers that throw or return empty arrays fall back to a plain
+ * `[Attached: <filename>]` breadcrumb — the LLM still sees the attachment
+ * was there, just without content.
+ */
+export declare function enrichAttachments(msg: InboundMessage, ctx: EnrichmentContext, enrichers: AttachmentEnricherMap): Promise<InboundMessage>;

package/dist/channels/slack/enrichers/image-enricher.d.ts

@@ -0,0 +1,10 @@
+import type { AttachmentEnricher } from "./types.js";
+/**
+ * Slack image enricher. Downloads the image via the Slack bot token and
+ * returns a single `image` ContentBlock containing the base64 data. No
+ * intermediate vision API call — the downstream Anthropic provider sees
+ * the raw image and processes it natively.
+ *
+ * Consumers wire this as `attachmentEnrichers.image = createSlackImageEnricher()`.
+ */
+export declare function createSlackImageEnricher(): AttachmentEnricher;

package/dist/channels/slack/enrichers/index.d.ts

@@ -0,0 +1,4 @@
+export type { AttachmentEnricher, AttachmentEnricherMap, EnrichmentContext, EnrichedMessage, } from "./types.js";
+export { enrichAttachments } from "./enrich.js";
+export { createSlackImageEnricher } from "./image-enricher.js";
+export { createSlackPdfEnricher } from "./pdf-enricher.js";

package/dist/channels/slack/enrichers/pdf-enricher.d.ts

@@ -0,0 +1,8 @@
+import type { AttachmentEnricher } from "./types.js";
+/**
+ * Slack PDF enricher. Downloads the PDF via the Slack bot token and returns
+ * a single `document` ContentBlock containing the base64 data. No intermediate
+ * document-extraction API call — the downstream Anthropic provider ingests
+ * the PDF natively.
+ */
+export declare function createSlackPdfEnricher(): AttachmentEnricher;

package/dist/channels/slack/enrichers/types.d.ts

@@ -0,0 +1,33 @@
+import type { Attachment, AttachmentMediaType, InboundMessage } from "../../../shared/types/channel.js";
+import type { ContentBlock } from "../../../shared/types/provider.js";
+/**
+ * Transport-specific context passed to every enricher. Extensible — add a new
+ * optional sub-context when wiring a new source (gmail, drive, dropbox, etc.)
+ * and enrichers that need it can type-guard.
+ */
+export interface EnrichmentContext {
+    slack?: {
+        botToken: string;
+    };
+    drive?: {
+        client: unknown;
+    };
+    gmail?: {
+        client: unknown;
+    };
+}
+/**
+ * An AttachmentEnricher downloads an attachment and returns Claude content
+ * blocks representing it. Text blocks become part of the message body; image
+ * and document blocks flow through to the Anthropic provider unchanged.
+ *
+ * Enrichers throw on failure. The framework catches and falls back to a
+ * plain `[Attached: <filename>]` breadcrumb in the message body.
+ */
+export type AttachmentEnricher = (attachment: Attachment, ctx: EnrichmentContext) => Promise<ContentBlock[]>;
+export type AttachmentEnricherMap = Partial<Record<AttachmentMediaType, AttachmentEnricher>>;
+/** Internal: the result of running enrichAttachments on a message. */
+export interface EnrichedMessage extends InboundMessage {
+    body: string;
+}
+export type { InboundMessage };

package/dist/channels/slack/inbound.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Slack inbound message parsing.
+ * Story 4.5
+ */
+import type { InboundMessage } from "../../shared/index.js";
+export interface SlackFile {
+    id?: string;
+    filetype?: string;
+    subtype?: string;
+    url_private?: string;
+    preview?: string;
+    transcription?: {
+        status?: string;
+        preview?: {
+            content?: string;
+        };
+    };
+    [key: string]: unknown;
+}
+export interface SlackEvent {
+    type: string;
+    subtype?: string;
+    client_msg_id?: string;
+    ts?: string;
+    event_ts?: string;
+    channel?: string;
+    user?: string;
+    text?: string;
+    thread_ts?: string;
+    files?: SlackFile[];
+    [key: string]: unknown;
+}
+/**
+ * Extract the text content from a voice message file.
+ * Prefers the transcription preview; falls back to the file preview text.
+ * Returns null if the file is not a voice message or has no transcript.
+ */
+export declare function extractVoiceTranscript(file: SlackFile): string | null;
+/**
+ * Parse a Slack event into an InboundMessage.
+ *
+ * Handles standard text messages and voice messages (file_share subtype
+ * with audio files). Voice message transcripts are extracted and prefixed
+ * with `[Voice message]`.
+ */
+export declare function parseSlackEvent(event: SlackEvent): InboundMessage;
+/**
+ * Enrich a voice message with local transcription when Slack's built-in
+ * transcription is unavailable.
+ *
+ * Downloads the audio file from Slack using the bot token, converts to WAV,
+ * and transcribes locally via whisper-node. Returns the original message
+ * unchanged if transcription fails or is not needed.
+ *
+ * @param msg - The parsed inbound message (from parseSlackEvent)
+ * @param botToken - Slack bot token for authenticated file download
+ * @returns The message with body replaced by transcript, or original on failure
+ */
+export declare function enrichVoiceMessage(msg: InboundMessage, botToken: string): Promise<InboundMessage>;

package/dist/channels/slack/index.d.ts

@@ -1,255 +1,16 @@
-import { C as ChannelAdapter, d as ChannelMeta, b as ChannelCapabilities, I as InboundMessage, c as ChannelConfig, H as HealthStatus, O as OutboundPayload, S as SendResult, A as Attachment, a as AttachmentMediaType } from '../../channel-CVm1AWUF.js';
-import { H as HookBus, c as ChatPipeline } from '../../chat-pipeline-aBSj7a4E.js';
-import { c as ContentBlock } from '../../provider-BHkqkSdq.js';
-import 'better-sqlite3';
-
 /**
- * SlackAdapter — ChannelAdapter implementation for Slack.
+ * @botinabox/channel-slack — Slack channel adapter.
  * Story 4.5
  */
-
-/** Minimal Bolt-compatible client interface for mockability. */
-interface BoltClient {
-    postMessage(channel: string, text: string, threadTs?: string): Promise<{
-        ok: boolean;
-        ts?: string;
-    }>;
-}
-declare class SlackAdapter implements ChannelAdapter {
-    readonly id = "slack";
-    readonly meta: ChannelMeta;
-    readonly capabilities: ChannelCapabilities;
-    onMessage?: (message: InboundMessage) => Promise<void>;
-    private connected;
-    private config;
-    private client;
-    constructor(client?: BoltClient);
-    connect(config: ChannelConfig): Promise<void>;
-    disconnect(): Promise<void>;
-    healthCheck(): Promise<HealthStatus>;
-    send(target: {
-        peerId: string;
-        threadId?: string;
-    }, payload: OutboundPayload): Promise<SendResult>;
-    /** Simulate receiving an inbound message (for testing/webhooks). */
-    receive(event: Record<string, unknown>): Promise<void>;
-}
-/** Factory function — default export for auto-discovery. */
-declare function createSlackAdapter(client?: BoltClient): SlackAdapter;
-
-/**
- * Slack inbound message parsing.
- * Story 4.5
- */
-
-interface SlackFile {
-    id?: string;
-    filetype?: string;
-    subtype?: string;
-    url_private?: string;
-    preview?: string;
-    transcription?: {
-        status?: string;
-        preview?: {
-            content?: string;
-        };
-    };
-    [key: string]: unknown;
-}
-interface SlackEvent {
-    type: string;
-    subtype?: string;
-    client_msg_id?: string;
-    ts?: string;
-    event_ts?: string;
-    channel?: string;
-    user?: string;
-    text?: string;
-    thread_ts?: string;
-    files?: SlackFile[];
-    [key: string]: unknown;
-}
-/**
- * Extract the text content from a voice message file.
- * Prefers the transcription preview; falls back to the file preview text.
- * Returns null if the file is not a voice message or has no transcript.
- */
-declare function extractVoiceTranscript(file: SlackFile): string | null;
-/**
- * Parse a Slack event into an InboundMessage.
- *
- * Handles standard text messages and voice messages (file_share subtype
- * with audio files). Voice message transcripts are extracted and prefixed
- * with `[Voice message]`.
- */
-declare function parseSlackEvent(event: SlackEvent): InboundMessage;
-/**
- * Enrich a voice message with local transcription when Slack's built-in
- * transcription is unavailable.
- *
- * Downloads the audio file from Slack using the bot token, converts to WAV,
- * and transcribes locally via whisper-node. Returns the original message
- * unchanged if transcription fails or is not needed.
- *
- * @param msg - The parsed inbound message (from parseSlackEvent)
- * @param botToken - Slack bot token for authenticated file download
- * @returns The message with body replaced by transcript, or original on failure
- */
-declare function enrichVoiceMessage(msg: InboundMessage, botToken: string): Promise<InboundMessage>;
-
-/**
- * Local voice transcription via whisper-node (whisper.cpp bindings).
- *
- * whisper-node is an optional dependency — if not installed, transcription
- * degrades gracefully (returns null). Requires ffmpeg on the system PATH
- * for audio format conversion.
- *
- * Setup:
- *   npm install whisper-node
- *   npx whisper-node download    # download a model (e.g. base.en)
- *   brew install ffmpeg           # or equivalent for your platform
- */
-interface TranscribeOptions {
-    /** Whisper model name (default: "base.en"). Run `npx whisper-node download` to get models. */
-    modelName?: string;
-    /** Language code (default: "auto"). Use "en" for English-only models. */
-    language?: string;
-}
-interface TranscribeResult {
-    /** The full transcribed text */
-    text: string;
-    /** Individual segments with timestamps */
-    segments: Array<{
-        start: string;
-        end: string;
-        speech: string;
-    }>;
-}
-/**
- * Transcribe an audio buffer using whisper-node.
- *
- * @param audioBuffer - Raw audio data (any format ffmpeg can decode)
- * @param filename - Original filename (used for temp file extension)
- * @param opts - Transcription options
- * @returns Transcribed text, or null if transcription fails or whisper-node is not installed
- */
-declare function transcribeAudio(audioBuffer: Buffer, filename: string, opts?: TranscribeOptions): Promise<string | null>;
-/**
- * Download an audio file from a URL with bearer token authentication.
- */
-declare function downloadAudio(url: string, token: string): Promise<Buffer | null>;
-
-/**
- * Slack outbound formatting.
- * Story 4.5
- */
-/**
- * Convert standard markdown to Slack's mrkdwn format.
- * - **bold** → *bold*
- * - _italic_ preserved
- * - `code` preserved
- * - ```code block``` preserved
- */
-declare function formatForSlack(text: string): string;
-
-/**
- * Slack channel configuration types.
- * Story 4.5
- */
-interface SlackConfig {
-    botToken: string;
-    appToken?: string;
-    signingSecret?: string;
-}
-
-/**
- * Transport-specific context passed to every enricher. Extensible — add a new
- * optional sub-context when wiring a new source (gmail, drive, dropbox, etc.)
- * and enrichers that need it can type-guard.
- */
-interface EnrichmentContext {
-    slack?: {
-        botToken: string;
-    };
-    drive?: {
-        client: unknown;
-    };
-    gmail?: {
-        client: unknown;
-    };
-}
-/**
- * An AttachmentEnricher downloads an attachment and returns Claude content
- * blocks representing it. Text blocks become part of the message body; image
- * and document blocks flow through to the Anthropic provider unchanged.
- *
- * Enrichers throw on failure. The framework catches and falls back to a
- * plain `[Attached: <filename>]` breadcrumb in the message body.
- */
-type AttachmentEnricher = (attachment: Attachment, ctx: EnrichmentContext) => Promise<ContentBlock[]>;
-type AttachmentEnricherMap = Partial<Record<AttachmentMediaType, AttachmentEnricher>>;
-/** Internal: the result of running enrichAttachments on a message. */
-interface EnrichedMessage extends InboundMessage {
-    body: string;
-}
-
-/**
- * SlackBoltAdapter — real Bolt Socket Mode integration for botinabox.
- *
- * Handles:
- * - Bolt app lifecycle (start, stop)
- * - Inbound message parsing + self-filtering
- * - response.ready → Slack message delivery
- * - file.deliver → Slack file upload
- *
- * Apps just instantiate and start:
- *   const slack = new SlackBoltAdapter({ botToken, appToken, hooks, pipeline });
- *   await slack.start();
- */
-
-interface SlackBoltAdapterConfig {
-    botToken: string;
-    appToken: string;
-    hooks: HookBus;
-    pipeline: ChatPipeline;
-    /** Optional per-type attachment enrichers. */
-    attachmentEnrichers?: AttachmentEnricherMap;
-}
-declare class SlackBoltAdapter {
-    private app;
-    private config;
-    constructor(config: SlackBoltAdapterConfig);
-    start(): Promise<void>;
-    stop(): Promise<void>;
-}
-
-/**
- * Run enrichers over each attachment on an InboundMessage. Text blocks get
- * appended to `body`; image/document blocks get stored on `attachmentBlocks`
- * so ChatPipeline can assemble a multimodal user message.
- *
- * Enrichers that throw or return empty arrays fall back to a plain
- * `[Attached: <filename>]` breadcrumb — the LLM still sees the attachment
- * was there, just without content.
- */
-declare function enrichAttachments(msg: InboundMessage, ctx: EnrichmentContext, enrichers: AttachmentEnricherMap): Promise<InboundMessage>;
-
-/**
- * Slack image enricher. Downloads the image via the Slack bot token and
- * returns a single `image` ContentBlock containing the base64 data. No
- * intermediate vision API call — the downstream Anthropic provider sees
- * the raw image and processes it natively.
- *
- * Consumers wire this as `attachmentEnrichers.image = createSlackImageEnricher()`.
- */
-declare function createSlackImageEnricher(): AttachmentEnricher;
-
-/**
- * Slack PDF enricher. Downloads the PDF via the Slack bot token and returns
- * a single `document` ContentBlock containing the base64 data. No intermediate
- * document-extraction API call — the downstream Anthropic provider ingests
- * the PDF natively.
- */
-declare function createSlackPdfEnricher(): AttachmentEnricher;
-
-export { type AttachmentEnricher, type AttachmentEnricherMap, type BoltClient, type EnrichedMessage, type EnrichmentContext, SlackAdapter, SlackBoltAdapter, type SlackBoltAdapterConfig, type SlackConfig, type SlackEvent, type SlackFile, type TranscribeOptions, type TranscribeResult, createSlackImageEnricher, createSlackPdfEnricher, createSlackAdapter as default, downloadAudio, enrichAttachments, enrichVoiceMessage, extractVoiceTranscript, formatForSlack, parseSlackEvent, transcribeAudio };
+export { SlackAdapter } from "./adapter.js";
+export type { BoltClient } from "./adapter.js";
+export { parseSlackEvent, extractVoiceTranscript, enrichVoiceMessage } from "./inbound.js";
+export type { SlackEvent, SlackFile } from "./inbound.js";
+export { transcribeAudio, downloadAudio } from "./transcribe.js";
+export type { TranscribeOptions, TranscribeResult } from "./transcribe.js";
+export { formatForSlack } from "./outbound.js";
+export type { SlackConfig } from "./models.js";
+export { SlackBoltAdapter } from "./bolt-adapter.js";
+export type { SlackBoltAdapterConfig } from "./bolt-adapter.js";
+export { default } from "./adapter.js";
+export * from "./enrichers/index.js";