botinabox 2.5.1 → 2.5.3

package/bin/botinabox.mjs

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

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

@@ -1,5 +1,5 @@
 import { C as ChannelAdapter, c as ChannelMeta, a as ChannelCapabilities, I as InboundMessage, b as ChannelConfig, H as HealthStatus, O as OutboundPayload, S as SendResult } from '../../channel-06G0vbIn.js';
-import { H as HookBus, c as ChatPipeline } from '../../chat-pipeline-BWrtVqEP.js';
+import { H as HookBus, c as ChatPipeline } from '../../chat-pipeline-DuNX5WoL.js';
 import 'better-sqlite3';
 import '../../provider-DLGUfnNx.js';
 

package/dist/{chat-pipeline-BWrtVqEP.d.ts → chat-pipeline-DuNX5WoL.d.ts}

@@ -584,6 +584,8 @@ interface ChatPipelineConfig {
     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>;
@@ -608,6 +610,7 @@ declare class ChatPipeline {
     private readonly dedupWindowMs;
     private readonly tasks;
     private readonly wakeups;
+    private readonly skipAck;
     private readonly threadChannelMap;
     /** Last dispatch promise — exposed for testing. */
     lastDispatch: Promise<void>;

package/dist/chunk-7AGWGYZC.js

@@ -0,0 +1,419 @@
+// src/connectors/google/oauth.ts
+var _google;
+async function getGoogle() {
+  if (!_google) {
+    try {
+      const mod = await import("googleapis");
+      _google = mod.google;
+    } catch {
+      throw new Error(
+        "googleapis is required for Google connectors. Install it: npm install googleapis"
+      );
+    }
+  }
+  return _google;
+}
+async function createOAuth2Client(config) {
+  const google = await getGoogle();
+  return new google.auth.OAuth2(
+    config.clientId,
+    config.clientSecret,
+    config.redirectUri
+  );
+}
+function getAuthUrl(client, scopes) {
+  return client.generateAuthUrl({
+    access_type: "offline",
+    prompt: "consent",
+    scope: scopes
+  });
+}
+async function exchangeCode(client, code) {
+  const { tokens } = await client.getToken(code);
+  return tokens;
+}
+async function createServiceAccountClient(config, scopes) {
+  const google = await getGoogle();
+  const auth = new google.auth.GoogleAuth({
+    ...config.keyFile ? { keyFile: config.keyFile } : {},
+    ...config.credentials ? { credentials: config.credentials } : {},
+    scopes,
+    clientOptions: { subject: config.subject }
+  });
+  return auth.getClient();
+}
+async function loadTokens(getter, accountKey) {
+  const raw = await getter(`google_tokens:${accountKey}`);
+  if (!raw) return null;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+async function saveTokens(setter, accountKey, tokens) {
+  await setter(`google_tokens:${accountKey}`, JSON.stringify(tokens));
+}
+async function refreshIfNeeded(client, tokens, saver) {
+  const buffer = 6e4;
+  const isExpired = tokens.expiry_date != null && Date.now() >= tokens.expiry_date - buffer;
+  if (!isExpired) return tokens;
+  client.setCredentials(tokens);
+  const { credentials } = await client.refreshAccessToken();
+  const refreshed = {
+    access_token: credentials.access_token,
+    refresh_token: credentials.refresh_token ?? tokens.refresh_token,
+    expiry_date: credentials.expiry_date ?? void 0,
+    token_type: credentials.token_type ?? "Bearer"
+  };
+  if (saver) {
+    await saver(refreshed);
+  }
+  return refreshed;
+}
+
+// src/connectors/google/gmail-connector.ts
+var GoogleGmailConnector = class {
+  id = "google-gmail";
+  meta = {
+    displayName: "Google Gmail",
+    provider: "google",
+    dataType: "email"
+  };
+  tokenLoader;
+  tokenSaver;
+  client = null;
+  config = null;
+  tokens = null;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  gmail = null;
+  constructor(opts = {}) {
+    this.tokenLoader = opts.tokenLoader;
+    this.tokenSaver = opts.tokenSaver;
+  }
+  // ── Lifecycle ──────────────────────────────────────────────────
+  async connect(config) {
+    this.config = config;
+    const scopes = config.scopes ?? [
+      "https://www.googleapis.com/auth/gmail.readonly"
+    ];
+    if (config.serviceAccount) {
+      this.client = await createServiceAccountClient(config.serviceAccount, scopes);
+    } else if (config.oauth) {
+      this.client = await createOAuth2Client(config.oauth);
+      if (!this.tokenLoader) {
+        throw new Error("tokenLoader required for OAuth2 flow");
+      }
+      this.tokens = await loadTokens(this.tokenLoader, config.account);
+      if (!this.tokens) {
+        throw new Error(
+          `No stored tokens for account ${config.account}. Complete the OAuth flow first.`
+        );
+      }
+      this.tokens = await refreshIfNeeded(
+        this.client,
+        this.tokens,
+        this.tokenSaver ? async (t) => saveTokens(this.tokenSaver, config.account, t) : void 0
+      );
+      this.client.setCredentials(this.tokens);
+    } else {
+      throw new Error("Either serviceAccount or oauth config is required");
+    }
+    const { google } = await import("googleapis");
+    this.gmail = google.gmail({ version: "v1", auth: this.client });
+  }
+  async disconnect() {
+    this.client = null;
+    this.gmail = null;
+    this.tokens = null;
+    this.config = null;
+  }
+  async healthCheck() {
+    try {
+      this.ensureConnected();
+      const res = await this.gmail.users.getProfile({ userId: "me" });
+      return { ok: true, account: res.data.emailAddress };
+    } catch (err) {
+      return { ok: false, error: errorMessage(err) };
+    }
+  }
+  // ── Auth ───────────────────────────────────────────────────────
+  async authenticate(codeProvider) {
+    if (!this.config) {
+      return { success: false, error: "Call connect() first to set config, or pass config and call authenticate() before connect()." };
+    }
+    try {
+      if (!this.config.oauth) {
+        return { success: false, error: "OAuth config required for browser-based authenticate(). Use serviceAccount for headless auth." };
+      }
+      if (!this.tokenSaver) {
+        return { success: false, error: "tokenSaver required for authenticate() flow." };
+      }
+      const client = await createOAuth2Client(this.config.oauth);
+      const scopes = this.config.scopes ?? [
+        "https://www.googleapis.com/auth/gmail.readonly",
+        "https://www.googleapis.com/auth/gmail.send"
+      ];
+      const authUrl = getAuthUrl(client, scopes);
+      const code = await codeProvider(authUrl);
+      const tokens = await exchangeCode(client, code);
+      await saveTokens(this.tokenSaver, this.config.account, tokens);
+      this.tokens = tokens;
+      this.client = client;
+      this.client.setCredentials(tokens);
+      const { google } = await import("googleapis");
+      this.gmail = google.gmail({ version: "v1", auth: this.client });
+      return { success: true, account: this.config.account };
+    } catch (err) {
+      return { success: false, error: errorMessage(err) };
+    }
+  }
+  // ── Sync ───────────────────────────────────────────────────────
+  async sync(options) {
+    this.ensureConnected();
+    if (options?.cursor) {
+      return this.syncIncremental(options.cursor, options.limit);
+    }
+    return this.syncFull(options);
+  }
+  /** Incremental sync using Gmail history API. */
+  async syncIncremental(startHistoryId, limit) {
+    const records = [];
+    const errors = [];
+    const seenIds = /* @__PURE__ */ new Set();
+    let pageToken;
+    let latestHistoryId = startHistoryId;
+    do {
+      const res = await this.gmail.users.history.list({
+        userId: "me",
+        startHistoryId,
+        historyTypes: ["messageAdded"],
+        ...pageToken ? { pageToken } : {}
+      });
+      latestHistoryId = res.data.historyId ?? latestHistoryId;
+      const histories = res.data.history ?? [];
+      for (const h of histories) {
+        for (const added of h.messagesAdded ?? []) {
+          const msgId = added.message?.id;
+          if (!msgId || seenIds.has(msgId)) continue;
+          seenIds.add(msgId);
+          try {
+            const record = await this.fetchMessage(msgId);
+            records.push(record);
+          } catch (err) {
+            errors.push({ id: msgId, error: errorMessage(err) });
+          }
+          if (limit && records.length >= limit) {
+            return { records, cursor: latestHistoryId, hasMore: true, errors };
+          }
+        }
+      }
+      pageToken = res.data.nextPageToken ?? void 0;
+    } while (pageToken);
+    return { records, cursor: latestHistoryId, hasMore: false, errors };
+  }
+  /** Full sync — list messages and fetch each one. */
+  async syncFull(options) {
+    const records = [];
+    const errors = [];
+    const maxResults = options?.limit ?? 100;
+    let query = "";
+    if (options?.since) {
+      const epoch = Math.floor(new Date(options.since).getTime() / 1e3);
+      query = `after:${epoch}`;
+    }
+    if (options?.filters?.q) {
+      query = query ? `${query} ${options.filters.q}` : String(options.filters.q);
+    }
+    let pageToken;
+    let collected = 0;
+    do {
+      const res = await this.gmail.users.messages.list({
+        userId: "me",
+        maxResults: Math.min(maxResults - collected, 100),
+        ...query ? { q: query } : {},
+        ...pageToken ? { pageToken } : {}
+      });
+      const messages = res.data.messages ?? [];
+      for (const msg of messages) {
+        try {
+          const record = await this.fetchMessage(msg.id);
+          records.push(record);
+        } catch (err) {
+          errors.push({ id: msg.id, error: errorMessage(err) });
+        }
+        collected++;
+        if (collected >= maxResults) break;
+      }
+      pageToken = res.data.nextPageToken ?? void 0;
+    } while (pageToken && collected < maxResults);
+    const profile = await this.gmail.users.getProfile({ userId: "me" });
+    const cursor = profile.data.historyId ?? void 0;
+    return {
+      records,
+      cursor,
+      hasMore: !!pageToken,
+      errors
+    };
+  }
+  // ── Push (send email) ─────────────────────────────────────────
+  async push(payload) {
+    this.ensureConnected();
+    try {
+      const toHeader = payload.to.map(formatAddress).join(", ");
+      const ccHeader = payload.cc.length ? `Cc: ${payload.cc.map(formatAddress).join(", ")}\r
+` : "";
+      const bccHeader = payload.bcc.length ? `Bcc: ${payload.bcc.map(formatAddress).join(", ")}\r
+` : "";
+      const mime = [
+        `To: ${toHeader}\r
+`,
+        ccHeader,
+        bccHeader,
+        `Subject: ${payload.subject}\r
+`,
+        `Content-Type: text/plain; charset="UTF-8"\r
+`,
+        `\r
+`,
+        payload.body ?? ""
+      ].join("");
+      const encoded = Buffer.from(mime).toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+      const res = await this.gmail.users.messages.send({
+        userId: "me",
+        requestBody: { raw: encoded }
+      });
+      return { success: true, externalId: res.data.id };
+    } catch (err) {
+      return { success: false, error: errorMessage(err) };
+    }
+  }
+  // ── Internals ─────────────────────────────────────────────────
+  ensureConnected() {
+    if (!this.gmail || !this.config) {
+      throw new Error("GoogleGmailConnector is not connected. Call connect() first.");
+    }
+  }
+  /** Fetch a single message by ID and parse into an EmailRecord. */
+  async fetchMessage(messageId) {
+    const res = await this.gmail.users.messages.get({
+      userId: "me",
+      id: messageId,
+      format: "full"
+    });
+    const msg = res.data;
+    const headers = msg.payload?.headers ?? [];
+    const getHeader = (name) => headers.find((h) => h.name.toLowerCase() === name.toLowerCase())?.value ?? "";
+    return {
+      gmailId: msg.id,
+      threadId: msg.threadId,
+      account: this.config.account,
+      subject: getHeader("Subject"),
+      from: parseAddress(getHeader("From")),
+      to: parseAddressList(getHeader("To")),
+      cc: parseAddressList(getHeader("Cc")),
+      bcc: parseAddressList(getHeader("Bcc")),
+      date: new Date(getHeader("Date")).toISOString(),
+      snippet: msg.snippet ?? "",
+      body: extractPlainTextBody(msg.payload),
+      labels: msg.labelIds ?? [],
+      isRead: !(msg.labelIds ?? []).includes("UNREAD"),
+      attachments: extractAttachments(msg.payload)
+    };
+  }
+};
+function extractAttachments(payload) {
+  if (!payload) return [];
+  const out = [];
+  const walk = (part) => {
+    if (!part) return;
+    const filename = part.filename ?? "";
+    const attachmentId = part.body?.attachmentId;
+    if (filename && attachmentId) {
+      const dispositionHeader = (part.headers ?? []).find(
+        (h) => h.name.toLowerCase() === "content-disposition"
+      );
+      const disposition = dispositionHeader?.value ?? "";
+      const isInline = disposition.toLowerCase().startsWith("inline");
+      if (!isInline) {
+        out.push({
+          attachmentId,
+          filename,
+          mimeType: part.mimeType ?? "application/octet-stream",
+          size: typeof part.body?.size === "number" ? part.body.size : 0
+        });
+      }
+    }
+    if (Array.isArray(part.parts)) {
+      for (const child of part.parts) walk(child);
+    }
+  };
+  walk(payload);
+  return out;
+}
+function extractPlainTextBody(payload) {
+  if (!payload) return void 0;
+  if (payload.mimeType === "text/plain" && payload.body?.data) {
+    return decodeBase64Url(payload.body.data);
+  }
+  if (payload.parts) {
+    for (const part of payload.parts) {
+      if (part.mimeType === "text/plain" && part.body?.data) {
+        return decodeBase64Url(part.body.data);
+      }
+    }
+    for (const part of payload.parts) {
+      if (part.mimeType?.startsWith("multipart/")) {
+        const result = extractPlainTextBody(part);
+        if (result) return result;
+      }
+    }
+  }
+  return void 0;
+}
+function decodeBase64Url(data) {
+  const base64 = data.replace(/-/g, "+").replace(/_/g, "/");
+  return Buffer.from(base64, "base64").toString("utf-8");
+}
+function parseAddress(raw) {
+  const match = raw.match(/^(.+?)\s*<([^>]+)>$/);
+  if (match) {
+    return { name: match[1].replace(/^["']|["']$/g, "").trim(), email: match[2] };
+  }
+  return { email: raw.trim() };
+}
+function parseAddressList(raw) {
+  if (!raw.trim()) return [];
+  const results = [];
+  let current = "";
+  let depth = 0;
+  for (const ch of raw) {
+    if (ch === "<") depth++;
+    else if (ch === ">") depth--;
+    else if (ch === "," && depth === 0) {
+      if (current.trim()) results.push(parseAddress(current.trim()));
+      current = "";
+      continue;
+    }
+    current += ch;
+  }
+  if (current.trim()) results.push(parseAddress(current.trim()));
+  return results;
+}
+function formatAddress(addr) {
+  return addr.name ? `${addr.name} <${addr.email}>` : addr.email;
+}
+function errorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+
+export {
+  createOAuth2Client,
+  getAuthUrl,
+  exchangeCode,
+  createServiceAccountClient,
+  loadTokens,
+  saveTokens,
+  refreshIfNeeded,
+  GoogleGmailConnector
+};

package/dist/cli.js

@@ -179,7 +179,7 @@ async function authGoogle(args) {
       });
     }
   };
-  const { GoogleGmailConnector } = await import("./gmail-connector-Z7SO6VOS.js");
+  const { GoogleGmailConnector } = await import("./gmail-connector-VP5FF56J.js");
   const connector = new GoogleGmailConnector({ tokenLoader, tokenSaver });
   connector.config = {
     account,

package/dist/connectors/google/index.d.ts

@@ -38,6 +38,14 @@ interface EmailAddress {
     name?: string;
     email: string;
 }
+interface EmailAttachment {
+    /** The Gmail attachment ID — can be used with users.messages.attachments.get */
+    attachmentId: string;
+    filename: string;
+    mimeType: string;
+    /** Size in bytes as reported by Gmail */
+    size: number;
+}
 interface EmailRecord {
     gmailId: string;
     threadId: string;
@@ -53,6 +61,7 @@ interface EmailRecord {
     body?: string;
     labels: string[];
     isRead: boolean;
+    attachments: EmailAttachment[];
 }
 interface DriveOwner {
     displayName: string;
@@ -275,4 +284,4 @@ declare class GoogleDriveConnector implements Connector<DriveFileRecord> {
     private mapFile;
 }
 
-export { type CalendarAttendee, type CalendarConnectorOpts, type CalendarEventRecord, type DriveConnectorOpts, type DriveFileRecord, type DriveOwner, type EmailAddress, type EmailRecord, type GmailConnectorOpts, GoogleCalendarConnector, type GoogleConnectorConfig, GoogleDriveConnector, GoogleGmailConnector, type GoogleOAuthConfig, type GoogleServiceAccountConfig, type GoogleTokens, createOAuth2Client, createServiceAccountClient, exchangeCode, getAuthUrl, loadTokens, refreshIfNeeded, saveTokens };
+export { type CalendarAttendee, type CalendarConnectorOpts, type CalendarEventRecord, type DriveConnectorOpts, type DriveFileRecord, type DriveOwner, type EmailAddress, type EmailAttachment, type EmailRecord, type GmailConnectorOpts, GoogleCalendarConnector, type GoogleConnectorConfig, GoogleDriveConnector, GoogleGmailConnector, type GoogleOAuthConfig, type GoogleServiceAccountConfig, type GoogleTokens, createOAuth2Client, createServiceAccountClient, exchangeCode, getAuthUrl, loadTokens, refreshIfNeeded, saveTokens };

package/dist/connectors/google/index.js

@@ -7,7 +7,7 @@ import {
   loadTokens,
   refreshIfNeeded,
   saveTokens
-} from "../../chunk-XYF5PSB2.js";
+} from "../../chunk-7AGWGYZC.js";
 import "../../chunk-3RG5ZIWI.js";
 
 // src/connectors/google/calendar-connector.ts

package/dist/gmail-connector-VP5FF56J.js

@@ -0,0 +1,7 @@
+import {
+  GoogleGmailConnector
+} from "./chunk-7AGWGYZC.js";
+import "./chunk-3RG5ZIWI.js";
+export {
+  GoogleGmailConnector
+};

package/dist/index.d.ts

@@ -4,8 +4,8 @@ import { T as TokenUsage, L as LLMProvider, M as ModelInfo, R as ResolvedModel,
 export { a as ChatParams, b as ChatResult, c as ContentBlock, d as ToolUse } from './provider-DLGUfnNx.js';
 import { C as ConnectorConfig } from './connector-B4Mj0P1b.js';
 export { A as AuthResult, a as Connector, b as ConnectorMeta, P as PushResult, S as SyncOptions, c as SyncResult } from './connector-B4Mj0P1b.js';
-import { C as ChatResponderConfig, D as DataStore, H as HookBus, M as MessageStore, a as ChatResponder, b as MessageInterpreter, E as Extractor } from './chat-pipeline-BWrtVqEP.js';
-export { c as ChatPipeline, d as ChatPipelineConfig, e as DataStoreError, f as EntityContextDef, g as EntityFileSpec, h as EntitySource, i as ExtractedFile, j as ExtractedMemory, k as ExtractedTask, l as ExtractedUserContext, F as Filter, m as HookHandler, n as HookOptions, o as HookRegistration, I as InterpretationResult, L as LLMCallFn, p as MessageInterpreterConfig, P as PkLookup, Q as QueryOptions, R as RelationDef, q as RoutingDecision, r as RoutingRule, s as Row, S as SeedItem, t as SqliteAdapter, u as StoreResult, v as StoredAttachment, T as TableDefinition, w as TableInfoRow, x as TriageRouter, y as TriageRouterConfig, U as Unsubscribe } from './chat-pipeline-BWrtVqEP.js';
+import { C as ChatResponderConfig, D as DataStore, H as HookBus, M as MessageStore, a as ChatResponder, b as MessageInterpreter, E as Extractor } from './chat-pipeline-DuNX5WoL.js';
+export { c as ChatPipeline, d as ChatPipelineConfig, e as DataStoreError, f as EntityContextDef, g as EntityFileSpec, h as EntitySource, i as ExtractedFile, j as ExtractedMemory, k as ExtractedTask, l as ExtractedUserContext, F as Filter, m as HookHandler, n as HookOptions, o as HookRegistration, I as InterpretationResult, L as LLMCallFn, p as MessageInterpreterConfig, P as PkLookup, Q as QueryOptions, R as RelationDef, q as RoutingDecision, r as RoutingRule, s as Row, S as SeedItem, t as SqliteAdapter, u as StoreResult, v as StoredAttachment, T as TableDefinition, w as TableInfoRow, x as TriageRouter, y as TriageRouterConfig, U as Unsubscribe } from './chat-pipeline-DuNX5WoL.js';
 import 'better-sqlite3';
 
 /** Execution adapter types — Story 1.5 / 3.4 / 3.5 */
@@ -1791,6 +1791,7 @@ declare class LoopDetector {
 
 interface FeedbackEntry {
     agentId: string;
+    userId?: string;
     taskId?: string;
     issue: string;
     rootCause?: string;
@@ -1805,6 +1806,7 @@ interface PlaybookEntry {
     rule: string;
     feedbackIds: string[];
     projectScoped: boolean;
+    clientId?: string;
     agentIds?: string[];
 }
 interface SkillEntry {
@@ -1839,6 +1841,7 @@ declare class LearningPipeline {
      */
     listFeedback(filter?: {
         agentId?: string;
+        userId?: string;
         severity?: string;
         repeatable?: boolean;
     }): Promise<Array<Record<string, unknown>>>;
@@ -2163,6 +2166,16 @@ declare const searchConversationTool: {
     handler: ToolHandler;
 };
 
+/**
+ * Shared agent resolution: slug → role → name (case-insensitive).
+ *
+ * LLMs see list_agents output like "AgentName (role)" and naturally use
+ * the role as the identifier. All agent-resolving tools must accept
+ * slug, role, OR name — not just slug.
+ */
+
+declare function resolveAgent(db: DataStore, ref: string): Promise<Record<string, unknown> | null>;
+
 /**
  * Built-in tools: Entity creation — agents, projects.
  */
@@ -2287,4 +2300,4 @@ declare function isLoginRequired(stdout: string): boolean;
 /** Rewrite local image paths to prevent CLI auto-embedding as vision content. */
 declare function deactivateLocalImagePaths(prompt: string): string;
 
-export { AGENT_STATUSES, type AgentConfig, type AgentDefinition, type AgentFilter, type AgentRecord, AgentRegistry, type AgentStatus, ApiExecutionAdapter, type ApprovalResponse, type ApprovalStatus, AuditEmitter, type AuditEvent, BackupManager, type BotConfig, BreakerState, type BudgetCheck, type BudgetConfig, BudgetController, CORE_MIGRATIONS, ChannelAdapter, ChannelRegistry, ChannelRegistryError, type ChatConfig, ChatMessage, ChatPipelineV2, type ChatPipelineV2Config, ChatResponder, ChatResponderConfig, ChatSessionManager, CircuitBreaker, type CircuitBreakerConfig, CliExecutionAdapter, type ColumnValidator, ColumnValidatorImpl, type ConfigLoadError, type ConfigLoadResult, ConnectorConfig, DEFAULTS, DEFAULT_CONFIG, type DataConfig, DataStore, type DefaultLLMCallConfig, DeterministicAdapter, type DeterministicConfig, type DomainEntityContextOptions, type DomainSchemaOptions, DriftGate, EVENTS, type EntityColumnDef, type EntityConfig, type ExecutionAdapter, type ExecutionConfig, type ExecutionEngineConfig, Extractor, type FeedbackEntry, type GateFinding, type GateInput, type GateResult, GateRunner, type GateVerdict, GovernanceGate, HealthStatus, HookBus, InboundMessage, LLMProvider, LearningPipeline, type LearningPipelineConfig, type LoopDetection, LoopDetector, type LoopDetectorConfig, LoopType, MAX_CHAIN_DEPTH, MessageInterpreter, MessagePipeline, MessageStore, type ModelConfig, ModelInfo, ModelRouter, NdjsonLogger, NotificationQueue, type PackageMigration, type PackageUpdate, type ParsedStream, type PermissionPrompt, type PermissionProvider, PermissionRelay, type PermissionRelayConfig, type PlaybookEntry, ProviderRegistry, QAGate, QualityGate, RUN_STATUSES, type RenderConfig, ResolvedModel, type RetryPolicy, type RoutingConfig, type RunContext, RunManager, type RunResult, type RunStatus, type SafetyConfig, type SanitizerOptions, type Schedule, type ScheduleDef, Scheduler, type SchemaError, type SecretInput, type SecretMeta, SecretStore, type SecurityConfig, SessionKey, SessionManager, type SkillEntry, type StepRef, type SystemContextOptions, TASK_STATUSES, type TaskDefinition, TaskQueue, type TaskRecord, type TaskStatus, TokenUsage, type ToolContext, type ToolDefinition, type ToolHandler, UpdateChecker, type UpdateConfig, UpdateManager, type UpdateManifest, type UsageSummary, type User, type UserInput, UserRegistry, WakeupQueue, type WorkflowConfigEntry, type WorkflowDefinition$1 as WorkflowDefinition, WorkflowEngine, type WorkflowRunRecord, type WorkflowRunStatus, type WorkflowStep$1 as WorkflowStep, type WorkflowStepConfig, type WorkflowTrigger, _resetConfig, addTaskCommentTool, areDependenciesMet, autoUpdate, buildAgentBindings, buildChainOrigin, buildProcessEnv, buildSystemContext, cancelTaskTool, checkAllowlist, checkChainDepth, checkMentionGate, chunkText, classifyUpdate, compareVersions, coordinatorTools, createAgentTool, createConfigRevision, createDefaultLLMCall, createProjectTool, deactivateLocalImagePaths, defineCoreEntityContexts, defineCoreTables, defineDomainEntityContexts, defineDomainTables, detectCycle, discoverChannels, discoverProviders, dispatchTaskTool, formatText, getActiveTasksTool, getAgentDetailTool, getAgentStatusTool, getConfig, getSystemStatusTool, getTaskStatusTool, initConfig, interpolate, interpolateEnv, isLoginRequired, isMaxTurns, listAgentsTool, listFilesTool, listProjectsTool, loadConfig, nativeTools, parseClaudeStream, parseVersion, readConversationTool, readFileTool, reassignTaskTool, registerExecutionEngine, registerFileTool, runPackageMigrations, sanitize, searchConversationTool, sendFileTool, sendMessageTool, topologicalSort, truncateAtWord, validateConfig };
+export { AGENT_STATUSES, type AgentConfig, type AgentDefinition, type AgentFilter, type AgentRecord, AgentRegistry, type AgentStatus, ApiExecutionAdapter, type ApprovalResponse, type ApprovalStatus, AuditEmitter, type AuditEvent, BackupManager, type BotConfig, BreakerState, type BudgetCheck, type BudgetConfig, BudgetController, CORE_MIGRATIONS, ChannelAdapter, ChannelRegistry, ChannelRegistryError, type ChatConfig, ChatMessage, ChatPipelineV2, type ChatPipelineV2Config, ChatResponder, ChatResponderConfig, ChatSessionManager, CircuitBreaker, type CircuitBreakerConfig, CliExecutionAdapter, type ColumnValidator, ColumnValidatorImpl, type ConfigLoadError, type ConfigLoadResult, ConnectorConfig, DEFAULTS, DEFAULT_CONFIG, type DataConfig, DataStore, type DefaultLLMCallConfig, DeterministicAdapter, type DeterministicConfig, type DomainEntityContextOptions, type DomainSchemaOptions, DriftGate, EVENTS, type EntityColumnDef, type EntityConfig, type ExecutionAdapter, type ExecutionConfig, type ExecutionEngineConfig, Extractor, type FeedbackEntry, type GateFinding, type GateInput, type GateResult, GateRunner, type GateVerdict, GovernanceGate, HealthStatus, HookBus, InboundMessage, LLMProvider, LearningPipeline, type LearningPipelineConfig, type LoopDetection, LoopDetector, type LoopDetectorConfig, LoopType, MAX_CHAIN_DEPTH, MessageInterpreter, MessagePipeline, MessageStore, type ModelConfig, ModelInfo, ModelRouter, NdjsonLogger, NotificationQueue, type PackageMigration, type PackageUpdate, type ParsedStream, type PermissionPrompt, type PermissionProvider, PermissionRelay, type PermissionRelayConfig, type PlaybookEntry, ProviderRegistry, QAGate, QualityGate, RUN_STATUSES, type RenderConfig, ResolvedModel, type RetryPolicy, type RoutingConfig, type RunContext, RunManager, type RunResult, type RunStatus, type SafetyConfig, type SanitizerOptions, type Schedule, type ScheduleDef, Scheduler, type SchemaError, type SecretInput, type SecretMeta, SecretStore, type SecurityConfig, SessionKey, SessionManager, type SkillEntry, type StepRef, type SystemContextOptions, TASK_STATUSES, type TaskDefinition, TaskQueue, type TaskRecord, type TaskStatus, TokenUsage, type ToolContext, type ToolDefinition, type ToolHandler, UpdateChecker, type UpdateConfig, UpdateManager, type UpdateManifest, type UsageSummary, type User, type UserInput, UserRegistry, WakeupQueue, type WorkflowConfigEntry, type WorkflowDefinition$1 as WorkflowDefinition, WorkflowEngine, type WorkflowRunRecord, type WorkflowRunStatus, type WorkflowStep$1 as WorkflowStep, type WorkflowStepConfig, type WorkflowTrigger, _resetConfig, addTaskCommentTool, areDependenciesMet, autoUpdate, buildAgentBindings, buildChainOrigin, buildProcessEnv, buildSystemContext, cancelTaskTool, checkAllowlist, checkChainDepth, checkMentionGate, chunkText, classifyUpdate, compareVersions, coordinatorTools, createAgentTool, createConfigRevision, createDefaultLLMCall, createProjectTool, deactivateLocalImagePaths, defineCoreEntityContexts, defineCoreTables, defineDomainEntityContexts, defineDomainTables, detectCycle, discoverChannels, discoverProviders, dispatchTaskTool, formatText, getActiveTasksTool, getAgentDetailTool, getAgentStatusTool, getConfig, getSystemStatusTool, getTaskStatusTool, initConfig, interpolate, interpolateEnv, isLoginRequired, isMaxTurns, listAgentsTool, listFilesTool, listProjectsTool, loadConfig, nativeTools, parseClaudeStream, parseVersion, readConversationTool, readFileTool, reassignTaskTool, registerExecutionEngine, registerFileTool, resolveAgent, runPackageMigrations, sanitize, searchConversationTool, sendFileTool, sendMessageTool, topologicalSort, truncateAtWord, validateConfig };

package/dist/index.js

@@ -1662,6 +1662,7 @@ var ChatPipeline = class {
     this.messageFilter = config.messageFilter;
     this.capabilities = config.capabilities;
     this.dedupWindowMs = config.dedupWindowMs ?? DEFAULT_DEDUP_WINDOW_MS;
+    this.skipAck = config.skipAck ?? false;
     this.tasks = config.tasks;
     this.wakeups = config.wakeups;
     this.messageStore = new MessageStore(db, hooks);
@@ -1695,6 +1696,7 @@ var ChatPipeline = class {
   dedupWindowMs;
   tasks;
   wakeups;
+  skipAck;
   // In-memory thread → channel mapping for response routing
   // (before thread_task_map exists)
   threadChannelMap = /* @__PURE__ */ new Map();
@@ -1731,24 +1733,26 @@ var ChatPipeline = class {
         const dir = m.direction === "inbound" ? "User" : "Bot";
         return `${dir}: ${m.body?.slice(0, 200) ?? ""}`;
       }).join("\n");
-      const ackResponse = await this.responder.respond({
-        messageBody: msg.body,
-        threadId: threadTs,
-        channel: this.channel,
-        capabilities: this.capabilities,
-        additionalContext: historyContext ? `
+      if (!this.skipAck) {
+        const ackResponse = await this.responder.respond({
+          messageBody: msg.body,
+          threadId: threadTs,
+          channel: this.channel,
+          capabilities: this.capabilities,
+          additionalContext: historyContext ? `
 
 Recent conversation history:
 ${historyContext}` : void 0
-      });
-      await this.responder.sendResponse({
-        text: ackResponse,
-        channel: this.channel,
-        threadId: threadTs,
-        source: "responder",
-        skipFilter: true,
-        skipRedundancyCheck: true
-      });
+        });
+        await this.responder.sendResponse({
+          text: ackResponse,
+          channel: this.channel,
+          threadId: threadTs,
+          source: "responder",
+          skipFilter: true,
+          skipRedundancyCheck: true
+        });
+      }
       const dispatchPromise = this.interpretAndDispatch(messageId, msg, threadTs, channelId);
       this.lastDispatch = dispatchPromise;
       void dispatchPromise;
@@ -2966,6 +2970,7 @@ function defineCoreTables(db) {
     columns: {
       id: "TEXT PRIMARY KEY",
       agent_id: "TEXT NOT NULL",
+      user_id: "TEXT",
       task_id: "TEXT",
       issue: "TEXT NOT NULL",
       root_cause: "TEXT",
@@ -2978,7 +2983,8 @@ function defineCoreTables(db) {
     },
     tableConstraints: [
       "CREATE INDEX IF NOT EXISTS idx_feedback_agent ON feedback(agent_id, created_at)",
-      "CREATE INDEX IF NOT EXISTS idx_feedback_issue ON feedback(issue)"
+      "CREATE INDEX IF NOT EXISTS idx_feedback_issue ON feedback(issue)",
+      "CREATE INDEX IF NOT EXISTS idx_feedback_user ON feedback(user_id)"
     ]
   });
   db.define("playbooks", {
@@ -2988,6 +2994,7 @@ function defineCoreTables(db) {
       rule: "TEXT NOT NULL",
       feedback_ids: "TEXT NOT NULL DEFAULT '[]'",
       project_scoped: "INTEGER NOT NULL DEFAULT 1",
+      client_id: "TEXT",
       created_at: "TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP",
       updated_at: "TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP",
       deleted_at: "TEXT"
@@ -3113,6 +3120,18 @@ var CORE_MIGRATIONS = [
   {
     version: "006_schedules_next_index",
     sql: `CREATE INDEX IF NOT EXISTS idx_schedules_next ON schedules(enabled, next_fire_at) WHERE deleted_at IS NULL`
+  },
+  {
+    version: "biab:2.5.0:feedback-user-id",
+    sql: `ALTER TABLE feedback ADD COLUMN user_id TEXT`
+  },
+  {
+    version: "biab:2.5.0:feedback-user-idx",
+    sql: `CREATE INDEX IF NOT EXISTS idx_feedback_user ON feedback(user_id)`
+  },
+  {
+    version: "biab:2.5.0:playbooks-client-id",
+    sql: `ALTER TABLE playbooks ADD COLUMN client_id TEXT`
   }
 ];
 
@@ -5932,6 +5951,7 @@ var LearningPipeline = class {
   async captureFeedback(entry) {
     const row = await this.db.insert("feedback", {
       agent_id: entry.agentId,
+      user_id: entry.userId,
       task_id: entry.taskId,
       issue: entry.issue,
       root_cause: entry.rootCause,
@@ -5945,6 +5965,7 @@ var LearningPipeline = class {
     await this.hooks.emit("learning.feedback_captured", {
       feedbackId,
       agentId: entry.agentId,
+      userId: entry.userId,
       issue: entry.issue,
       severity: entry.severity
     });
@@ -5959,6 +5980,7 @@ var LearningPipeline = class {
   async listFeedback(filter) {
     const where = {};
     if (filter?.agentId) where["agent_id"] = filter.agentId;
+    if (filter?.userId) where["user_id"] = filter.userId;
     if (filter?.severity) where["severity"] = filter.severity;
     if (filter?.repeatable !== void 0) where["repeatable"] = filter.repeatable ? 1 : 0;
     return this.db.query("feedback", Object.keys(where).length ? { where } : void 0);
@@ -6000,7 +6022,8 @@ var LearningPipeline = class {
       pattern: entry.pattern,
       rule: entry.rule,
       feedback_ids: JSON.stringify(entry.feedbackIds),
-      project_scoped: entry.projectScoped ? 1 : 0
+      project_scoped: entry.projectScoped ? 1 : 0,
+      client_id: entry.clientId
     });
     const playbookId = row["id"];
     if (entry.agentIds) {
@@ -6662,6 +6685,25 @@ var registerFileTool = {
 
 // src/core/orchestrator/tools/task-ops.ts
 import { randomUUID as randomUUID2 } from "crypto";
+
+// src/core/orchestrator/tools/resolve-agent.ts
+async function resolveAgent(db, ref) {
+  const bySlug = await db.query("agents", { where: { slug: ref } });
+  if (bySlug[0] && !bySlug[0].deleted_at) return bySlug[0];
+  const byRole = await db.query("agents", { where: { role: ref } });
+  const activeByRole = byRole.find((a) => !a.deleted_at);
+  if (activeByRole) return activeByRole;
+  const byName = await db.query("agents", { where: { name: ref } });
+  const activeByName = byName.find((a) => !a.deleted_at);
+  if (activeByName) return activeByName;
+  const lower = ref.toLowerCase();
+  const all = await db.query("agents");
+  return all.find(
+    (a) => !a.deleted_at && (a.slug?.toLowerCase() === lower || a.role?.toLowerCase() === lower || a.name?.toLowerCase() === lower)
+  ) ?? null;
+}
+
+// src/core/orchestrator/tools/task-ops.ts
 var dispatchTaskTool = {
   definition: {
     name: "dispatch_task",
@@ -6671,15 +6713,14 @@ var dispatchTaskTool = {
       properties: {
         title: { type: "string", description: "Short task title" },
         description: { type: "string", description: "Detailed task description" },
-        agent_slug: { type: "string", description: 'Agent slug to assign to (e.g. "engineer", "qa")' },
+        agent_slug: { type: "string", description: 'Agent slug, role, or name (e.g. "eddy", "engineer", "Eddy")' },
         priority: { type: "number", description: "Priority 1-10 (lower = higher priority). Default: 5" }
       },
       required: ["title", "agent_slug"]
     }
   },
   handler: async (input, ctx) => {
-    const agents = await ctx.db.query("agents", { where: { slug: input.agent_slug } });
-    const agent = agents[0];
+    const agent = await resolveAgent(ctx.db, input.agent_slug);
     if (!agent) return `Error: agent "${input.agent_slug}" not found.`;
     const row = await ctx.db.insert("tasks", {
       id: randomUUID2(),
@@ -6719,7 +6760,7 @@ var reassignTaskTool = {
       type: "object",
       properties: {
         task_id: { type: "string", description: "Task ID to reassign" },
-        new_agent_slug: { type: "string", description: "Agent slug to reassign to" }
+        new_agent_slug: { type: "string", description: "Agent slug, role, or name to reassign to" }
       },
       required: ["task_id", "new_agent_slug"]
     }
@@ -6727,8 +6768,7 @@ var reassignTaskTool = {
   handler: async (input, ctx) => {
     const task = await ctx.db.get("tasks", { id: input.task_id });
     if (!task) return `Error: task ${input.task_id} not found.`;
-    const agents = await ctx.db.query("agents", { where: { slug: input.new_agent_slug } });
-    const newAgent = agents[0];
+    const newAgent = await resolveAgent(ctx.db, input.new_agent_slug);
     if (!newAgent) return `Error: agent "${input.new_agent_slug}" not found.`;
     await ctx.db.update("tasks", { id: input.task_id }, { status: "cancelled" });
     const row = await ctx.db.insert("tasks", {
@@ -6776,14 +6816,13 @@ var getAgentStatusTool = {
     input_schema: {
       type: "object",
       properties: {
-        agent_slug: { type: "string", description: 'Agent slug (e.g. "engineer")' }
+        agent_slug: { type: "string", description: 'Agent slug, role, or name (e.g. "eddy", "engineer", "Eddy")' }
       },
       required: ["agent_slug"]
     }
   },
   handler: async (input, ctx) => {
-    const agents = await ctx.db.query("agents", { where: { slug: input.agent_slug } });
-    const agent = agents[0];
+    const agent = await resolveAgent(ctx.db, input.agent_slug);
     if (!agent) return `Agent "${input.agent_slug}" not found.`;
     const tasks = await ctx.db.query("tasks", { where: { assignee_id: agent.id, status: "todo" } });
     const runs = await ctx.db.query("runs", { where: { agent_id: agent.id }, limit: 5 });
@@ -6867,8 +6906,7 @@ var getAgentDetailTool = {
     }
   },
   handler: async (input, ctx) => {
-    const agents = await ctx.db.query("agents", { where: { slug: input.agent_slug } });
-    const agent = agents[0];
+    const agent = await resolveAgent(ctx.db, input.agent_slug);
     if (!agent) return `Agent "${input.agent_slug}" not found.`;
     const skills = await ctx.db.query("agent_skills", { where: { agent_id: agent.id } }).catch(() => []);
     const skillNames = [];
@@ -7544,6 +7582,7 @@ export {
   reassignTaskTool,
   registerExecutionEngine,
   registerFileTool,
+  resolveAgent,
   runPackageMigrations,
   sanitize,
   searchConversationTool,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "botinabox",
-  "version": "2.5.1",
+  "version": "2.5.3",
   "description": "Bot in a Box — framework for building multi-agent bots",
   "type": "module",
   "main": "./dist/index.js",