botinabox 2.9.0 → 2.9.2

package/dist/index.js

@@ -139,6 +139,44 @@ var HookBus = class {
       if (idx !== -1) arr.splice(idx, 1);
     }
   }
+  /**
+   * Emit an event and collect handler errors instead of swallowing them.
+   * Handlers still run in priority order and one handler's error does not
+   * block subsequent handlers. Returns the array of errors (empty = success).
+   */
+  async emitCollectingErrors(event, context) {
+    const list = this.registrations.get(event);
+    if (!list || list.length === 0) return [];
+    const snapshot = [...list];
+    const toRemove = [];
+    const errors = [];
+    for (const reg of snapshot) {
+      if (reg.filter) {
+        const matches = Object.entries(reg.filter).every(
+          ([k, v]) => context[k] === v
+        );
+        if (!matches) continue;
+      }
+      try {
+        await reg.handler(context);
+      } catch (err) {
+        const wrapped = err instanceof Error ? err : new Error(String(err));
+        errors.push(wrapped);
+        console.error(
+          `[HookBus] Handler error on event "${event}":`,
+          err
+        );
+      }
+      if (reg.once) toRemove.push(reg);
+    }
+    for (const r of toRemove) {
+      const arr = this.registrations.get(event);
+      if (!arr) continue;
+      const idx = arr.indexOf(r);
+      if (idx !== -1) arr.splice(idx, 1);
+    }
+    return errors;
+  }
   /** Emit synchronously (use only when async is not needed) */
   emitSync(event, context) {
     const list = this.registrations.get(event);
@@ -5146,6 +5184,11 @@ var Scheduler = class {
   db;
   hooks;
   timer = null;
+  breaker;
+  /** Wire a CircuitBreaker for connector.sync actions. */
+  setCircuitBreaker(cb) {
+    this.breaker = cb;
+  }
   /**
    * Start the scheduler. Computes initial next_fire_at for schedules
    * that don't have one, then polls for due schedules.
@@ -5178,11 +5221,54 @@ var Scheduler = class {
         for (const [k, v] of Object.entries(config)) {
           if (!k.startsWith("__")) safeConfig[k] = v;
         }
-        await this.hooks.emit(schedule.action, {
-          schedule_id: schedule.id,
-          schedule_name: schedule.name,
-          ...safeConfig
-        });
+        const breakerKey = schedule.action === "connector.sync" && this.breaker ? `${safeConfig["connector"]}:${safeConfig["account"]}` : null;
+        if (breakerKey && !this.breaker.canExecute(breakerKey)) {
+          console.warn(
+            `[Scheduler] circuit open for ${breakerKey}, skipping sync`
+          );
+          continue;
+        }
+        const handlerErrors = await this.hooks.emitCollectingErrors(
+          schedule.action,
+          {
+            schedule_id: schedule.id,
+            schedule_name: schedule.name,
+            ...safeConfig
+          }
+        );
+        if (handlerErrors.length > 0) {
+          if (breakerKey) {
+            await this.breaker.recordFailure(
+              breakerKey,
+              handlerErrors[0].message
+            );
+          }
+          await this.hooks.emit("schedule.error", {
+            schedule_id: schedule.id,
+            schedule_name: schedule.name,
+            error: handlerErrors[0].message
+          });
+          console.error(
+            `[Scheduler] Handler error firing "${schedule.name}":`,
+            handlerErrors[0]
+          );
+          if (schedule.type === "recurring" && schedule.cron) {
+            const nextFire = computeNextFire(
+              schedule.cron,
+              schedule.timezone,
+              /* @__PURE__ */ new Date()
+            );
+            await this.db.update(
+              "schedules",
+              { id: schedule.id },
+              { next_fire_at: nextFire, updated_at: now }
+            );
+          }
+          continue;
+        }
+        if (breakerKey) {
+          await this.breaker.recordSuccess(breakerKey);
+        }
         await this.hooks.emit("schedule.fired", {
           schedule_id: schedule.id,
           schedule_name: schedule.name,
@@ -7190,6 +7276,26 @@ var coordinatorTools = [
   listProjectsTool,
   sendFileTool
 ];
+function mergeTools(...toolSets) {
+  const seen = /* @__PURE__ */ new Map();
+  const result = [];
+  for (const set of toolSets) {
+    for (const tool of set) {
+      const name = tool.definition.name;
+      const existing = seen.get(name);
+      if (existing !== void 0) {
+        result[existing] = tool;
+        console.warn(
+          `[mergeTools] tool '${name}' overridden by a later tool set -- the earlier definition will not be used`
+        );
+      } else {
+        seen.set(name, result.length);
+        result.push(tool);
+      }
+    }
+  }
+  return result;
+}
 
 // src/core/orchestrator/user-registry.ts
 import { v4 as uuidv4 } from "uuid";
@@ -7618,6 +7724,7 @@ export {
   listFilesTool,
   listProjectsTool,
   loadConfig,
+  mergeTools,
   nativeTools,
   parseClaudeStream,
   parseVersion,

package/dist/providers/anthropic/index.d.ts

@@ -1,22 +1,7 @@
-import { L as LLMProvider, M as ModelInfo, e as ToolDefinition, a as ChatParams, b as ChatResult } from '../../provider-BHkqkSdq.js';
-
-declare class AnthropicProvider implements LLMProvider {
-    readonly id = "anthropic";
-    readonly displayName = "Anthropic";
-    readonly models: ModelInfo[];
-    private client;
-    constructor({ apiKey }: {
-        apiKey: string;
-    });
-    serializeTools(tools: ToolDefinition[]): unknown;
-    chat(params: ChatParams): Promise<ChatResult>;
-    chatStream(params: ChatParams): AsyncGenerator<string, ChatResult, unknown>;
-}
-
-declare const MODELS: ModelInfo[];
-
-declare function createAnthropicProvider(config: {
+import type { LLMProvider } from "../../shared/index.js";
+import { AnthropicProvider } from './provider.js';
+import { MODELS } from './models.js';
+export { AnthropicProvider, MODELS };
+export default function createAnthropicProvider(config: {
     apiKey: string;
 }): LLMProvider;
-
-export { AnthropicProvider, MODELS, createAnthropicProvider as default };

package/dist/providers/anthropic/models.d.ts

@@ -0,0 +1,2 @@
+import type { ModelInfo } from "../../shared/index.js";
+export declare const MODELS: ModelInfo[];

package/dist/providers/anthropic/provider.d.ts

@@ -0,0 +1,13 @@
+import type { LLMProvider, ChatParams, ChatResult, ModelInfo, ToolDefinition } from "../../shared/index.js";
+export declare class AnthropicProvider implements LLMProvider {
+    readonly id = "anthropic";
+    readonly displayName = "Anthropic";
+    readonly models: ModelInfo[];
+    private client;
+    constructor({ apiKey }: {
+        apiKey: string;
+    });
+    serializeTools(tools: ToolDefinition[]): unknown;
+    chat(params: ChatParams): Promise<ChatResult>;
+    chatStream(params: ChatParams): AsyncGenerator<string, ChatResult, unknown>;
+}

package/dist/providers/anthropic/tool-converter.d.ts

@@ -0,0 +1,10 @@
+import type { ToolDefinition } from "../../shared/index.js";
+export interface AnthropicTool {
+    name: string;
+    description: string;
+    input_schema: {
+        type: 'object';
+        [key: string]: unknown;
+    };
+}
+export declare function convertTools(tools: ToolDefinition[]): AnthropicTool[];

package/dist/providers/ollama/index.d.ts

@@ -1,24 +1,6 @@
-import { L as LLMProvider, M as ModelInfo, e as ToolDefinition, a as ChatParams, b as ChatResult } from '../../provider-BHkqkSdq.js';
-
-declare class OllamaProvider implements LLMProvider {
-    readonly id = "ollama";
-    readonly displayName = "Ollama";
-    private baseUrl;
-    private cachedModels;
-    private cacheTimestamp;
-    private readonly cacheTtlMs;
-    constructor({ baseUrl }?: {
-        baseUrl?: string;
-    });
-    get models(): ModelInfo[];
-    serializeTools(_tools: ToolDefinition[]): unknown;
-    getModels(): Promise<ModelInfo[]>;
-    chat(params: ChatParams): Promise<ChatResult>;
-    chatStream(params: ChatParams): AsyncGenerator<string, ChatResult, unknown>;
-}
-
-declare function createOllamaProvider(config?: {
+import type { LLMProvider } from "../../shared/index.js";
+import { OllamaProvider } from './provider.js';
+export { OllamaProvider };
+export default function createOllamaProvider(config?: {
     baseUrl?: string;
 }): LLMProvider;
-
-export { OllamaProvider, createOllamaProvider as default };

package/dist/providers/ollama/provider.d.ts

@@ -0,0 +1,17 @@
+import type { LLMProvider, ChatParams, ChatResult, ModelInfo, ToolDefinition } from "../../shared/index.js";
+export declare class OllamaProvider implements LLMProvider {
+    readonly id = "ollama";
+    readonly displayName = "Ollama";
+    private baseUrl;
+    private cachedModels;
+    private cacheTimestamp;
+    private readonly cacheTtlMs;
+    constructor({ baseUrl }?: {
+        baseUrl?: string;
+    });
+    get models(): ModelInfo[];
+    serializeTools(_tools: ToolDefinition[]): unknown;
+    getModels(): Promise<ModelInfo[]>;
+    chat(params: ChatParams): Promise<ChatResult>;
+    chatStream(params: ChatParams): AsyncGenerator<string, ChatResult, unknown>;
+}

package/dist/providers/openai/index.d.ts

@@ -1,22 +1,7 @@
-import { L as LLMProvider, M as ModelInfo, e as ToolDefinition, a as ChatParams, b as ChatResult } from '../../provider-BHkqkSdq.js';
-
-declare class OpenAIProvider implements LLMProvider {
-    readonly id = "openai";
-    readonly displayName = "OpenAI";
-    readonly models: ModelInfo[];
-    private client;
-    constructor({ apiKey }: {
-        apiKey: string;
-    });
-    serializeTools(tools: ToolDefinition[]): unknown;
-    chat(params: ChatParams): Promise<ChatResult>;
-    chatStream(params: ChatParams): AsyncGenerator<string, ChatResult, unknown>;
-}
-
-declare const MODELS: ModelInfo[];
-
-declare function createOpenAIProvider(config: {
+import type { LLMProvider } from "../../shared/index.js";
+import { OpenAIProvider } from './provider.js';
+import { MODELS } from './models.js';
+export { OpenAIProvider, MODELS };
+export default function createOpenAIProvider(config: {
     apiKey: string;
 }): LLMProvider;
-
-export { MODELS, OpenAIProvider, createOpenAIProvider as default };

package/dist/providers/openai/models.d.ts

@@ -0,0 +1,2 @@
+import type { ModelInfo } from "../../shared/index.js";
+export declare const MODELS: ModelInfo[];

package/dist/providers/openai/provider.d.ts

@@ -0,0 +1,13 @@
+import type { LLMProvider, ChatParams, ChatResult, ModelInfo, ToolDefinition } from "../../shared/index.js";
+export declare class OpenAIProvider implements LLMProvider {
+    readonly id = "openai";
+    readonly displayName = "OpenAI";
+    readonly models: ModelInfo[];
+    private client;
+    constructor({ apiKey }: {
+        apiKey: string;
+    });
+    serializeTools(tools: ToolDefinition[]): unknown;
+    chat(params: ChatParams): Promise<ChatResult>;
+    chatStream(params: ChatParams): AsyncGenerator<string, ChatResult, unknown>;
+}

package/dist/providers/openai/tool-converter.d.ts

@@ -0,0 +1,10 @@
+import type { ToolDefinition } from "../../shared/index.js";
+export interface OpenAITool {
+    type: 'function';
+    function: {
+        name: string;
+        description: string;
+        parameters: Record<string, unknown>;
+    };
+}
+export declare function convertTools(tools: ToolDefinition[]): OpenAITool[];

package/dist/shared/constants.d.ts

@@ -0,0 +1,50 @@
+/** Shared constants — event names, default values, status enums */
+/** Hook/event name constants */
+export declare const EVENTS: {
+    readonly COST_RECORDED: "cost.recorded";
+    readonly AGENT_CREATED: "agent.created";
+    readonly AGENT_STATUS_CHANGED: "agent.status_changed";
+    readonly BUDGET_EXCEEDED: "budget.exceeded";
+    readonly TASK_CREATED: "task.created";
+    readonly TASK_COMPLETED: "task.completed";
+    readonly TASK_FAILED: "task.failed";
+    readonly TASK_CANCELLED: "task.cancelled";
+    readonly RUN_STARTED: "run.started";
+    readonly RUN_COMPLETED: "run.completed";
+    readonly RUN_FAILED: "run.failed";
+    readonly MESSAGE_INBOUND: "message.inbound";
+    readonly MESSAGE_ROUTED: "message.routed";
+    readonly MESSAGE_PROCESSED: "message.processed";
+    readonly MESSAGE_OUTBOUND: "message.outbound";
+    readonly MESSAGE_SENT: "message.sent";
+    readonly UPDATE_AVAILABLE: "update.available";
+    readonly UPDATE_STARTED: "update.started";
+    readonly UPDATE_COMPLETED: "update.completed";
+    readonly UPDATE_FAILED: "update.failed";
+    readonly WORKFLOW_STARTED: "workflow.started";
+    readonly WORKFLOW_STEP_COMPLETED: "workflow.step_completed";
+    readonly WORKFLOW_COMPLETED: "workflow.completed";
+    readonly WORKFLOW_FAILED: "workflow.failed";
+};
+/** Default config values */
+export declare const DEFAULTS: {
+    readonly TASK_POLL_INTERVAL_MS: 30000;
+    readonly NOTIFICATION_POLL_INTERVAL_MS: 5000;
+    readonly ORPHAN_REAP_INTERVAL_MS: 300000;
+    readonly STALE_RUN_THRESHOLD_MS: 1800000;
+    readonly STALE_TASK_AGE_MS: 7200000;
+    readonly MAX_CHAIN_DEPTH: 5;
+    readonly MAX_NOTIFICATION_RETRIES: 3;
+    readonly UPDATE_CHECK_INTERVAL_MS: 86400000;
+    readonly RENDER_WATCH_INTERVAL_MS: 30000;
+    readonly DATA_PATH: "./data/bot.db";
+    readonly RENDER_OUTPUT_DIR: "./context";
+    readonly LOG_PATH_TEMPLATE: "./data/runs/{runId}.ndjson";
+    readonly BUDGET_WARN_PERCENT: 80;
+};
+/** Task status values */
+export declare const TASK_STATUSES: readonly ["backlog", "todo", "in_progress", "in_review", "done", "blocked", "cancelled"];
+/** Agent status values */
+export declare const AGENT_STATUSES: readonly ["idle", "running", "paused", "terminated", "error"];
+/** Run status values */
+export declare const RUN_STATUSES: readonly ["queued", "running", "succeeded", "failed", "cancelled"];

package/dist/shared/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @botinabox/shared — Shared types and interfaces for all Bot in a Box packages.
+ * Zero runtime dependencies.
+ */
+export * from "./types/channel.js";
+export * from "./types/provider.js";
+export * from "./types/execution.js";
+export * from "./types/agent.js";
+export * from "./types/task.js";
+export * from "./types/config.js";
+export * from "./types/connector.js";
+export * from "./types/workflow.js";
+export * from "./constants.js";
+export * from "./utils.js";

package/dist/shared/types/agent.d.ts

@@ -0,0 +1,36 @@
+/** Agent types — Story 1.5 / 3.1 */
+export type AgentStatus = "idle" | "running" | "paused" | "terminated" | "error";
+export interface AgentDefinition {
+    slug: string;
+    name: string;
+    role?: string;
+    adapter: string;
+    model?: string;
+    workdir?: string;
+    instructionsFile?: string;
+    maxConcurrentRuns?: number;
+    budgetMonthlyCents?: number;
+    canCreateAgents?: boolean;
+    skipPermissions?: boolean;
+    config?: Record<string, unknown>;
+}
+export interface AgentRecord extends AgentDefinition {
+    id: string;
+    status: AgentStatus;
+    spentMonthlyCents: number;
+    createdAt: string;
+    updatedAt: string;
+    deletedAt?: string;
+}
+export interface AgentFilter {
+    status?: AgentStatus | AgentStatus[];
+    role?: string;
+    adapter?: string;
+}
+export interface BudgetCheck {
+    allowed: boolean;
+    status: "ok" | "warning" | "hard_stop";
+    spentCents: number;
+    limitCents?: number;
+    message?: string;
+}

package/dist/shared/types/channel.d.ts

@@ -0,0 +1,78 @@
+/** Channel adapter types — Story 1.5 / 4.1 */
+import type { ContentBlock } from "./provider.js";
+export type ChatType = "direct" | "group" | "channel";
+export type FormattingMode = "markdown" | "mrkdwn" | "html" | "plain";
+export interface ChannelCapabilities {
+    chatTypes: ChatType[];
+    threads: boolean;
+    reactions: boolean;
+    editing: boolean;
+    media: boolean;
+    polls: boolean;
+    maxTextLength: number;
+    formattingMode: FormattingMode;
+}
+export interface ChannelMeta {
+    displayName: string;
+    icon?: string;
+    homepage?: string;
+}
+export interface InboundMessage {
+    id: string;
+    channel: string;
+    account?: string;
+    from: string;
+    userId?: string;
+    body: string;
+    threadId?: string;
+    replyToId?: string;
+    attachments?: Attachment[];
+    /**
+     * Multimodal content blocks produced by attachment enrichers.
+     * When set, ChatPipeline builds a multimodal user message that passes
+     * these blocks through to the LLM provider alongside `body`.
+     */
+    attachmentBlocks?: ContentBlock[];
+    receivedAt: string;
+    raw?: unknown;
+}
+export type AttachmentMediaType = "image" | "video" | "audio" | "pdf" | "doc" | "excel" | "presentation" | "html" | "link" | "misc";
+export interface Attachment {
+    type: AttachmentMediaType;
+    url?: string;
+    mimeType?: string;
+    filename?: string;
+    size?: number;
+}
+export interface OutboundPayload {
+    text: string;
+    threadId?: string;
+    replyToId?: string;
+    attachments?: Attachment[];
+}
+export interface SendResult {
+    success: boolean;
+    messageId?: string;
+    error?: string;
+}
+export interface HealthStatus {
+    ok: boolean;
+    latencyMs?: number;
+    error?: string;
+}
+export type ChannelConfig = Record<string, unknown>;
+export 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>;
+}

package/dist/shared/types/config.d.ts

@@ -0,0 +1,160 @@
+/** Bot configuration types — Story 1.2 / 1.5 */
+export interface DataConfig {
+    path: string;
+    walMode: boolean;
+    backupDir?: string;
+}
+export interface ModelConfig {
+    aliases: Record<string, string>;
+    default: string;
+    routing: Record<string, string>;
+    fallbackChain: string[];
+    costLimit?: {
+        perRunCents?: number;
+    };
+}
+export interface SecurityConfig {
+    fieldLengthLimits?: Record<string, number>;
+    allowedFilePrefixes?: string[];
+}
+export interface RenderConfig {
+    outputDir: string;
+    watchIntervalMs: number;
+}
+export interface UpdateConfig {
+    policy: "auto-all" | "auto-compatible" | "auto-patch" | "notify" | "manual";
+    checkIntervalMs: number;
+    maintenanceWindow?: {
+        utcHourStart: number;
+        utcHourEnd: number;
+        days?: Array<"mon" | "tue" | "wed" | "thu" | "fri" | "sat" | "sun">;
+    };
+}
+export interface BudgetConfig {
+    globalMonthlyCents?: number;
+    warnPercent: number;
+}
+export interface EntityColumnDef {
+    type: "uuid" | "text" | "integer" | "boolean" | "datetime" | "real";
+    required?: boolean;
+    default?: string | number | boolean;
+    references?: string;
+}
+export interface EntityConfig {
+    columns: Record<string, EntityColumnDef>;
+    relations?: Array<{
+        type: "hasMany" | "manyToMany" | "belongsTo";
+        table: string;
+        through?: string;
+        localKey?: string;
+        remoteKey?: string;
+    }>;
+}
+export interface AgentConfig {
+    slug: string;
+    name: string;
+    role?: string;
+    adapter: string;
+    model?: string;
+    workdir?: string;
+    instructionsFile?: string;
+    maxConcurrentRuns?: number;
+    budgetMonthlyCents?: number;
+    canCreateAgents?: boolean;
+    skipPermissions?: boolean;
+    config?: Record<string, unknown>;
+}
+export interface ExecutionConfig {
+    /** Model for task execution. Default: models.routing.task_execution */
+    model?: string;
+    /** Max tool loop iterations per task. Default: 5 */
+    maxIterations?: number;
+    /** Max tokens per LLM call. Default: 4096 */
+    maxTokens?: number;
+    /** Additional system prompt text appended to agent prompt */
+    systemPromptSuffix?: string;
+}
+export interface ChatConfig {
+    /** System prompt for the conversational responder */
+    systemPrompt?: string;
+    /** Max tokens for context window. Default: 4000 */
+    contextWindowTokens?: number;
+    /** Max recent outbound messages for redundancy check. Default: 10 */
+    redundancyWindow?: number;
+    /** Message dedup window in ms. Default: 300000 (5 min) */
+    dedupWindowMs?: number;
+    /** Max tokens for ack responses. Default: 500 */
+    responseMaxTokens?: number;
+}
+export interface RoutingConfig {
+    /** Routing rules for message triage */
+    rules: Array<{
+        agentSlug: string;
+        keywords?: string[];
+        patterns?: string[];
+        priority?: number;
+    }>;
+    /** Default agent when no rule matches */
+    fallbackAgent: string;
+    /** Use LLM for ambiguous messages. Default: false */
+    llmFallback?: boolean;
+}
+export interface SafetyConfig {
+    /** Circuit breaker failure threshold. Default: 3 */
+    circuitBreakerThreshold?: number;
+    /** Circuit breaker reset timeout ms. Default: 300000 (5 min) */
+    circuitBreakerResetMs?: number;
+    /** Max agent followup chain depth. Default: 5 */
+    maxChainDepth?: number;
+    /** Stale run detection threshold ms. Default: 1800000 (30 min) */
+    staleRunThresholdMs?: number;
+}
+export interface BotConfig {
+    data: DataConfig;
+    channels: Record<string, {
+        enabled: boolean;
+        accounts?: Record<string, unknown>;
+    } & Record<string, unknown>>;
+    connectors?: Record<string, {
+        enabled: boolean;
+        provider: string;
+        accounts?: Record<string, import("./connector.js").ConnectorConfig>;
+    } & Record<string, unknown>>;
+    agents: AgentConfig[];
+    providers: Record<string, {
+        enabled: boolean;
+    } & Record<string, unknown>>;
+    models: ModelConfig;
+    entities: Record<string, EntityConfig>;
+    security: SecurityConfig;
+    render: RenderConfig;
+    updates: UpdateConfig;
+    budget: BudgetConfig;
+    execution?: ExecutionConfig;
+    chat?: ChatConfig;
+    routing?: RoutingConfig;
+    safety?: SafetyConfig;
+    workflows?: Record<string, WorkflowConfigEntry>;
+}
+export interface WorkflowConfigEntry {
+    name: string;
+    description?: string;
+    steps: WorkflowStepConfig[];
+    trigger?: {
+        type: "task_completed" | "event" | "schedule" | "manual";
+        filter?: Record<string, unknown>;
+    };
+}
+export interface WorkflowStepConfig {
+    id: string;
+    name: string;
+    agentSlug?: string;
+    taskTemplate: {
+        title: string;
+        description: string;
+    };
+    dependsOn?: string[];
+    onComplete?: "next" | "parallel" | "end";
+    onFail?: "abort" | "skip" | "retry";
+    retryPolicy?: import("./task.js").RetryPolicy;
+}