botinabox 2.3.2 → 2.4.1

package/dist/index.js

@@ -1991,6 +1991,374 @@ ${extractedTask.description ?? msg.body}`;
   }
 };
 
+// src/core/chat/chat-pipeline-v2.ts
+import { createHash as createHash2 } from "crypto";
+
+// src/core/data/context-builder.ts
+async function buildSystemContext(db, options) {
+  const opts = {
+    users: true,
+    agents: true,
+    projects: true,
+    clients: true,
+    files: true,
+    org: true,
+    ...options
+  };
+  const sections = [];
+  if (opts.org) {
+    const orgs = await db.query("org").catch(() => []);
+    const org = orgs[0];
+    if (org) {
+      sections.push(`## Organization
+${org.name} \u2014 ${org.description ?? ""}`);
+    }
+  }
+  if (opts.users) {
+    const users = await db.query("users").catch(() => []);
+    if (users.length > 0) {
+      const list = users.map((u) => `- ${u.name} (${u.role}${u.email ? `, ${u.email}` : ""})`).join("\n");
+      sections.push(`## Users (${users.length})
+${list}`);
+    }
+  }
+  if (opts.clients) {
+    const clients = await db.query("client").catch(() => []);
+    if (clients.length > 0) {
+      const list = clients.map((c) => `- ${c.name} (${c.status ?? "active"})`).join("\n");
+      sections.push(`## Clients (${clients.length})
+${list}`);
+    }
+  }
+  if (opts.projects) {
+    const projects = await db.query("project").catch(() => []);
+    if (projects.length > 0) {
+      const list = projects.map((p) => `- ${p.name} (${p.status ?? "unknown"})`).join("\n");
+      sections.push(`## Projects (${projects.length})
+${list}`);
+    }
+  }
+  if (opts.files) {
+    const files = await db.query("file").catch(() => []);
+    if (files.length > 0) {
+      const list = files.map(
+        (f) => `- ${f.name}${f.file_path ? ` | path: ${f.file_path}` : ""}${f.access_level ? ` (${f.access_level})` : ""}`
+      ).join("\n");
+      sections.push(`## Files (${files.length})
+${list}`);
+    }
+  }
+  if (opts.agents) {
+    const agents = await db.query("agents").catch(() => []);
+    if (agents.length > 0) {
+      const list = agents.map((a) => `- ${a.name} (${a.role}, ${a.status})`).join("\n");
+      sections.push(`## Agents (${agents.length})
+${list}`);
+    }
+  }
+  return sections.join("\n\n");
+}
+
+// src/core/chat/chat-pipeline-v2.ts
+var DEFAULT_DEDUP_WINDOW_MS2 = 5 * 60 * 1e3;
+var DEFAULT_MAX_ITERATIONS = 5;
+var DEFAULT_MAX_TOKENS = 4096;
+var DEFAULT_MAX_MESSAGES = 50;
+var DEFAULT_MAX_AGE_DAYS = 7;
+var ChatPipelineV2 = class {
+  constructor(db, hooks, config) {
+    this.db = db;
+    this.hooks = hooks;
+    this.config = config;
+    this.channel = config.channel ?? "slack";
+    this.messageFilter = config.messageFilter;
+    this.dedupWindowMs = config.dedupWindowMs ?? DEFAULT_DEDUP_WINDOW_MS2;
+    this.toolDefs = (config.tools ?? []).map((t) => t.definition);
+    this.toolHandlers = new Map(
+      (config.tools ?? []).map((t) => [t.definition.name, t.handler])
+    );
+    this.messageStore = new MessageStore(db, hooks);
+    const simpleLlmCall = async (params) => {
+      const result = await config.llmCall({
+        model: params.model ?? config.model ?? "fast",
+        messages: params.messages.map((m) => ({
+          role: m.role,
+          content: typeof m.content === "string" ? m.content : m.content.map((b) => "text" in b ? b.text : "").join("")
+        })),
+        system: params.system,
+        maxTokens: params.maxTokens ?? 500
+      });
+      const text = result.content.filter((b) => b.type === "text").map((b) => b.text ?? "").join("");
+      return { content: text };
+    };
+    this.responder = new ChatResponder(db, hooks, this.messageStore, {
+      llmCall: simpleLlmCall,
+      model: config.model ?? "fast",
+      systemPrompt: config.systemPrompt
+    });
+    this.interpreter = new MessageInterpreter(db, hooks, {
+      llmCall: simpleLlmCall,
+      model: "fast",
+      extractors: config.extractors
+    });
+    this.registerHandlers();
+  }
+  db;
+  hooks;
+  config;
+  messageStore;
+  responder;
+  interpreter;
+  channel;
+  messageFilter;
+  dedupWindowMs;
+  threadChannelMap = /* @__PURE__ */ new Map();
+  toolDefs;
+  toolHandlers;
+  /**
+   * Resolve the channel ID for a thread (for response delivery).
+   */
+  async resolveChannel(threadId, taskId) {
+    if (taskId) {
+      const mappings = await this.db.query("thread_task_map", { where: { task_id: taskId } });
+      if (mappings.length > 0) return mappings[0].channel_id;
+    }
+    if (threadId) {
+      const mappings = await this.db.query("thread_task_map", { where: { thread_ts: threadId } });
+      if (mappings.length > 0) return mappings[0].channel_id;
+    }
+    return this.threadChannelMap.get(threadId);
+  }
+  registerHandlers() {
+    this.hooks.register("message.inbound", async (ctx) => {
+      const msg = ctx;
+      if (msg.channel !== this.channel) return;
+      if (this.messageFilter && !this.messageFilter(msg)) return;
+      if (await this.isDuplicate(msg)) return;
+      const channelId = msg.account ?? "";
+      const threadTs = channelId || msg.threadId || msg.id;
+      if (threadTs && channelId) {
+        this.threadChannelMap.set(threadTs, channelId);
+      }
+      const msgWithThread = { ...msg, threadId: threadTs };
+      const { messageId } = await this.messageStore.storeInbound(msgWithThread);
+      await this.hooks.emit("typing.start", { channel: this.channel, threadId: threadTs });
+      try {
+        const history = await this.buildHistory(channelId);
+        let systemPrompt = this.config.systemPrompt;
+        if (this.config.includeSystemContext !== false) {
+          const ctx2 = await buildSystemContext(this.db, this.config.systemContextOptions);
+          if (ctx2) systemPrompt += `
+
+${ctx2}`;
+        }
+        const { text, tasksDispatched } = await this.think(
+          systemPrompt,
+          history,
+          msg.body,
+          threadTs,
+          channelId
+        );
+        await this.hooks.emit("typing.stop", { channel: this.channel, threadId: threadTs });
+        if (text) {
+          await this.responder.sendResponse({
+            text,
+            channel: this.channel,
+            threadId: threadTs,
+            source: "primary",
+            skipFilter: true,
+            skipRedundancyCheck: true
+          });
+        }
+        void this.extractAsync(messageId);
+      } catch (err) {
+        await this.hooks.emit("typing.stop", { channel: this.channel, threadId: threadTs });
+        const errMsg = err instanceof Error ? err.message : String(err);
+        console.error("[ChatPipelineV2] Pipeline error:", errMsg);
+        await this.hooks.emit("pipeline.error", {
+          messageId,
+          error: errMsg
+        });
+      }
+    });
+    this.hooks.register("run.completed", async (ctx) => {
+      const taskId = ctx.taskId;
+      if (!taskId) return;
+      const task = await this.db.get("tasks", { id: taskId });
+      const output = task?.result;
+      if (!output) return;
+      const mappings = await this.db.query("thread_task_map", { where: { task_id: taskId } });
+      if (mappings.length === 0) return;
+      const threadId = mappings[0].thread_ts;
+      await this.responder.sendResponse({
+        text: output,
+        channel: this.channel,
+        threadId,
+        agentId: ctx.agentId,
+        taskId,
+        source: "agent",
+        skipFilter: true,
+        skipRedundancyCheck: true
+      });
+    }, { priority: 90 });
+  }
+  /**
+   * Primary agent tool loop — adapted from ExecutionEngine pattern.
+   */
+  async think(systemPrompt, history, currentMessage, threadTs, channelId) {
+    const model = this.config.model ?? "claude-sonnet-4-6";
+    const maxIterations = this.config.maxIterations ?? DEFAULT_MAX_ITERATIONS;
+    const maxTokens = this.config.maxTokens ?? DEFAULT_MAX_TOKENS;
+    const tasksDispatched = [];
+    const messages = [
+      ...history,
+      { role: "user", content: currentMessage }
+    ];
+    let finalText = "";
+    for (let i = 0; i < maxIterations; i++) {
+      const params = {
+        model,
+        messages,
+        system: systemPrompt,
+        maxTokens
+      };
+      if (this.toolDefs.length > 0) {
+        params.tools = this.toolDefs;
+        params.tool_choice = { type: "auto" };
+      }
+      const response = await this.config.llmCall(params);
+      const textBlocks = response.content.filter((b) => b.type === "text").map((b) => b.text ?? "");
+      if (textBlocks.length > 0) finalText += textBlocks.join("");
+      if (response.stop_reason !== "tool_use") break;
+      const toolUseBlocks = response.content.filter((b) => b.type === "tool_use");
+      const toolResults = [];
+      for (const toolUse of toolUseBlocks) {
+        const handler = this.toolHandlers.get(toolUse.name);
+        if (handler) {
+          try {
+            const toolCtx = {
+              taskId: "",
+              agentId: "primary",
+              hooks: this.hooks,
+              db: this.db,
+              resolveFilePath: this.config.resolveFilePath
+            };
+            const result = await handler(
+              toolUse.input,
+              toolCtx
+            );
+            if (toolUse.name === "dispatch_task" && result.includes("ID:")) {
+              const idMatch = result.match(/ID:\s*([a-f0-9-]+)/);
+              if (idMatch) {
+                const taskId = idMatch[1];
+                tasksDispatched.push(taskId);
+                try {
+                  const existing = await this.db.query("thread_task_map", {
+                    where: { thread_ts: threadTs, channel_id: channelId }
+                  });
+                  if (existing.length > 0) {
+                    await this.db.update("thread_task_map", { id: existing[0].id }, { task_id: taskId });
+                  } else {
+                    await this.db.insert("thread_task_map", {
+                      thread_ts: threadTs,
+                      channel_id: channelId,
+                      task_id: taskId
+                    });
+                  }
+                } catch {
+                }
+              }
+            }
+            toolResults.push({
+              type: "tool_result",
+              id: toolUse.id,
+              text: result
+            });
+          } catch (err) {
+            toolResults.push({
+              type: "tool_result",
+              id: toolUse.id,
+              text: `Error: ${err instanceof Error ? err.message : String(err)}`
+            });
+          }
+        }
+      }
+      messages.push({ role: "assistant", content: response.content });
+      messages.push({ role: "user", content: toolResults });
+    }
+    return { text: finalText, tasksDispatched };
+  }
+  /**
+   * Build conversation history from channel messages.
+   * Includes BOTH user and assistant messages (unlike v1 which excluded bot messages).
+   */
+  async buildHistory(channelId) {
+    const maxMessages = this.config.history?.maxMessages ?? DEFAULT_MAX_MESSAGES;
+    const maxAgeDays = this.config.history?.maxAgeDays ?? DEFAULT_MAX_AGE_DAYS;
+    const includeAssistant = this.config.history?.includeAssistant !== false;
+    const cutoff = new Date(Date.now() - maxAgeDays * 24 * 60 * 60 * 1e3).toISOString();
+    let rows;
+    try {
+      rows = await this.db.query("messages", {
+        where: { channel: this.channel },
+        orderBy: "created_at",
+        orderDir: "desc",
+        limit: maxMessages
+      });
+      rows.reverse();
+      rows = rows.filter((r) => {
+        const ts = r.created_at;
+        return !ts || ts >= cutoff;
+      });
+    } catch {
+      return [];
+    }
+    const messages = [];
+    const maxChars = 16e3;
+    let charCount = 0;
+    for (const row of rows) {
+      const body = row.body ?? "";
+      const direction = row.direction;
+      if (!includeAssistant && direction !== "inbound") continue;
+      if (charCount + body.length > maxChars) break;
+      messages.push({
+        role: direction === "inbound" ? "user" : "assistant",
+        content: body
+      });
+      charCount += body.length;
+    }
+    return messages;
+  }
+  /**
+   * Dedup check (same as v1).
+   */
+  async isDuplicate(msg) {
+    const hash = createHash2("sha256").update(`${msg.from}:${msg.body}`).digest("hex");
+    const cutoff = new Date(Date.now() - this.dedupWindowMs).toISOString();
+    const recent = await this.db.query("message_dedup", { where: { content_hash: hash } });
+    if (recent.some((r) => r.created_at > cutoff)) return true;
+    await this.db.insert("message_dedup", {
+      content_hash: hash,
+      channel_id: msg.account ?? "",
+      created_at: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    return false;
+  }
+  /**
+   * Async memory extraction (non-blocking, non-fatal).
+   */
+  async extractAsync(messageId) {
+    try {
+      await this.interpreter.interpret(messageId);
+    } catch (err) {
+      await this.hooks.emit("interpretation.error", {
+        messageId,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+};
+
 // src/core/chat/formatter.ts
 function formatText(text, mode) {
   switch (mode) {
@@ -3504,71 +3872,6 @@ ${c.instructions}` : null,
   }
 }
 
-// src/core/data/context-builder.ts
-async function buildSystemContext(db, options) {
-  const opts = {
-    users: true,
-    agents: true,
-    projects: true,
-    clients: true,
-    files: true,
-    org: true,
-    ...options
-  };
-  const sections = [];
-  if (opts.org) {
-    const orgs = await db.query("org").catch(() => []);
-    const org = orgs[0];
-    if (org) {
-      sections.push(`## Organization
-${org.name} \u2014 ${org.description ?? ""}`);
-    }
-  }
-  if (opts.users) {
-    const users = await db.query("users").catch(() => []);
-    if (users.length > 0) {
-      const list = users.map((u) => `- ${u.name} (${u.role}${u.email ? `, ${u.email}` : ""})`).join("\n");
-      sections.push(`## Users (${users.length})
-${list}`);
-    }
-  }
-  if (opts.clients) {
-    const clients = await db.query("client").catch(() => []);
-    if (clients.length > 0) {
-      const list = clients.map((c) => `- ${c.name} (${c.status ?? "active"})`).join("\n");
-      sections.push(`## Clients (${clients.length})
-${list}`);
-    }
-  }
-  if (opts.projects) {
-    const projects = await db.query("project").catch(() => []);
-    if (projects.length > 0) {
-      const list = projects.map((p) => `- ${p.name} (${p.status ?? "unknown"})`).join("\n");
-      sections.push(`## Projects (${projects.length})
-${list}`);
-    }
-  }
-  if (opts.files) {
-    const files = await db.query("file").catch(() => []);
-    if (files.length > 0) {
-      const list = files.map(
-        (f) => `- ${f.name}${f.file_path ? ` | path: ${f.file_path}` : ""}${f.access_level ? ` (${f.access_level})` : ""}`
-      ).join("\n");
-      sections.push(`## Files (${files.length})
-${list}`);
-    }
-  }
-  if (opts.agents) {
-    const agents = await db.query("agents").catch(() => []);
-    if (agents.length > 0) {
-      const list = agents.map((a) => `- ${a.name} (${a.role}, ${a.status})`).join("\n");
-      sections.push(`## Agents (${agents.length})
-${list}`);
-    }
-  }
-  return sections.join("\n\n");
-}
-
 // src/core/security/sanitizer.ts
 import { Buffer as Buffer2 } from "buffer";
 var DEFAULT_FIELD_LIMIT = 65535;
@@ -6751,6 +7054,30 @@ var nativeTools = [
   createAgentTool,
   createProjectTool
 ];
+var coordinatorTools = [
+  // Task management
+  dispatchTaskTool,
+  cancelTaskTool,
+  reassignTaskTool,
+  // Progress monitoring
+  getTaskStatusTool,
+  getActiveTasksTool,
+  // Agent management + awareness
+  listAgentsTool,
+  getAgentStatusTool,
+  getAgentDetailTool,
+  createAgentTool,
+  // Communication (coordinator is the user-facing gateway)
+  sendMessageTool,
+  addTaskCommentTool,
+  // Conversational context
+  readConversationTool,
+  searchConversationTool,
+  // Awareness (for routing decisions, not for doing work)
+  listFilesTool,
+  listProjectsTool,
+  sendFileTool
+];
 
 // src/core/orchestrator/user-registry.ts
 import { v4 as uuidv4 } from "uuid";
@@ -7089,6 +7416,7 @@ export {
   ChannelRegistry,
   ChannelRegistryError,
   ChatPipeline,
+  ChatPipelineV2,
   ChatResponder,
   ChatSessionManager,
   CircuitBreaker,
@@ -7147,6 +7475,7 @@ export {
   chunkText,
   classifyUpdate,
   compareVersions,
+  coordinatorTools,
   createAgentTool,
   createConfigRevision,
   createDefaultLLMCall,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "botinabox",
-  "version": "2.3.2",
+  "version": "2.4.1",
   "description": "Bot in a Box — framework for building multi-agent bots",
   "type": "module",
   "main": "./dist/index.js",
@@ -53,8 +53,7 @@
     "build": "tsup",
     "test": "vitest run",
     "typecheck": "tsc --noEmit",
-    "check-docs": "bash scripts/check-docs.sh",
-    "prepublishOnly": "npm run build && npm run typecheck && npm test && npm run check-docs"
+    "prepublishOnly": "npm run build && npm run typecheck && npm test"
   },
   "dependencies": {
     "@types/uuid": "^10.0.0",