botinabox 2.13.0 → 2.13.1

package/dist/channel-06G0vbIn.d.ts

@@ -0,0 +1,72 @@
+/** Channel adapter types — Story 1.5 / 4.1 */
+type ChatType = "direct" | "group" | "channel";
+type FormattingMode = "markdown" | "mrkdwn" | "html" | "plain";
+interface ChannelCapabilities {
+    chatTypes: ChatType[];
+    threads: boolean;
+    reactions: boolean;
+    editing: boolean;
+    media: boolean;
+    polls: boolean;
+    maxTextLength: number;
+    formattingMode: FormattingMode;
+}
+interface ChannelMeta {
+    displayName: string;
+    icon?: string;
+    homepage?: string;
+}
+interface InboundMessage {
+    id: string;
+    channel: string;
+    account?: string;
+    from: string;
+    userId?: string;
+    body: string;
+    threadId?: string;
+    replyToId?: string;
+    attachments?: Attachment[];
+    receivedAt: string;
+    raw?: unknown;
+}
+interface Attachment {
+    type: "image" | "file" | "audio" | "video";
+    url?: string;
+    mimeType?: string;
+    filename?: string;
+    size?: number;
+}
+interface OutboundPayload {
+    text: string;
+    threadId?: string;
+    replyToId?: string;
+    attachments?: Attachment[];
+}
+interface SendResult {
+    success: boolean;
+    messageId?: string;
+    error?: string;
+}
+interface HealthStatus {
+    ok: boolean;
+    latencyMs?: number;
+    error?: string;
+}
+type ChannelConfig = Record<string, unknown>;
+interface ChannelAdapter {
+    /** Unique identifier for this adapter instance */
+    id: string;
+    meta: ChannelMeta;
+    capabilities: ChannelCapabilities;
+    connect(config: ChannelConfig): Promise<void>;
+    disconnect(): Promise<void>;
+    healthCheck(): Promise<HealthStatus>;
+    send(target: {
+        peerId: string;
+        threadId?: string;
+    }, payload: OutboundPayload): Promise<SendResult>;
+    /** Called when a message arrives — set by the framework */
+    onMessage?: (message: InboundMessage) => Promise<void>;
+}
+
+export type { Attachment as A, ChannelAdapter as C, FormattingMode as F, HealthStatus as H, InboundMessage as I, OutboundPayload as O, SendResult as S, ChannelCapabilities as a, ChannelConfig as b, ChannelMeta as c, ChatType as d };

package/dist/chat-pipeline-DuNX5WoL.d.ts

@@ -0,0 +1,655 @@
+import * as better_sqlite3 from 'better-sqlite3';
+import { I as InboundMessage } from './channel-06G0vbIn.js';
+import { C as ChatMessage } from './provider-DLGUfnNx.js';
+
+type HookHandler = (context: Record<string, unknown>) => Promise<void> | void;
+type Unsubscribe = () => void;
+interface HookOptions {
+    /** 0–100, default 50. Lower = runs first. */
+    priority?: number;
+    /** Auto-unsubscribe after first invocation. */
+    once?: boolean;
+    /** Only fire if context matches all filter key/value pairs. */
+    filter?: Record<string, unknown>;
+}
+interface HookRegistration {
+    event: string;
+    handler: HookHandler;
+    priority: number;
+    once: boolean;
+    filter?: Record<string, unknown>;
+    /** Internal auto-increment for stable sort within same priority */
+    id: number;
+}
+
+/**
+ * Priority-ordered event bus for decoupled inter-layer communication.
+ * Story 1.1 — handlers run in priority order, errors are isolated,
+ * and registrations are unsubscribable.
+ */
+declare class HookBus {
+    private readonly registrations;
+    private nextId;
+    register(event: string, handler: HookHandler, opts?: HookOptions): Unsubscribe;
+    emit(event: string, context: Record<string, unknown>): Promise<void>;
+    /** Emit synchronously (use only when async is not needed) */
+    emitSync(event: string, context: Record<string, unknown>): void;
+    hasListeners(event: string): boolean;
+    listRegistered(): string[];
+    /** Remove all handlers for an event, or all handlers if no event given */
+    clear(event?: string): void;
+}
+
+interface TableDefinition {
+    columns: Record<string, string>;
+    primaryKey?: string | string[];
+    tableConstraints?: string[];
+    relations?: Record<string, RelationDef>;
+    render?: string | ((rows: Row[]) => string);
+    outputFile?: string;
+    filter?: (rows: Row[]) => Row[];
+}
+interface RelationDef {
+    type: 'belongsTo' | 'hasMany';
+    table: string;
+    foreignKey: string;
+    references?: string;
+}
+interface EntityContextDef {
+    table: string;
+    directory: string;
+    slugColumn: string;
+    files: Record<string, EntityFileSpec>;
+    indexFile?: string;
+    /** Custom index render function. If omitted, a default listing is generated. */
+    indexRender?: (rows: Row[]) => string;
+    protectedFiles?: string[];
+    /** When true, this entity's data is never rendered into other entities' context files. */
+    protected?: boolean;
+    /** Enable at-rest encryption. Requires encryptionKey in Lattice options. */
+    encrypted?: boolean | {
+        columns: string[];
+    };
+}
+interface EntityFileSpec {
+    source: EntitySource;
+    render: string | ((rows: Row[]) => string);
+    junctionColumns?: string[];
+    omitIfEmpty?: boolean;
+}
+type EntitySource = {
+    type: 'self';
+} | {
+    type: 'hasMany';
+    table: string;
+    foreignKey: string;
+    filters?: Filter[];
+    softDelete?: boolean;
+    orderBy?: string;
+    limit?: number;
+} | {
+    type: 'manyToMany';
+    junctionTable: string;
+    localKey: string;
+    remoteKey: string;
+    remoteTable: string;
+    filters?: Filter[];
+    softDelete?: boolean;
+    orderBy?: string;
+    limit?: number;
+} | {
+    type: 'belongsTo';
+    table: string;
+    foreignKey: string;
+} | {
+    type: 'enriched';
+    include: Record<string, EntitySource>;
+} | {
+    type: 'custom';
+    resolve: (row: Row, adapter: SqliteAdapter) => Row[];
+};
+interface Filter {
+    col: string;
+    op: 'eq' | 'ne' | 'gt' | 'gte' | 'lt' | 'lte' | 'like' | 'in' | 'isNull' | 'isNotNull';
+    val?: unknown;
+}
+interface QueryOptions {
+    where?: Record<string, unknown>;
+    filters?: Filter[];
+    orderBy?: string | Array<{
+        col: string;
+        dir: 'asc' | 'desc';
+    }>;
+    orderDir?: 'asc' | 'desc';
+    limit?: number;
+    offset?: number;
+}
+type Row = Record<string, unknown>;
+type PkLookup = string | Record<string, unknown>;
+interface SqliteAdapter {
+    run(sql: string, params?: unknown[]): better_sqlite3.RunResult;
+    get<T = Row>(sql: string, params?: unknown[]): T | undefined;
+    all<T = Row>(sql: string, params?: unknown[]): T[];
+    tableInfo(table: string): TableInfoRow[];
+    invalidateTableCache(table: string): void;
+}
+interface TableInfoRow {
+    cid: number;
+    name: string;
+    type: string;
+    notnull: number;
+    dflt_value: unknown;
+    pk: number;
+}
+interface SeedItem {
+    table: string;
+    rows: Row[];
+    naturalKey?: string | string[];
+    junctions?: Array<{
+        table: string;
+        items: Array<Row>;
+    }>;
+    softDeleteMissing?: boolean;
+}
+
+declare class DataStoreError extends Error {
+    constructor(message: string);
+}
+/**
+ * Thin wrapper around Lattice that provides the botinabox DataStore API.
+ *
+ * Delegates all data operations to the latticesql package. Application-level
+ * events (task.created, run.completed, etc.) remain on the HookBus — they are
+ * emitted by orchestrator modules, not the data layer.
+ */
+declare class DataStore {
+    private lattice;
+    private readonly hooks;
+    private readonly outputDir;
+    private _initialized;
+    private readonly deferredStatements;
+    constructor(opts: {
+        dbPath: string;
+        outputDir?: string;
+        wal?: boolean;
+        hooks?: HookBus;
+    });
+    /**
+     * Register a table definition. Must be called before init().
+     *
+     * tableConstraints may contain both inline constraints (FOREIGN KEY, UNIQUE)
+     * and standalone SQL statements (CREATE INDEX). Standalone statements are
+     * deferred and executed after init() creates the tables.
+     */
+    define(name: string, def: TableDefinition): void;
+    /**
+     * Register an entity context definition for per-entity file rendering.
+     */
+    defineEntityContext(name: string, def: EntityContextDef): void;
+    init(opts?: {
+        migrations?: Array<{
+            version: string;
+            sql: string;
+        }>;
+    }): Promise<void>;
+    private assertInitialized;
+    insert(table: string, row: Row): Promise<Row>;
+    upsert(table: string, row: Row): Promise<Row>;
+    update(table: string, pk: PkLookup, changes: Row): Promise<Row>;
+    delete(table: string, pk: PkLookup): Promise<void>;
+    /**
+     * Get a single row by primary key.
+     * Returns undefined if not found (Lattice returns null).
+     */
+    get(table: string, pk: PkLookup): Promise<Row | undefined>;
+    query(table: string, opts?: QueryOptions): Promise<Row[]>;
+    count(table: string, opts?: QueryOptions): Promise<number>;
+    link(junctionTable: string, row: Row): Promise<void>;
+    unlink(junctionTable: string, row: Row): Promise<void>;
+    migrate(migrations: Array<{
+        version: string;
+        sql: string;
+    }>): Promise<void>;
+    seed(items: SeedItem[]): Promise<void>;
+    render(): Promise<void>;
+    reconcile(): Promise<void>;
+    tableInfo(table: string): TableInfoRow[];
+    close(): void;
+    on(event: string, handler: (context: Record<string, unknown>) => void): void;
+}
+
+/**
+ * MessageStore — store-before-respond guarantee for all chat interactions.
+ * Story 7.1
+ *
+ * Every inbound message (with attachments) is stored BEFORE the bot responds.
+ * Every outbound message is stored BEFORE it is sent to the user.
+ * Storage confirmation is required before any response flows.
+ */
+
+interface StoredAttachment {
+    fileType: string;
+    filename?: string;
+    mimeType?: string;
+    sizeBytes?: number;
+    contents?: string;
+    summary?: string;
+    url?: string;
+}
+interface StoreResult {
+    messageId: string;
+    attachmentIds: string[];
+}
+declare class MessageStore {
+    private db;
+    private hooks;
+    constructor(db: DataStore, hooks: HookBus);
+    /**
+     * Store an inbound message and its attachments.
+     * Must complete successfully before any bot response is generated.
+     */
+    storeInbound(msg: InboundMessage): Promise<StoreResult>;
+    /**
+     * Store an outbound message BEFORE sending it.
+     * Returns the message ID for confirmation tracking.
+     */
+    storeOutbound(opts: {
+        channel: string;
+        text: string;
+        threadId?: string;
+        agentId?: string;
+        agentSlug?: string;
+        taskId?: string;
+    }): Promise<string>;
+    /**
+     * Store an attachment linked to a message.
+     */
+    storeAttachment(messageId: string, att: StoredAttachment): Promise<string>;
+    /**
+     * Get recent messages in a thread for context building.
+     */
+    getThreadHistory(threadId: string, limit?: number): Promise<Array<Record<string, unknown>>>;
+    /**
+     * Get recent outbound messages in a thread for redundancy checking.
+     */
+    getRecentOutbound(threadId: string, limit?: number): Promise<Array<Record<string, unknown>>>;
+    /**
+     * Get recent messages in a channel (all threads combined).
+     * More reliable than getThreadHistory for DMs where thread_ids are inconsistent.
+     */
+    getChannelHistory(channel: string, limit?: number): Promise<Array<Record<string, unknown>>>;
+    /**
+     * Get recent messages from a specific user across all threads.
+     */
+    getUserHistory(userId: string, channel: string, limit?: number): Promise<Array<Record<string, unknown>>>;
+    /**
+     * Get attachments for a message.
+     */
+    getAttachments(messageId: string): Promise<Array<Record<string, unknown>>>;
+}
+
+/**
+ * ChatResponder — fast conversational layer with LLM-filtered responses.
+ * Story 7.2
+ *
+ * Provides rapid (<2s) conversational responses using a cheap LLM (Haiku).
+ * The responder has awareness of tools and capabilities but does NOT execute
+ * anything — it keeps the conversation going while work happens async.
+ *
+ * All outbound messages (direct, post-interpretation, task execution) are
+ * filtered through this layer for human readability and redundancy checking.
+ */
+
+interface ChatResponderConfig {
+    /** System prompt for the conversational responder */
+    systemPrompt?: string;
+    /** Max tokens for context window. Default: 4000 */
+    contextWindowTokens?: number;
+    /** Max recent outbound messages to check for redundancy. Default: 10 */
+    redundancyWindow?: number;
+    /** Model to use for responses. Default: 'fast' (resolved via ModelRouter) */
+    model?: string;
+    /** Caller-provided LLM call function */
+    llmCall: (params: {
+        model: string;
+        messages: ChatMessage[];
+        system?: string;
+        maxTokens?: number;
+    }) => Promise<{
+        content: string;
+    }>;
+}
+declare class ChatResponder {
+    private db;
+    private hooks;
+    private messageStore;
+    private readonly systemPrompt;
+    private readonly contextWindowTokens;
+    private readonly redundancyWindow;
+    private readonly model;
+    private readonly llmCall;
+    constructor(db: DataStore, hooks: HookBus, messageStore: MessageStore, config: ChatResponderConfig);
+    /**
+     * Generate a fast conversational response to an inbound message.
+     * Uses rolling context window from thread history.
+     */
+    respond(opts: {
+        messageBody: string;
+        threadId: string;
+        channel: string;
+        userName?: string;
+        capabilities?: string;
+        additionalContext?: string;
+    }): Promise<string>;
+    /**
+     * Filter any outbound message through the LLM for human readability.
+     * This is the single funnel ALL responses pass through.
+     */
+    filterResponse(text: string, context?: {
+        channel?: string;
+        threadId?: string;
+        source?: string;
+    }): Promise<string>;
+    /**
+     * Check if a candidate outbound message is redundant with recent messages.
+     * Returns true if the message should be suppressed.
+     */
+    isRedundant(text: string, threadId: string): Promise<boolean>;
+    /**
+     * Full send pipeline: check redundancy → filter → store → deliver.
+     * Returns the message ID, or undefined if suppressed as redundant.
+     */
+    sendResponse(opts: {
+        text: string;
+        channel: string;
+        threadId: string;
+        agentId?: string;
+        agentSlug?: string;
+        taskId?: string;
+        source?: string;
+        skipRedundancyCheck?: boolean;
+        skipFilter?: boolean;
+    }): Promise<string | undefined>;
+    /**
+     * Build a context window from thread history, trimmed to token limit.
+     *
+     * Only includes inbound (user) messages. Outbound (bot) messages are
+     * excluded to prevent the ack layer from mimicking prior verbose responses,
+     * which caused hallucinated system state and walls of text.
+     */
+    private buildContextWindow;
+}
+
+/**
+ * TriageRouter — content-based routing with deterministic-first resolution.
+ * Story 6.3
+ *
+ * Replaces the simple channel→agent binding with intelligent routing:
+ * 1. Keyword/regex rules evaluated first (deterministic, ~4ms)
+ * 2. LLM classification only for ambiguous messages (async, ~2-4s)
+ * 3. Ownership chain logged for every routing decision
+ *
+ * Key constraint: specialists return to triage, never to another specialist.
+ */
+
+interface RoutingRule {
+    /** Target agent slug */
+    agentSlug: string;
+    /** Keywords that trigger this rule (case-insensitive) */
+    keywords?: string[];
+    /** Regex patterns that trigger this rule */
+    patterns?: string[];
+    /** Priority — lower number wins ties. Default: 50 */
+    priority?: number;
+}
+interface RoutingDecision {
+    timestamp: string;
+    source: string;
+    target: string;
+    reason: string;
+    method: 'deterministic' | 'llm';
+    messageId?: string;
+    channel?: string;
+}
+interface TriageRouterConfig {
+    /** Static routing rules evaluated deterministically */
+    rules: RoutingRule[];
+    /** Fallback agent if no rule matches and LLM is unavailable */
+    fallbackAgent?: string;
+    /** Whether to use LLM for ambiguous messages. Default: true */
+    llmFallback?: boolean;
+    /** Log decisions to the database. Default: true */
+    persist?: boolean;
+}
+declare class TriageRouter {
+    private db;
+    private hooks;
+    private readonly rules;
+    private readonly fallbackAgent?;
+    private readonly llmFallback;
+    private readonly persist;
+    private readonly compiledRules;
+    constructor(db: DataStore, hooks: HookBus, config: TriageRouterConfig);
+    /**
+     * Route an inbound message to the best agent.
+     * Returns the agent slug and the routing decision.
+     */
+    route(msg: InboundMessage): Promise<{
+        agentSlug: string | undefined;
+        decision: RoutingDecision;
+    }>;
+    /**
+     * Query the ownership chain for a given message or channel.
+     */
+    getDecisionHistory(filter?: {
+        channel?: string;
+        limit?: number;
+    }): Promise<RoutingDecision[]>;
+    /**
+     * LLM classification — emits a hook for external LLM integration.
+     * Returns agent slug + reason, or undefined if LLM is unavailable.
+     */
+    private classifyWithLLM;
+    private buildDecision;
+    private logDecision;
+}
+
+/**
+ * MessageInterpreter — async structured extraction from messages.
+ * Story 7.3
+ *
+ * After every message is stored, the interpreter runs async to extract
+ * structured data types: tasks, memories, files, user context, and custom types.
+ *
+ * Uses a cheap LLM (Haiku) for classification and extraction.
+ * Pluggable extractors allow apps to add custom data types.
+ */
+
+interface ExtractedTask {
+    title: string;
+    description?: string;
+    dueDate?: string;
+    scheduled?: boolean;
+    priority?: number;
+}
+interface ExtractedMemory {
+    summary: string;
+    contents: string;
+    tags?: string[];
+    category?: string;
+}
+interface ExtractedFile {
+    filename: string;
+    fileType: string;
+    contents: string;
+    summary: string;
+}
+interface ExtractedUserContext {
+    trait: string;
+    value: string;
+}
+interface InterpretationResult {
+    messageId: string;
+    tasks: ExtractedTask[];
+    memories: ExtractedMemory[];
+    files: ExtractedFile[];
+    userContext: ExtractedUserContext[];
+    custom: Record<string, unknown[]>;
+    isTaskRequest: boolean;
+}
+type LLMCallFn = (params: {
+    model: string;
+    messages: ChatMessage[];
+    system?: string;
+    maxTokens?: number;
+}) => Promise<{
+    content: string;
+}>;
+/**
+ * Pluggable extractor interface for custom data types.
+ */
+interface Extractor {
+    readonly type: string;
+    extract(message: {
+        body: string;
+        attachments?: Array<Record<string, unknown>>;
+    }, llmCall: LLMCallFn): Promise<unknown[]>;
+}
+interface MessageInterpreterConfig {
+    /** Additional custom extractors beyond built-in ones */
+    extractors?: Extractor[];
+    /** Model for interpretation LLM calls. Default: 'fast' */
+    model?: string;
+    /** LLM call function */
+    llmCall: LLMCallFn;
+    /** Auto-create tasks from extracted tasks. Default: false */
+    autoCreateTasks?: boolean;
+}
+declare class MessageInterpreter {
+    private db;
+    private hooks;
+    private readonly extractors;
+    private readonly model;
+    private readonly llmCall;
+    private readonly autoCreateTasks;
+    constructor(db: DataStore, hooks: HookBus, config: MessageInterpreterConfig);
+    /**
+     * Interpret a stored message asynchronously.
+     * Extracts tasks, memories, files, user context, and custom types.
+     */
+    interpret(messageId: string): Promise<InterpretationResult>;
+    /**
+     * Extract structured data from message text using LLM.
+     */
+    private extractWithLLM;
+}
+
+/**
+ * ChatPipeline — configurable 6-layer chat orchestration.
+ * Story 7.4
+ *
+ * Replaces duplicated handler code across apps with a single configurable
+ * pipeline. Apps provide: system prompt, routing rules, LLM call function,
+ * and optional message filter. Everything else is framework-level.
+ *
+ * Layers:
+ *   1. Dedup + Storage (MessageStore)
+ *   2. Fast Response (ChatResponder)
+ *   3. Interpretation (MessageInterpreter)
+ *   4. Post-Interpretation Response
+ *   5. Task Dispatch (TriageRouter)
+ *   6. Task Execution Response
+ */
+
+interface ChatPipelineConfig {
+    /** LLM call function for chat responses and interpretation */
+    llmCall: ChatResponderConfig['llmCall'];
+    /** System prompt for the conversational responder */
+    systemPrompt: string;
+    /** Agent routing rules for task dispatch */
+    routingRules: RoutingRule[];
+    /** Default agent when no rule matches */
+    fallbackAgent: string;
+    /** Optional message filter — return false to ignore a message */
+    messageFilter?: (msg: InboundMessage) => boolean;
+    /** Optional capabilities description for the responder */
+    capabilities?: string;
+    /** Channel this pipeline handles (default: 'slack') */
+    channel?: string;
+    /** Custom extractors for MessageInterpreter */
+    extractors?: Extractor[];
+    /** Dedup window in ms (default: 300_000 = 5 min) */
+    dedupWindowMs?: number;
+    /** Model for fast responses (default: 'fast') */
+    model?: string;
+    /** Enable LLM fallback routing (default: false) */
+    llmRouting?: boolean;
+    /** Skip the ack layer — no fast response before task dispatch (default: false) */
+    skipAck?: boolean;
+    /** TaskQueue instance — required for task dispatch */
+    tasks: {
+        create(task: Record<string, unknown>): Promise<string>;
+        update(id: string, changes: Record<string, unknown>): Promise<void>;
+        get(id: string): Promise<Record<string, unknown> | undefined>;
+    };
+    /** WakeupQueue instance — required for agent waking */
+    wakeups: {
+        enqueue(agentId: string, source: string, context?: Record<string, unknown>): Promise<string>;
+    };
+}
+declare class ChatPipeline {
+    private db;
+    private hooks;
+    readonly messageStore: MessageStore;
+    readonly responder: ChatResponder;
+    readonly interpreter: MessageInterpreter;
+    readonly router: TriageRouter;
+    private readonly channel;
+    private readonly messageFilter?;
+    private readonly capabilities?;
+    private readonly dedupWindowMs;
+    private readonly tasks;
+    private readonly wakeups;
+    private readonly skipAck;
+    private readonly threadChannelMap;
+    /** Last dispatch promise — exposed for testing. */
+    lastDispatch: Promise<void>;
+    constructor(db: DataStore, hooks: HookBus, config: ChatPipelineConfig);
+    /**
+     * Resolve the Slack channel ID for a thread (for response delivery).
+     */
+    resolveChannel(threadId: string, taskId?: string): Promise<string | undefined>;
+    /**
+     * Register the 6-layer pipeline on the HookBus.
+     */
+    private registerHandlers;
+    /**
+     * Check and record message dedup (SHA256 hash, configurable window).
+     */
+    private isDuplicate;
+    /**
+     * Async interpretation + task dispatch (Layers 3-5).
+     *
+     * ALWAYS creates a task programmatically — task creation does not depend
+     * on LLM classification. Interpretation enriches but never gates dispatch.
+     */
+    private interpretAndDispatch;
+    /**
+     * Programmatic task creation — guaranteed, no LLM dependency.
+     */
+    private guaranteedTaskDispatch;
+    /**
+     * Route and dispatch extracted tasks.
+     */
+    private dispatchTasks;
+    /**
+     * Resolve Slack channel ID from thread_task_map or in-memory fallback.
+     */
+    private resolveChannelId;
+    /**
+     * Build human-readable interpretation summary.
+     */
+    private buildSummary;
+}
+
+export { type ChatResponderConfig as C, DataStore as D, type Extractor as E, type Filter as F, HookBus as H, type InterpretationResult as I, type LLMCallFn as L, MessageStore as M, type PkLookup as P, type QueryOptions as Q, type RelationDef as R, type SeedItem as S, type TableDefinition as T, type Unsubscribe as U, ChatResponder as a, MessageInterpreter as b, ChatPipeline as c, type ChatPipelineConfig as d, DataStoreError as e, type EntityContextDef as f, type EntityFileSpec as g, type EntitySource as h, type ExtractedFile as i, type ExtractedMemory as j, type ExtractedTask as k, type ExtractedUserContext as l, type HookHandler as m, type HookOptions as n, type HookRegistration as o, type MessageInterpreterConfig as p, type RoutingDecision as q, type RoutingRule as r, type Row as s, type SqliteAdapter as t, type StoreResult as u, type StoredAttachment as v, type TableInfoRow as w, TriageRouter as x, type TriageRouterConfig as y };

package/dist/chunk-NNPCKR6G.js

@@ -0,0 +1,144 @@
+// src/channels/slack/transcribe.ts
+import { execFileSync } from "child_process";
+import { writeFileSync, unlinkSync, mkdirSync } from "fs";
+import { join } from "path";
+import { randomUUID } from "crypto";
+import os from "os";
+import { createRequire } from "module";
+var TEMP_DIR = join(os.tmpdir(), "botinabox-audio");
+async function transcribeAudio(audioBuffer, filename, opts) {
+  let whisper;
+  try {
+    const require2 = createRequire(import.meta.url);
+    const mod = require2("whisper-node");
+    whisper = mod.whisper ?? mod.default ?? mod;
+  } catch {
+    console.warn("[botinabox] whisper-node not installed \u2014 voice transcription unavailable. Run: npm install whisper-node && npx whisper-node download");
+    return null;
+  }
+  try {
+    execFileSync("ffmpeg", ["-version"], { stdio: "ignore" });
+  } catch {
+    console.warn("[botinabox] ffmpeg not found \u2014 required for audio conversion. Install: brew install ffmpeg");
+    return null;
+  }
+  const id = randomUUID().slice(0, 8);
+  const ext = filename.split(".").pop() ?? "aac";
+  mkdirSync(TEMP_DIR, { recursive: true });
+  const inputPath = join(TEMP_DIR, `${id}.${ext}`);
+  const wavPath = join(TEMP_DIR, `${id}.wav`);
+  try {
+    writeFileSync(inputPath, audioBuffer);
+    execFileSync("ffmpeg", ["-y", "-i", inputPath, "-ar", "16000", "-ac", "1", "-c:a", "pcm_s16le", wavPath], {
+      stdio: "ignore",
+      timeout: 3e4
+    });
+    const segments = await whisper(wavPath, {
+      modelName: opts?.modelName ?? "base.en",
+      whisperOptions: {
+        language: opts?.language ?? "auto"
+      }
+    });
+    if (!segments || segments.length === 0) return null;
+    return segments.map((s) => s.speech).join(" ").trim();
+  } catch (err) {
+    console.error("[botinabox] Transcription failed:", err);
+    return null;
+  } finally {
+    try {
+      unlinkSync(inputPath);
+    } catch {
+    }
+    try {
+      unlinkSync(wavPath);
+    } catch {
+    }
+  }
+}
+async function downloadAudio(url, token) {
+  try {
+    const resp = await fetch(url, {
+      headers: { Authorization: `Bearer ${token}` }
+    });
+    if (!resp.ok) {
+      console.error(`[botinabox] Audio download failed: ${resp.status} ${resp.statusText}`);
+      return null;
+    }
+    return Buffer.from(await resp.arrayBuffer());
+  } catch (err) {
+    console.error("[botinabox] Audio download error:", err);
+    return null;
+  }
+}
+
+// src/channels/slack/inbound.ts
+var AUDIO_TYPES = /* @__PURE__ */ new Set(["aac", "mp4", "m4a", "ogg", "webm", "mp3", "wav"]);
+function extractVoiceTranscript(file) {
+  const isAudio = file.subtype === "slack_audio" || AUDIO_TYPES.has(file.filetype ?? "");
+  if (!isAudio) return null;
+  const transcript = file.transcription?.preview?.content ?? (typeof file.preview === "string" ? file.preview : null);
+  return transcript ?? null;
+}
+function parseSlackEvent(event) {
+  const id = event.client_msg_id ?? event.ts ?? event.event_ts ?? `slack-${Date.now()}`;
+  const channel = event.channel ?? "unknown";
+  const from = event.user ?? "unknown";
+  const threadId = event.thread_ts !== void 0 ? event.thread_ts : void 0;
+  const receivedAt = event.ts ? new Date(parseFloat(event.ts) * 1e3).toISOString() : (/* @__PURE__ */ new Date()).toISOString();
+  let body = event.text ?? "";
+  if (event.subtype === "file_share" && event.files?.length) {
+    for (const file of event.files) {
+      const transcript = extractVoiceTranscript(file);
+      if (transcript) {
+        body = body ? `${body}
+
+[Voice message] ${transcript}` : `[Voice message] ${transcript}`;
+        break;
+      }
+    }
+  }
+  if (event.subtype === "file_share" && event.files?.length && !body) {
+    const hasAudio = event.files.some(
+      (f) => f.subtype === "slack_audio" || AUDIO_TYPES.has(f.filetype ?? "")
+    );
+    if (hasAudio) {
+      body = "[Voice message \u2014 no transcript available]";
+    }
+  }
+  return {
+    id,
+    channel,
+    from,
+    body,
+    threadId,
+    receivedAt,
+    raw: event
+  };
+}
+async function enrichVoiceMessage(msg, botToken) {
+  if (!msg.body.includes("[Voice message \u2014 no transcript available]")) return msg;
+  const raw = msg.raw;
+  const files = raw?.files;
+  if (!files?.length) return msg;
+  const audioFile = files.find(
+    (f) => f.subtype === "slack_audio" || AUDIO_TYPES.has(f.filetype ?? "")
+  );
+  if (!audioFile?.url_private) return msg;
+  const buffer = await downloadAudio(audioFile.url_private, botToken);
+  if (!buffer) return msg;
+  const filename = audioFile.name ?? `voice.${audioFile.filetype ?? "aac"}`;
+  const transcript = await transcribeAudio(buffer, filename);
+  if (!transcript) return msg;
+  return {
+    ...msg,
+    body: `[Voice message] ${transcript}`
+  };
+}
+
+export {
+  transcribeAudio,
+  downloadAudio,
+  extractVoiceTranscript,
+  parseSlackEvent,
+  enrichVoiceMessage
+};

package/dist/connector-B4Mj0P1b.d.ts

@@ -0,0 +1,79 @@
+/** Connector types — generic external service integrations. */
+interface ConnectorMeta {
+    displayName: string;
+    /** Provider identifier, e.g. "google", "trello", "jira", "salesforce" */
+    provider: string;
+    /** Data type this connector handles, e.g. "email", "calendar", "board", "crm" */
+    dataType: string;
+}
+interface SyncOptions {
+    /** Only sync records after this ISO 8601 timestamp */
+    since?: string;
+    /** Provider-specific incremental sync token */
+    cursor?: string;
+    /** Maximum number of records to fetch */
+    limit?: number;
+    /** Provider-specific query filters */
+    filters?: Record<string, unknown>;
+}
+interface SyncResult<T = Record<string, unknown>> {
+    /** Typed records produced by the connector — consumer decides where to store */
+    records: T[];
+    /** Next incremental sync token (persist for future calls) */
+    cursor?: string;
+    /** Whether more records are available (pagination) */
+    hasMore: boolean;
+    /** Errors encountered during sync (non-fatal per-record failures) */
+    errors: Array<{
+        id?: string;
+        error: string;
+    }>;
+}
+interface PushResult {
+    success: boolean;
+    externalId?: string;
+    error?: string;
+}
+interface AuthResult {
+    success: boolean;
+    account?: string;
+    /** URL the user must visit to authorize (for OAuth flows) */
+    authUrl?: string;
+    error?: string;
+}
+type ConnectorConfig = Record<string, unknown>;
+/**
+ * Generic connector interface for external service integrations.
+ *
+ * Connectors pull and optionally push data to/from external services
+ * (Gmail, Calendar, Trello, Jira, Salesforce, etc.). They produce
+ * typed records — the consuming application decides where to store them.
+ *
+ * @typeParam T - The record type this connector produces/consumes.
+ */
+interface Connector<T = Record<string, unknown>> {
+    readonly id: string;
+    readonly meta: ConnectorMeta;
+    connect(config: ConnectorConfig): Promise<void>;
+    disconnect(): Promise<void>;
+    healthCheck(): Promise<{
+        ok: boolean;
+        account?: string;
+        error?: string;
+    }>;
+    /** Pull records from external source */
+    sync(options?: SyncOptions): Promise<SyncResult<T>>;
+    /** Push a record to external source (optional) */
+    push?(payload: T): Promise<PushResult>;
+    /**
+     * Run the authentication/authorization flow for this connector.
+     * For OAuth connectors, this generates the auth URL and exchanges the code for tokens.
+     *
+     * @param codeProvider - called with the auth URL; must return the authorization code.
+     *   For CLI flows, this prints the URL and reads from stdin.
+     *   For programmatic flows, the caller handles the redirect.
+     */
+    authenticate?(codeProvider: (authUrl: string) => Promise<string>): Promise<AuthResult>;
+}
+
+export type { AuthResult as A, ConnectorConfig as C, PushResult as P, SyncOptions as S, Connector as a, ConnectorMeta as b, SyncResult as c };

package/dist/inbound-IBKXBFZF.js

@@ -0,0 +1,11 @@
+import {
+  enrichVoiceMessage,
+  extractVoiceTranscript,
+  parseSlackEvent
+} from "./chunk-NNPCKR6G.js";
+import "./chunk-3RG5ZIWI.js";
+export {
+  enrichVoiceMessage,
+  extractVoiceTranscript,
+  parseSlackEvent
+};

package/dist/provider-DLGUfnNx.d.ts

@@ -0,0 +1,75 @@
+/** LLM provider types — Story 1.5 / 2.1 */
+interface ToolDefinition {
+    name: string;
+    description: string;
+    parameters: Record<string, unknown>;
+}
+interface ChatMessage {
+    role: "user" | "assistant" | "system";
+    content: string | ContentBlock[];
+}
+type ContentBlock = {
+    type: "text";
+    text: string;
+} | {
+    type: "tool_use";
+    id: string;
+    name: string;
+    input: unknown;
+} | {
+    type: "tool_result";
+    tool_use_id: string;
+    content: string;
+};
+interface ChatParams {
+    messages: ChatMessage[];
+    system?: string;
+    tools?: ToolDefinition[];
+    maxTokens?: number;
+    temperature?: number;
+    model: string;
+    abortSignal?: AbortSignal;
+}
+interface TokenUsage {
+    inputTokens: number;
+    outputTokens: number;
+    cacheReadTokens?: number;
+    cacheWriteTokens?: number;
+}
+interface ChatResult {
+    content: string;
+    toolUses?: ToolUse[];
+    usage: TokenUsage;
+    model: string;
+    stopReason: "end_turn" | "tool_use" | "max_tokens" | "stop_sequence";
+}
+interface ToolUse {
+    id: string;
+    name: string;
+    input: unknown;
+}
+interface ModelInfo {
+    id: string;
+    displayName: string;
+    contextWindow: number;
+    maxOutputTokens: number;
+    capabilities: Array<"chat" | "tools" | "vision" | "streaming">;
+    /** Cost in micro-cents per 1M tokens */
+    inputCostPerMToken?: number;
+    outputCostPerMToken?: number;
+}
+interface ResolvedModel {
+    provider: string;
+    model: string;
+}
+interface LLMProvider {
+    id: string;
+    displayName: string;
+    models: ModelInfo[];
+    chat(params: ChatParams): Promise<ChatResult>;
+    chatStream(params: ChatParams): AsyncGenerator<string, ChatResult, unknown>;
+    /** Convert ToolDefinition[] to provider-native format */
+    serializeTools(tools: ToolDefinition[]): unknown;
+}
+
+export type { ChatMessage as C, LLMProvider as L, ModelInfo as M, ResolvedModel as R, TokenUsage as T, ChatParams as a, ChatResult as b, ContentBlock as c, ToolUse as d, ToolDefinition as e };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "botinabox",
-  "version": "2.13.0",
+  "version": "2.13.1",
   "description": "Bot in a Box — framework for building multi-agent bots",
   "type": "module",
   "main": "./dist/index.js",
@@ -60,7 +60,7 @@
     "@types/uuid": "^10.0.0",
     "ajv": "^8.17.1",
     "cron-parser": "^4.9.0",
-    "latticesql": "^1.10.0",
+    "latticesql": "^1.11.0",
     "uuid": "^13.0.0",
     "yaml": "^2.7.0"
   },