botinabox 2.9.3 → 2.9.5

package/dist/chunk-QBBROFEL.js

@@ -0,0 +1,224 @@
+// src/channels/slack/transcribe.ts
+import { execFileSync } from "child_process";
+import { writeFileSync, unlinkSync, mkdirSync } from "fs";
+import { join } from "path";
+import { randomUUID } from "crypto";
+import os from "os";
+import { createRequire } from "module";
+var TEMP_DIR = join(os.tmpdir(), "botinabox-audio");
+async function transcribeAudio(audioBuffer, filename, opts) {
+  let whisper;
+  try {
+    const require2 = createRequire(import.meta.url);
+    const mod = require2("whisper-node");
+    whisper = mod.whisper ?? mod.default ?? mod;
+  } catch {
+    console.warn("[botinabox] whisper-node not installed \u2014 voice transcription unavailable. Run: npm install whisper-node && npx whisper-node download");
+    return null;
+  }
+  try {
+    execFileSync("ffmpeg", ["-version"], { stdio: "ignore" });
+  } catch {
+    console.warn("[botinabox] ffmpeg not found \u2014 required for audio conversion. Install: brew install ffmpeg");
+    return null;
+  }
+  const id = randomUUID().slice(0, 8);
+  const ext = filename.split(".").pop() ?? "aac";
+  mkdirSync(TEMP_DIR, { recursive: true });
+  const inputPath = join(TEMP_DIR, `${id}.${ext}`);
+  const wavPath = join(TEMP_DIR, `${id}.wav`);
+  try {
+    writeFileSync(inputPath, audioBuffer);
+    execFileSync("ffmpeg", ["-y", "-i", inputPath, "-ar", "16000", "-ac", "1", "-c:a", "pcm_s16le", wavPath], {
+      stdio: "ignore",
+      timeout: 3e4
+    });
+    const segments = await whisper(wavPath, {
+      modelName: opts?.modelName ?? "base.en",
+      whisperOptions: {
+        language: opts?.language ?? "auto"
+      }
+    });
+    if (!segments || segments.length === 0) return null;
+    return segments.map((s) => s.speech).join(" ").trim();
+  } catch (err) {
+    console.error("[botinabox] Transcription failed:", err);
+    return null;
+  } finally {
+    try {
+      unlinkSync(inputPath);
+    } catch {
+    }
+    try {
+      unlinkSync(wavPath);
+    } catch {
+    }
+  }
+}
+async function downloadAudio(url, token) {
+  try {
+    const resp = await fetch(url, {
+      headers: { Authorization: `Bearer ${token}` }
+    });
+    if (!resp.ok) {
+      console.error(`[botinabox] Audio download failed: ${resp.status} ${resp.statusText}`);
+      return null;
+    }
+    return Buffer.from(await resp.arrayBuffer());
+  } catch (err) {
+    console.error("[botinabox] Audio download error:", err);
+    return null;
+  }
+}
+
+// src/channels/slack/media-type.ts
+var FILETYPE_MAP = {
+  // image
+  jpg: "image",
+  jpeg: "image",
+  png: "image",
+  gif: "image",
+  webp: "image",
+  heic: "image",
+  svg: "image",
+  bmp: "image",
+  // video
+  mp4: "video",
+  mov: "video",
+  webm: "video",
+  avi: "video",
+  mkv: "video",
+  // audio (also handled by voice-message path — included for completeness)
+  aac: "audio",
+  m4a: "audio",
+  mp3: "audio",
+  wav: "audio",
+  ogg: "audio",
+  flac: "audio",
+  // pdf
+  pdf: "pdf",
+  // doc
+  gdoc: "doc",
+  docx: "doc",
+  doc: "doc",
+  md: "doc",
+  txt: "doc",
+  rtf: "doc",
+  // excel
+  gsheet: "excel",
+  xlsx: "excel",
+  xls: "excel",
+  csv: "excel",
+  tsv: "excel",
+  // presentation
+  gslide: "presentation",
+  pptx: "presentation",
+  ppt: "presentation",
+  key: "presentation",
+  // html
+  html: "html",
+  htm: "html"
+};
+function slackFiletypeToMediaType(filetype) {
+  if (!filetype) return "misc";
+  return FILETYPE_MAP[filetype.toLowerCase()] ?? "misc";
+}
+var URL_REGEX = /https?:\/\/[^\s<>"')]+/g;
+function extractUrls(text) {
+  if (!text) return [];
+  const matches = text.match(URL_REGEX);
+  if (!matches) return [];
+  return Array.from(new Set(matches.map((u) => u.replace(/[.,;:!?)]+$/, ""))));
+}
+
+// src/channels/slack/inbound.ts
+var AUDIO_TYPES = /* @__PURE__ */ new Set(["aac", "mp4", "m4a", "ogg", "webm", "mp3", "wav"]);
+function extractVoiceTranscript(file) {
+  const isAudio = file.subtype === "slack_audio" || AUDIO_TYPES.has(file.filetype ?? "");
+  if (!isAudio) return null;
+  const transcript = file.transcription?.preview?.content ?? (typeof file.preview === "string" ? file.preview : null);
+  return transcript ?? null;
+}
+function parseSlackEvent(event) {
+  const id = event.client_msg_id ?? event.ts ?? event.event_ts ?? `slack-${Date.now()}`;
+  const channel = event.channel ?? "unknown";
+  const from = event.user ?? "unknown";
+  const isChannel = channel.startsWith("C") || channel.startsWith("G");
+  const threadId = event.thread_ts ?? (isChannel ? event.ts : void 0);
+  const receivedAt = event.ts ? new Date(parseFloat(event.ts) * 1e3).toISOString() : (/* @__PURE__ */ new Date()).toISOString();
+  let body = event.text ?? "";
+  if (event.subtype === "file_share" && event.files?.length) {
+    for (const file of event.files) {
+      const transcript = extractVoiceTranscript(file);
+      if (transcript) {
+        body = body ? `${body}
+
+[Voice message] ${transcript}` : `[Voice message] ${transcript}`;
+        break;
+      }
+    }
+  }
+  if (event.subtype === "file_share" && event.files?.length && !body) {
+    const hasAudio = event.files.some(
+      (f) => f.subtype === "slack_audio" || AUDIO_TYPES.has(f.filetype ?? "")
+    );
+    if (hasAudio) {
+      body = "[Voice message \u2014 no transcript available]";
+    }
+  }
+  const attachments = [];
+  if (event.subtype === "file_share" && event.files?.length) {
+    for (const file of event.files) {
+      const isAudio = file.subtype === "slack_audio" || AUDIO_TYPES.has(file.filetype ?? "");
+      if (isAudio) continue;
+      attachments.push({
+        type: slackFiletypeToMediaType(file.filetype),
+        url: file.url_private,
+        mimeType: file.mimetype,
+        filename: file.name ?? file.title,
+        size: file.size
+      });
+    }
+  }
+  const urls = extractUrls(body);
+  for (const url of urls) {
+    attachments.push({ type: "link", url });
+  }
+  return {
+    id,
+    channel,
+    from,
+    body,
+    threadId,
+    attachments: attachments.length > 0 ? attachments : void 0,
+    receivedAt,
+    raw: event
+  };
+}
+async function enrichVoiceMessage(msg, botToken) {
+  if (!msg.body.includes("[Voice message \u2014 no transcript available]")) return msg;
+  const raw = msg.raw;
+  const files = raw?.files;
+  if (!files?.length) return msg;
+  const audioFile = files.find(
+    (f) => f.subtype === "slack_audio" || AUDIO_TYPES.has(f.filetype ?? "")
+  );
+  if (!audioFile?.url_private) return msg;
+  const buffer = await downloadAudio(audioFile.url_private, botToken);
+  if (!buffer) return msg;
+  const filename = audioFile.name ?? `voice.${audioFile.filetype ?? "aac"}`;
+  const transcript = await transcribeAudio(buffer, filename);
+  if (!transcript) return msg;
+  return {
+    ...msg,
+    body: `[Voice message] ${transcript}`
+  };
+}
+
+export {
+  transcribeAudio,
+  downloadAudio,
+  extractVoiceTranscript,
+  parseSlackEvent,
+  enrichVoiceMessage
+};

package/dist/core/orchestrator/run-manager.d.ts

@@ -24,6 +24,8 @@ export declare class RunManager {
         output?: string;
         costCents?: number;
         usage?: unknown;
+        model?: string;
+        provider?: string;
     }): Promise<void>;
     reapOrphans(): Promise<void>;
     startOrphanReaper(intervalMs?: number): void;

package/dist/inbound-WAOVULIZ.js

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

package/dist/index.js

@@ -4688,7 +4688,8 @@ var RunManager = class {
       cost_cents: result.costCents ?? 0,
       input_tokens: usage?.["inputTokens"] ?? 0,
       output_tokens: usage?.["outputTokens"] ?? 0,
-      error_message: result.exitCode !== 0 ? result.output : void 0
+      error_message: result.exitCode !== 0 ? result.output : void 0,
+      model: result.model ?? void 0
     });
     const agentId = run["agent_id"];
     this.locks.delete(agentId);
@@ -4759,7 +4760,10 @@ var RunManager = class {
       agentId,
       taskId,
       status,
-      exitCode: result.exitCode
+      exitCode: result.exitCode,
+      model: result.model,
+      provider: result.provider,
+      usage: result.usage
     });
   }
   async reapOrphans() {
@@ -6635,7 +6639,9 @@ ${contextFilesBlock}` : "",
         exitCode: 0,
         output: finalOutput,
         costCents,
-        usage: { inputTokens: totalInput, outputTokens: totalOutput }
+        usage: { inputTokens: totalInput, outputTokens: totalOutput },
+        model,
+        provider: "anthropic"
       });
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);

package/dist/provider-BHkqkSdq.d.ts

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

package/package.json

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