botinabox 1.8.2 → 1.8.4

package/dist/core/update/types.d.ts

@@ -0,0 +1,11 @@
+export interface PackageUpdate {
+    name: string;
+    installedVersion: string;
+    latestVersion: string;
+    updateType: 'patch' | 'minor' | 'major';
+}
+export interface UpdateManifest {
+    checkedAt: string;
+    packages: PackageUpdate[];
+    hasUpdates: boolean;
+}

package/dist/core/update/types.js

@@ -0,0 +1 @@
+export {};

package/dist/core/update/update-checker.d.ts

@@ -0,0 +1,11 @@
+import type { UpdateManifest } from './types.js';
+export declare class UpdateChecker {
+    private nodeModulesPath;
+    private opts?;
+    private readonly fetchFn;
+    constructor(nodeModulesPath: string, opts?: {
+        fetch?: typeof globalThis.fetch;
+    } | undefined);
+    getInstalledPackages(): string[];
+    check(packageNames?: string[]): Promise<UpdateManifest>;
+}

package/dist/core/update/update-checker.js

@@ -0,0 +1,63 @@
+import { readFileSync, readdirSync } from 'fs';
+import { join } from 'path';
+import { classifyUpdate, compareVersions } from './version-utils.js';
+export class UpdateChecker {
+    nodeModulesPath;
+    opts;
+    fetchFn;
+    constructor(nodeModulesPath, opts) {
+        this.nodeModulesPath = nodeModulesPath;
+        this.opts = opts;
+        this.fetchFn = opts?.fetch ?? globalThis.fetch;
+    }
+    getInstalledPackages() {
+        try {
+            const botinaboxPath = join(this.nodeModulesPath, '@botinabox');
+            const entries = readdirSync(botinaboxPath, { withFileTypes: true });
+            return entries
+                .filter((e) => e.isDirectory())
+                .map((e) => e.name);
+        }
+        catch {
+            return [];
+        }
+    }
+    async check(packageNames) {
+        const installed = packageNames ?? this.getInstalledPackages();
+        const updates = [];
+        for (const pkg of installed) {
+            try {
+                const pkgJsonPath = join(this.nodeModulesPath, '@botinabox', pkg, 'package.json');
+                const pkgJson = JSON.parse(readFileSync(pkgJsonPath, 'utf-8'));
+                const installedVersion = pkgJson.version ?? '0.0.0';
+                const response = await this.fetchFn(`https://registry.npmjs.org/@botinabox/${pkg}`);
+                if (!response.ok)
+                    continue;
+                const data = await response.json();
+                const latestVersion = data['dist-tags']?.['latest'];
+                if (!latestVersion)
+                    continue;
+                if (compareVersions(latestVersion, installedVersion) > 0) {
+                    const updateType = classifyUpdate(installedVersion, latestVersion);
+                    if (updateType !== 'none') {
+                        updates.push({
+                            name: `@botinabox/${pkg}`,
+                            installedVersion,
+                            latestVersion,
+                            updateType,
+                        });
+                    }
+                }
+            }
+            catch {
+                // Gracefully skip on error
+                continue;
+            }
+        }
+        return {
+            checkedAt: new Date().toISOString(),
+            packages: updates,
+            hasUpdates: updates.length > 0,
+        };
+    }
+}

package/dist/core/update/update-manager.d.ts

@@ -0,0 +1,25 @@
+import type { DataStore } from '../data/data-store.js';
+import type { HookBus } from '../hooks/hook-bus.js';
+import type { PackageUpdate, UpdateManifest } from './types.js';
+import { UpdateChecker } from './update-checker.js';
+type UpdatePolicy = 'auto-all' | 'auto-compatible' | 'auto-patch' | 'notify' | 'manual';
+export declare class UpdateManager {
+    private checker;
+    private db;
+    private hooks;
+    private opts?;
+    private backupManager;
+    constructor(checker: UpdateChecker, db: DataStore, hooks: HookBus, opts?: {
+        projectRoot?: string;
+        policy?: UpdatePolicy;
+        maintenanceWindow?: {
+            utcHourStart: number;
+            utcHourEnd: number;
+        };
+    } | undefined);
+    checkAndNotify(): Promise<UpdateManifest>;
+    applyUpdates(updates: PackageUpdate[]): Promise<void>;
+    isInMaintenanceWindow(): boolean;
+    filterByPolicy(updates: PackageUpdate[]): PackageUpdate[];
+}
+export {};

package/dist/core/update/update-manager.js

@@ -0,0 +1,101 @@
+import { execSync } from 'child_process';
+import { BackupManager } from './backup-manager.js';
+export class UpdateManager {
+    checker;
+    db;
+    hooks;
+    opts;
+    backupManager;
+    constructor(checker, db, hooks, opts) {
+        this.checker = checker;
+        this.db = db;
+        this.hooks = hooks;
+        this.opts = opts;
+        this.backupManager = new BackupManager(opts?.projectRoot ?? process.cwd());
+    }
+    async checkAndNotify() {
+        const manifest = await this.checker.check();
+        if (manifest.hasUpdates) {
+            await this.hooks.emit('update.available', { manifest });
+        }
+        return manifest;
+    }
+    async applyUpdates(updates) {
+        const filtered = this.filterByPolicy(updates);
+        if (filtered.length === 0)
+            return;
+        if (!this.isInMaintenanceWindow()) {
+            await this.hooks.emit('update.deferred', { reason: 'outside maintenance window' });
+            return;
+        }
+        let backupPath;
+        const historyIds = [];
+        try {
+            backupPath = await this.backupManager.backup();
+            for (const update of filtered) {
+                const row = await this.db.insert('update_history', {
+                    from_version: update.installedVersion,
+                    to_version: update.latestVersion,
+                    status: 'pending',
+                });
+                historyIds.push(row['id']);
+            }
+            execSync('pnpm install', {
+                cwd: this.opts?.projectRoot ?? process.cwd(),
+                stdio: 'ignore',
+            });
+            for (const id of historyIds) {
+                await this.db.update('update_history', { id }, { status: 'succeeded' });
+            }
+            await this.backupManager.cleanup(backupPath);
+            await this.hooks.emit('update.completed', { updates: filtered });
+        }
+        catch (err) {
+            for (const id of historyIds) {
+                await this.db.update('update_history', { id }, {
+                    status: 'failed',
+                    migration_log: String(err),
+                });
+            }
+            if (backupPath) {
+                try {
+                    await this.backupManager.restore(backupPath);
+                    await this.backupManager.cleanup(backupPath);
+                }
+                catch {
+                    // best effort restore
+                }
+            }
+            await this.hooks.emit('update.failed', { updates: filtered, error: String(err) });
+        }
+    }
+    isInMaintenanceWindow() {
+        const window = this.opts?.maintenanceWindow;
+        if (!window)
+            return true; // No window configured = always allowed
+        const nowHour = new Date().getUTCHours();
+        const { utcHourStart, utcHourEnd } = window;
+        if (utcHourStart <= utcHourEnd) {
+            return nowHour >= utcHourStart && nowHour < utcHourEnd;
+        }
+        else {
+            // Wraps midnight
+            return nowHour >= utcHourStart || nowHour < utcHourEnd;
+        }
+    }
+    filterByPolicy(updates) {
+        const policy = this.opts?.policy ?? 'notify';
+        switch (policy) {
+            case 'auto-all':
+                return updates;
+            case 'auto-compatible':
+                return updates.filter((u) => u.updateType !== 'major');
+            case 'auto-patch':
+                return updates.filter((u) => u.updateType === 'patch');
+            case 'notify':
+            case 'manual':
+            default:
+                return [];
+        }
+    }
+}

package/dist/core/update/version-utils.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Simple semver utilities — no external deps.
+ */
+export declare function parseVersion(v: string): [number, number, number];
+export declare function compareVersions(a: string, b: string): -1 | 0 | 1;
+export declare function classifyUpdate(from: string, to: string): 'patch' | 'minor' | 'major' | 'none';

package/dist/core/update/version-utils.js

@@ -0,0 +1,34 @@
+/**
+ * Simple semver utilities — no external deps.
+ */
+export function parseVersion(v) {
+    // Strip leading 'v' and any pre-release suffix
+    const cleaned = v.replace(/^v/, '').split('-')[0] ?? v;
+    const parts = cleaned.split('.');
+    const major = parseInt(parts[0] ?? '0', 10) || 0;
+    const minor = parseInt(parts[1] ?? '0', 10) || 0;
+    const patch = parseInt(parts[2] ?? '0', 10) || 0;
+    return [major, minor, patch];
+}
+export function compareVersions(a, b) {
+    const [aMaj, aMin, aPat] = parseVersion(a);
+    const [bMaj, bMin, bPat] = parseVersion(b);
+    if (aMaj !== bMaj)
+        return aMaj < bMaj ? -1 : 1;
+    if (aMin !== bMin)
+        return aMin < bMin ? -1 : 1;
+    if (aPat !== bPat)
+        return aPat < bPat ? -1 : 1;
+    return 0;
+}
+export function classifyUpdate(from, to) {
+    const [fMaj, fMin] = parseVersion(from);
+    const [tMaj, tMin] = parseVersion(to);
+    if (compareVersions(from, to) === 0)
+        return 'none';
+    if (tMaj !== fMaj)
+        return 'major';
+    if (tMin !== fMin)
+        return 'minor';
+    return 'patch';
+}

package/dist/index.d.ts

@@ -1343,6 +1343,8 @@ declare class ChatPipeline {
     private readonly tasks;
     private readonly wakeups;
     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).
@@ -1358,8 +1360,15 @@ declare class ChatPipeline {
     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.
      */

package/dist/index.js

@@ -1470,11 +1470,10 @@ Return a JSON object with these fields:
 }
 
 Rules:
-- "tasks": actionable requests the user wants done. NOT conversational messages.
+- "tasks": ALWAYS create at least one task from every message. The task title should capture the user's intent. If the message is just a greeting or acknowledgment, create a task with title "Respond to greeting" or similar. Tasks are cheap \u2014 the execution layer decides whether action is needed.
 - "memories": information, notes, random thoughts to remember. Parse thematically \u2014 one message can have multiple memories.
 - "user_context": personality traits, preferences, or learnings about the user.
-- "is_task_request": true if the message contains at least one actionable task.
-- If the message is just a greeting or conversation, return empty arrays and is_task_request: false.
+- "is_task_request": ALWAYS true. Every message gets a task. The execution layer handles triage.
 - Return ONLY valid JSON, no markdown or explanation.`;
 var MessageInterpreter = class {
   constructor(db, hooks, config) {
@@ -1577,7 +1576,8 @@ var MessageInterpreter = class {
         system: INTERPRET_SYSTEM,
         maxTokens: 1e3
       });
-      const parsed = JSON.parse(result.content);
+      const raw = result.content.replace(/^```(?:json)?\s*\n?/i, "").replace(/\n?```\s*$/i, "").trim();
+      const parsed = JSON.parse(raw);
       return {
         tasks: (parsed.tasks ?? []).map((t) => ({
           title: t.title,
@@ -1654,6 +1654,8 @@ var ChatPipeline = class {
   // In-memory thread → channel mapping for response routing
   // (before thread_task_map exists)
   threadChannelMap = /* @__PURE__ */ new Map();
+  /** Last dispatch promise — exposed for testing. */
+  lastDispatch = Promise.resolve();
   /**
    * Resolve the Slack channel ID for a thread (for response delivery).
    */
@@ -1703,7 +1705,9 @@ ${historyContext}` : void 0
         skipFilter: true,
         skipRedundancyCheck: true
       });
-      void this.interpretAndDispatch(messageId, msg, threadTs, channelId);
+      const dispatchPromise = this.interpretAndDispatch(messageId, msg, threadTs, channelId);
+      this.lastDispatch = dispatchPromise;
+      void dispatchPromise;
     });
     this.hooks.register("run.completed", async (ctx) => {
       const taskId = ctx.taskId;
@@ -1722,7 +1726,9 @@ ${historyContext}` : void 0
         threadId: mapping.thread_ts,
         agentId: ctx.agentId,
         taskId,
-        source: "agent"
+        source: "agent",
+        skipRedundancyCheck: true
+        // Task results are always delivered
       });
     }, { priority: 90 });
   }
@@ -1746,28 +1752,94 @@ ${historyContext}` : void 0
   }
   /**
    * 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.
    */
   async interpretAndDispatch(messageId, msg, threadTs, channelId) {
+    await this.guaranteedTaskDispatch(msg, threadTs, channelId);
     try {
       const result = await this.interpreter.interpret(messageId);
-      if (result.tasks.length > 0 || result.memories.length > 0) {
-        const summary = this.buildSummary(result);
-        await this.responder.sendResponse({
-          text: summary,
-          channel: this.channel,
-          threadId: threadTs,
-          source: "interpretation"
-        });
-      }
-      if (result.isTaskRequest && result.tasks.length > 0) {
-        await this.dispatchTasks(result, msg, threadTs, channelId);
+      if (result.memories.length > 0 || result.userContext.length > 0) {
+        try {
+          const parts = [];
+          if (result.memories.length > 0) {
+            parts.push(`Noted ${result.memories.length} thing${result.memories.length > 1 ? "s" : ""} to remember.`);
+          }
+          if (parts.length > 0) {
+            await this.responder.sendResponse({
+              text: parts.join(" "),
+              channel: this.channel,
+              threadId: threadTs,
+              source: "interpretation"
+            });
+          }
+        } catch {
+        }
       }
     } catch (err) {
+      const errMsg = err instanceof Error ? err.message : String(err);
       await this.hooks.emit("interpretation.error", {
         messageId,
-        error: err instanceof Error ? err.message : String(err)
+        error: errMsg
+      });
+    }
+  }
+  /**
+   * Programmatic task creation — guaranteed, no LLM dependency.
+   */
+  async guaranteedTaskDispatch(msg, threadTs, channelId) {
+    const { agentSlug: targetSlug } = await this.router.route(msg);
+    if (!targetSlug) return;
+    const agents = await this.db.query("agents", { where: { slug: targetSlug } });
+    const targetAgent = agents[0];
+    if (!targetAgent) return;
+    const handlerAgentId = targetAgent.id;
+    if (threadTs) {
+      const existing = await this.db.query("thread_task_map", {
+        where: { thread_ts: threadTs, channel_id: channelId }
+      });
+      if (existing.length > 0) {
+        const taskId2 = existing[0].task_id;
+        const task = await this.tasks.get(taskId2);
+        if (task && task.status !== "done" && task.status !== "cancelled") {
+          const updatedDesc = `${task.description ?? ""}
+
+---
+**Follow-up (${(/* @__PURE__ */ new Date()).toISOString()}):**
+${msg.body}`;
+          await this.tasks.update(taskId2, { description: updatedDesc });
+          await this.wakeups.enqueue(handlerAgentId, "chat_followup", { taskId: taskId2 });
+          return;
+        }
+      }
+    }
+    const description = `## Chat Message
+
+**Channel:** ${channelId}
+**Thread:** ${threadTs}
+**From:** ${msg.from}
+**Time:** ${msg.receivedAt}
+
+---
+
+${msg.body}`;
+    const taskId = randomUUID();
+    if (threadTs) {
+      await this.db.insert("thread_task_map", {
+        thread_ts: threadTs,
+        channel_id: channelId,
+        task_id: taskId
       });
     }
+    await this.tasks.create({
+      id: taskId,
+      title: msg.body.slice(0, 120),
+      description,
+      assignee_id: handlerAgentId,
+      priority: 5
+    });
+    await this.wakeups.enqueue(handlerAgentId, "chat_dispatch", { taskId });
   }
   /**
    * Route and dispatch extracted tasks.

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/models.js

@@ -0,0 +1,29 @@
+export const MODELS = [
+    {
+        id: 'claude-opus-4-6',
+        displayName: 'Claude Opus 4.6',
+        contextWindow: 200000,
+        maxOutputTokens: 32000,
+        inputCostPerMToken: 15,
+        outputCostPerMToken: 75,
+        capabilities: ['chat', 'tools', 'vision', 'streaming'],
+    },
+    {
+        id: 'claude-sonnet-4-6',
+        displayName: 'Claude Sonnet 4.6',
+        contextWindow: 200000,
+        maxOutputTokens: 16000,
+        inputCostPerMToken: 3,
+        outputCostPerMToken: 15,
+        capabilities: ['chat', 'tools', 'vision', 'streaming'],
+    },
+    {
+        id: 'claude-haiku-4-5',
+        displayName: 'Claude Haiku 4.5',
+        contextWindow: 200000,
+        maxOutputTokens: 8192,
+        inputCostPerMToken: 0.8,
+        outputCostPerMToken: 4,
+        capabilities: ['chat', 'tools', 'vision', 'streaming'],
+    },
+];

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/provider.js

@@ -0,0 +1,119 @@
+import Anthropic from '@anthropic-ai/sdk';
+import { MODELS } from './models.js';
+import { convertTools } from './tool-converter.js';
+export class AnthropicProvider {
+    id = 'anthropic';
+    displayName = 'Anthropic';
+    models = MODELS;
+    client;
+    constructor({ apiKey }) {
+        this.client = new Anthropic({ apiKey });
+    }
+    serializeTools(tools) {
+        return convertTools(tools);
+    }
+    async chat(params) {
+        const { messages, system, tools, maxTokens, temperature, model, abortSignal } = params;
+        const anthropicMessages = messages
+            .filter((m) => m.role !== 'system')
+            .map((m) => ({
+            role: m.role,
+            content: typeof m.content === 'string' ? m.content : m.content,
+        }));
+        const response = await this.client.messages.create({
+            model,
+            max_tokens: maxTokens ?? 4096,
+            messages: anthropicMessages,
+            ...(system ? { system } : {}),
+            ...(tools && tools.length > 0 ? { tools: convertTools(tools) } : {}),
+            ...(temperature !== undefined ? { temperature } : {}),
+        }, { signal: abortSignal });
+        let content = '';
+        const toolUses = [];
+        for (const block of response.content) {
+            if (block.type === 'text') {
+                content += block.text;
+            }
+            else if (block.type === 'tool_use') {
+                toolUses.push({
+                    id: block.id,
+                    name: block.name,
+                    input: block.input,
+                });
+            }
+        }
+        const stopReason = mapStopReason(response.stop_reason);
+        return {
+            content,
+            toolUses: toolUses.length > 0 ? toolUses : undefined,
+            usage: {
+                inputTokens: response.usage.input_tokens,
+                outputTokens: response.usage.output_tokens,
+            },
+            model: response.model,
+            stopReason,
+        };
+    }
+    async *chatStream(params) {
+        const { messages, system, tools, maxTokens, temperature, model, abortSignal } = params;
+        const anthropicMessages = messages
+            .filter((m) => m.role !== 'system')
+            .map((m) => ({
+            role: m.role,
+            content: typeof m.content === 'string' ? m.content : m.content,
+        }));
+        const stream = this.client.messages.stream({
+            model,
+            max_tokens: maxTokens ?? 4096,
+            messages: anthropicMessages,
+            ...(system ? { system } : {}),
+            ...(tools && tools.length > 0 ? { tools: convertTools(tools) } : {}),
+            ...(temperature !== undefined ? { temperature } : {}),
+        }, { signal: abortSignal });
+        for await (const event of stream) {
+            if (event.type === 'content_block_delta' &&
+                event.delta.type === 'text_delta') {
+                yield event.delta.text;
+            }
+        }
+        const finalMessage = await stream.finalMessage();
+        let content = '';
+        const toolUses = [];
+        for (const block of finalMessage.content) {
+            if (block.type === 'text') {
+                content += block.text;
+            }
+            else if (block.type === 'tool_use') {
+                toolUses.push({
+                    id: block.id,
+                    name: block.name,
+                    input: block.input,
+                });
+            }
+        }
+        return {
+            content,
+            toolUses: toolUses.length > 0 ? toolUses : undefined,
+            usage: {
+                inputTokens: finalMessage.usage.input_tokens,
+                outputTokens: finalMessage.usage.output_tokens,
+            },
+            model: finalMessage.model,
+            stopReason: mapStopReason(finalMessage.stop_reason),
+        };
+    }
+}
+function mapStopReason(reason) {
+    switch (reason) {
+        case 'end_turn':
+            return 'end_turn';
+        case 'tool_use':
+            return 'tool_use';
+        case 'max_tokens':
+            return 'max_tokens';
+        case 'stop_sequence':
+            return 'stop_sequence';
+        default:
+            return 'end_turn';
+    }
+}

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/anthropic/tool-converter.js

@@ -0,0 +1,7 @@
+export function convertTools(tools) {
+    return tools.map((tool) => ({
+        name: tool.name,
+        description: tool.description,
+        input_schema: { type: 'object', ...tool.parameters },
+    }));
+}

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>;
+}