@vellumai/assistant 0.5.4 → 0.5.6

package/src/runtime/http-server.ts

@@ -172,6 +172,7 @@ import { surfaceContentRouteDefinitions } from "./routes/surface-content-routes.
 import { telemetryRouteDefinitions } from "./routes/telemetry-routes.js";
 import { traceEventRouteDefinitions } from "./routes/trace-event-routes.js";
 import { trustRulesRouteDefinitions } from "./routes/trust-rules-routes.js";
+import { upgradeBroadcastRouteDefinitions } from "./routes/upgrade-broadcast-routes.js";
 import { usageRouteDefinitions } from "./routes/usage-routes.js";
 import { watchRouteDefinitions } from "./routes/watch-routes.js";
 import { workItemRouteDefinitions } from "./routes/work-items-routes.js";
@@ -208,8 +209,8 @@ const log = getLogger("runtime-http");
 const DEFAULT_PORT = 7821;
 const DEFAULT_HOSTNAME = "127.0.0.1";
 
-/** Global hard cap on request body size (150 MB — accommodates base64-encoded 100 MB attachments). */
-const MAX_REQUEST_BODY_BYTES = 150 * 1024 * 1024;
+/** Global hard cap on request body size (512 MB — accommodates large .vbundle backup imports). */
+const MAX_REQUEST_BODY_BYTES = 512 * 1024 * 1024;
 
 export class RuntimeHttpServer {
   private server: ReturnType<typeof Bun.serve> | null = null;
@@ -918,6 +919,7 @@ export class RuntimeHttpServer {
         getCesClient: this.getCesClient,
       }),
       ...identityRouteDefinitions(),
+      ...upgradeBroadcastRouteDefinitions(),
       ...debugRouteDefinitions(),
       ...usageRouteDefinitions(),
       ...telemetryRouteDefinitions(),

package/src/runtime/routes/conversation-management-routes.ts

@@ -275,24 +275,6 @@ export function conversationManagementRouteDefinitions(
             targetId: summaryId,
           });
         }
-        for (const obsId of result.deletedObservationIds) {
-          enqueueMemoryJob("delete_qdrant_vectors", {
-            targetType: "observation",
-            targetId: obsId,
-          });
-        }
-        for (const chunkId of result.deletedChunkIds) {
-          enqueueMemoryJob("delete_qdrant_vectors", {
-            targetType: "chunk",
-            targetId: chunkId,
-          });
-        }
-        for (const episodeId of result.deletedEpisodeIds) {
-          enqueueMemoryJob("delete_qdrant_vectors", {
-            targetType: "episode",
-            targetId: episodeId,
-          });
-        }
         log.info(
           {
             conversationId: resolvedId,
@@ -349,24 +331,6 @@ export function conversationManagementRouteDefinitions(
             targetId: summaryId,
           });
         }
-        for (const obsId of deleted.deletedObservationIds) {
-          enqueueMemoryJob("delete_qdrant_vectors", {
-            targetType: "observation",
-            targetId: obsId,
-          });
-        }
-        for (const chunkId of deleted.deletedChunkIds) {
-          enqueueMemoryJob("delete_qdrant_vectors", {
-            targetType: "chunk",
-            targetId: chunkId,
-          });
-        }
-        for (const episodeId of deleted.deletedEpisodeIds) {
-          enqueueMemoryJob("delete_qdrant_vectors", {
-            targetType: "episode",
-            targetId: episodeId,
-          });
-        }
         log.info({ conversationId: resolvedId }, "Deleted conversation");
         return new Response(null, { status: 204 });
       },

package/src/runtime/routes/conversation-query-routes.ts

@@ -1,7 +1,7 @@
 /**
  * HTTP route definitions for model configuration, embedding configuration,
- * conversation search, message content, LLM context inspection, and queued
- * message deletion.
+ * permissions configuration, conversation search, message content, LLM
+ * context inspection, and queued message deletion.
  *
  * These routes expose conversation query functionality over the HTTP API.
  *
@@ -10,12 +10,15 @@
  * PUT    /v1/model/image-gen            — set image-gen model
  * GET    /v1/config/embeddings          — current embedding config
  * PUT    /v1/config/embeddings          — set embedding provider/model
+ * GET    /v1/config/permissions/skip    — dangerouslySkipPermissions status
+ * PUT    /v1/config/permissions/skip    — toggle dangerouslySkipPermissions
  * GET    /v1/conversations/search       — search conversations
  * GET    /v1/messages/:id/content       — full message content
  * GET    /v1/messages/:id/llm-context   — LLM request logs for a message
  * DELETE /v1/messages/queued/:id        — delete queued message
  */
 
+import { getConfig, loadRawConfig, saveRawConfig } from "../../config/loader.js";
 import { VALID_MEMORY_EMBEDDING_PROVIDERS } from "../../config/schemas/memory-storage.js";
 import { VALID_INFERENCE_PROVIDERS } from "../../config/schemas/services.js";
 import {
@@ -250,6 +253,45 @@ export function conversationQueryRouteDefinitions(
       },
     },
 
+    // ── Permissions config ─────────────────────────────────────────────
+    {
+      endpoint: "config/permissions/skip",
+      method: "GET",
+      policyKey: "config/permissions/skip",
+      handler: () => {
+        const config = getConfig();
+        return Response.json({
+          enabled: config.permissions.dangerouslySkipPermissions,
+        });
+      },
+    },
+    {
+      endpoint: "config/permissions/skip",
+      method: "PUT",
+      policyKey: "config/permissions/skip",
+      handler: async ({ req }) => {
+        const body = (await req.json()) as { enabled?: unknown };
+        if (typeof body.enabled !== "boolean") {
+          return httpError(
+            "BAD_REQUEST",
+            "Missing or invalid field: enabled (boolean)",
+            400,
+          );
+        }
+        const raw = loadRawConfig();
+        const permissions: Record<string, unknown> =
+          raw.permissions != null &&
+          typeof raw.permissions === "object" &&
+          !Array.isArray(raw.permissions)
+            ? (raw.permissions as Record<string, unknown>)
+            : {};
+        permissions.dangerouslySkipPermissions = body.enabled;
+        raw.permissions = permissions;
+        saveRawConfig(raw);
+        return Response.json({ enabled: body.enabled });
+      },
+    },
+
     // ── Conversation search ───────────────────────────────────────────
     {
       endpoint: "conversations/search",

package/src/runtime/routes/conversation-routes.ts

@@ -637,6 +637,7 @@ export async function handleSendMessage(
     interface?: string;
     conversationType?: string;
     automated?: boolean;
+    bypassSecretCheck?: boolean;
   };
 
   const { conversationKey, content, attachmentIds } = body;
@@ -708,7 +709,7 @@ export async function handleSendMessage(
   // This mirrors the legacy handleUserMessage behavior: secrets are
   // detected and the message is rejected with a safe notice. The client
   // should prompt the user to use the secure credential flow instead.
-  if (trimmedContent.length > 0) {
+  if (trimmedContent.length > 0 && !body.bypassSecretCheck) {
     const ingressCheck = checkIngressForSecrets(trimmedContent);
     if (ingressCheck.blocked) {
       log.warn(

package/src/runtime/routes/inbound-message-handler.ts

@@ -44,6 +44,7 @@ import { handleEditIntercept } from "./inbound-stages/edit-intercept.js";
 import { handleEscalationIntercept } from "./inbound-stages/escalation-intercept.js";
 import { handleGuardianReplyIntercept } from "./inbound-stages/guardian-reply-intercept.js";
 import { runSecretIngressCheck } from "./inbound-stages/secret-ingress-check.js";
+import { tryTranscribeAudioAttachments } from "./inbound-stages/transcribe-audio.js";
 import { handleVerificationIntercept } from "./inbound-stages/verification-intercept.js";
 
 const log = getLogger("runtime-http");
@@ -144,7 +145,7 @@ export async function handleChannelInbound(
     return httpError("BAD_REQUEST", "content must be a string", 400);
   }
 
-  const trimmedContent = typeof content === "string" ? content.trim() : "";
+  let trimmedContent = typeof content === "string" ? content.trim() : "";
   const hasAttachments =
     Array.isArray(attachmentIds) && attachmentIds.length > 0;
 
@@ -227,6 +228,29 @@ export async function handleChannelInbound(
     }
   }
 
+  // Auto-transcribe audio attachments from channel messages
+  if (hasAttachments && sourceChannel) {
+    const transcribeResult = await tryTranscribeAudioAttachments(attachmentIds);
+    switch (transcribeResult.status) {
+      case "transcribed":
+        // For voice-only messages (empty content), this becomes the message text.
+        // For audio+caption, both are preserved.
+        trimmedContent =
+          transcribeResult.text +
+          (trimmedContent ? `\n\n${trimmedContent}` : "");
+        break;
+      case "no_provider":
+      case "error":
+        // Inject a hint so the assistant knows the user sent audio and why
+        // transcription failed — it can then guide the user (e.g. set up API key).
+        trimmedContent =
+          `[Voice message received — ${transcribeResult.reason}]` +
+          (trimmedContent ? `\n\n${trimmedContent}` : "");
+        break;
+      // "no_audio", "disabled" — no action needed
+    }
+  }
+
   const sourceMessageId =
     typeof sourceMetadata?.messageId === "string"
       ? sourceMetadata.messageId
@@ -333,7 +357,7 @@ export async function handleChannelInbound(
     externalMessageId,
     conversationId: result.conversationId,
     eventId: result.eventId,
-    content,
+    content: trimmedContent,
     attachmentIds,
     sourceMetadata: body.sourceMetadata,
     actorDisplayName: body.actorDisplayName,
@@ -612,7 +636,7 @@ export async function handleChannelInbound(
       processMessage,
       conversationId: result.conversationId,
       eventId: result.eventId,
-      content: content ?? "",
+      content: trimmedContent,
       attachmentIds: hasAttachments ? attachmentIds : undefined,
       sourceChannel,
       sourceInterface,

package/src/runtime/routes/inbound-stages/acl-enforcement.ts

@@ -79,14 +79,29 @@ export interface AclResult {
   guardianVerifyCode: string | undefined;
 }
 
+/**
+ * Strip Slack/Telegram mrkdwn formatting wrappers from a raw message.
+ * When users copy-paste a verification code from the desktop app with
+ * rich-text formatting (e.g. bold), Slack preserves it as `*code*` in
+ * the message text, which would otherwise fail the strict bare-code regex.
+ */
+function stripMrkdwnFormatting(text: string): string {
+  // Bold (*…*), italic (_…_), strikethrough (~…~), inline code (`…`)
+  return text.replace(/^[*_~`]+/, "").replace(/[*_~`]+$/, "");
+}
+
 /**
  * Parse a guardian verification code from message content.
  * Accepts a bare code as the entire message: 6-digit numeric OR 64-char hex
  * (hex is retained for compatibility with unbound inbound/bootstrap sessions
  * that intentionally use high-entropy secrets).
+ *
+ * Strips surrounding mrkdwn formatting characters first so that codes
+ * pasted with bold/italic/code formatting are still recognized.
  */
 function parseGuardianVerifyCode(content: string): string | undefined {
-  const bareMatch = content.match(/^([0-9a-fA-F]{64}|\d{6})$/);
+  const stripped = stripMrkdwnFormatting(content);
+  const bareMatch = stripped.match(/^([0-9a-fA-F]{64}|\d{6})$/);
   if (bareMatch) return bareMatch[1];
 
   return undefined;

package/src/runtime/routes/inbound-stages/transcribe-audio.test.ts

@@ -0,0 +1,287 @@
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+import type { SpeechToTextProvider } from "../../../providers/speech-to-text/types.js";
+
+// ---------------------------------------------------------------------------
+// Mocks — must be set up before importing the module under test
+// ---------------------------------------------------------------------------
+
+let mockFeatureFlagEnabled = true;
+let mockAttachments: Array<{
+  id: string;
+  mimeType: string;
+  dataBase64: string;
+  originalFilename: string;
+  sizeBytes: number;
+  kind: string;
+  thumbnailBase64: string | null;
+  createdAt: number;
+}> = [];
+let mockProvider: SpeechToTextProvider | null = null;
+
+mock.module("../../../config/assistant-feature-flags.js", () => ({
+  isAssistantFeatureFlagEnabled: () => mockFeatureFlagEnabled,
+}));
+
+mock.module("../../../config/loader.js", () => ({
+  getConfig: () => ({ assistantFeatureFlagValues: {} }),
+}));
+
+mock.module("../../../memory/attachments-store.js", () => ({
+  getAttachmentsByIds: (ids: string[]) =>
+    mockAttachments.filter((a) => ids.includes(a.id)),
+  getAttachmentById: (id: string, _opts?: { hydrateFileData?: boolean }) =>
+    mockAttachments.find((a) => a.id === id) ?? null,
+}));
+
+mock.module("../../../providers/speech-to-text/resolve.js", () => ({
+  resolveSpeechToTextProvider: async () => mockProvider,
+}));
+
+mock.module("../../../util/logger.js", () => ({
+  getLogger: () => ({
+    debug: () => {},
+    info: () => {},
+    warn: () => {},
+    error: () => {},
+  }),
+}));
+
+// Import after mocks are installed
+const { tryTranscribeAudioAttachments } = await import("./transcribe-audio.js");
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function makeAudioAttachment(
+  id: string,
+  mimeType = "audio/ogg",
+  dataBase64 = Buffer.from("fake-audio-data").toString("base64"),
+) {
+  return {
+    id,
+    mimeType,
+    dataBase64,
+    originalFilename: `voice-${id}.ogg`,
+    sizeBytes: Buffer.from(dataBase64, "base64").length,
+    kind: "document" as const,
+    thumbnailBase64: null,
+    createdAt: Date.now(),
+  };
+}
+
+function makeDocumentAttachment(id: string) {
+  return {
+    id,
+    mimeType: "application/pdf",
+    dataBase64: Buffer.from("fake-pdf").toString("base64"),
+    originalFilename: `doc-${id}.pdf`,
+    sizeBytes: 8,
+    kind: "document" as const,
+    thumbnailBase64: null,
+    createdAt: Date.now(),
+  };
+}
+
+function makeImageAttachment(id: string) {
+  return {
+    id,
+    mimeType: "image/png",
+    dataBase64: Buffer.from("fake-image").toString("base64"),
+    originalFilename: `photo-${id}.png`,
+    sizeBytes: 10,
+    kind: "image" as const,
+    thumbnailBase64: null,
+    createdAt: Date.now(),
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("tryTranscribeAudioAttachments", () => {
+  beforeEach(() => {
+    mockFeatureFlagEnabled = true;
+    mockAttachments = [];
+    mockProvider = null;
+  });
+
+  afterEach(() => {
+    mockAttachments = [];
+  });
+
+  test("audio attachment is transcribed and returns transcribed result", async () => {
+    const audio = makeAudioAttachment("a1");
+    mockAttachments = [audio];
+    mockProvider = {
+      transcribe: async () => ({ text: "Hello, how are you?" }),
+    };
+
+    const result = await tryTranscribeAudioAttachments(["a1"]);
+
+    expect(result).toEqual({
+      status: "transcribed",
+      text: "Hello, how are you?",
+    });
+  });
+
+  test("non-audio attachments return no_audio", async () => {
+    const doc = makeDocumentAttachment("d1");
+    const img = makeImageAttachment("i1");
+    mockAttachments = [doc, img];
+    mockProvider = {
+      transcribe: async () => ({ text: "should not be called" }),
+    };
+
+    const result = await tryTranscribeAudioAttachments(["d1", "i1"]);
+
+    expect(result).toEqual({ status: "no_audio" });
+  });
+
+  test("no API key returns no_provider with helpful reason string", async () => {
+    const audio = makeAudioAttachment("a1");
+    mockAttachments = [audio];
+    mockProvider = null; // No provider resolved
+
+    const result = await tryTranscribeAudioAttachments(["a1"]);
+
+    expect(result.status).toBe("no_provider");
+    expect((result as { reason: string }).reason).toContain(
+      "No OpenAI API key configured",
+    );
+  });
+
+  test("API failure returns error with reason", async () => {
+    const audio = makeAudioAttachment("a1");
+    mockAttachments = [audio];
+    mockProvider = {
+      transcribe: async () => {
+        throw new Error("API rate limit exceeded");
+      },
+    };
+
+    const result = await tryTranscribeAudioAttachments(["a1"]);
+
+    expect(result.status).toBe("error");
+    expect((result as { reason: string }).reason).toBe(
+      "API rate limit exceeded",
+    );
+  });
+
+  test("feature flag disabled returns disabled", async () => {
+    mockFeatureFlagEnabled = false;
+    const audio = makeAudioAttachment("a1");
+    mockAttachments = [audio];
+
+    const result = await tryTranscribeAudioAttachments(["a1"]);
+
+    expect(result).toEqual({ status: "disabled" });
+  });
+
+  test("30-second timeout fires and returns error without blocking", async () => {
+    const audio = makeAudioAttachment("a1");
+    mockAttachments = [audio];
+    mockProvider = {
+      transcribe: async (_audio, _mime, signal) => {
+        // Simulate a provider that respects the abort signal
+        return new Promise((_resolve, reject) => {
+          if (signal?.aborted) {
+            reject(new DOMException("The operation was aborted", "AbortError"));
+            return;
+          }
+          const onAbort = () => {
+            reject(new DOMException("The operation was aborted", "AbortError"));
+          };
+          signal?.addEventListener("abort", onAbort, { once: true });
+        });
+      },
+    };
+
+    // The timeout is 30s in the real code, but the test's mock provider
+    // aborts immediately when signaled. We verify the error path works
+    // by checking the result type. For a true timeout test we'd need
+    // to override the timeout constant, but this confirms the abort
+    // path produces the correct result.
+    // Instead, let's test with a provider that checks signal state:
+    mockProvider = {
+      transcribe: async () => {
+        throw new DOMException("The operation was aborted", "AbortError");
+      },
+    };
+
+    const result = await tryTranscribeAudioAttachments(["a1"]);
+
+    expect(result.status).toBe("error");
+    expect((result as { reason: string }).reason).toBe(
+      "Transcription timed out",
+    );
+  });
+
+  test("multiple audio attachments are transcribed and concatenated", async () => {
+    const a1 = makeAudioAttachment("a1");
+    const a2 = makeAudioAttachment("a2", "audio/mpeg");
+    mockAttachments = [a1, a2];
+
+    let callCount = 0;
+    mockProvider = {
+      transcribe: async () => {
+        callCount++;
+        return { text: callCount === 1 ? "First message" : "Second message" };
+      },
+    };
+
+    const result = await tryTranscribeAudioAttachments(["a1", "a2"]);
+
+    expect(result).toEqual({
+      status: "transcribed",
+      text: "First message\n\nSecond message",
+    });
+    expect(callCount).toBe(2);
+  });
+
+  test("mixed audio and non-audio attachments: only audio is transcribed", async () => {
+    const audio = makeAudioAttachment("a1");
+    const doc = makeDocumentAttachment("d1");
+    mockAttachments = [audio, doc];
+
+    let transcribeCallCount = 0;
+    mockProvider = {
+      transcribe: async () => {
+        transcribeCallCount++;
+        return { text: "Voice transcription" };
+      },
+    };
+
+    const result = await tryTranscribeAudioAttachments(["a1", "d1"]);
+
+    expect(result).toEqual({
+      status: "transcribed",
+      text: "Voice transcription",
+    });
+    expect(transcribeCallCount).toBe(1);
+  });
+
+  test("empty attachment IDs returns no_audio", async () => {
+    mockProvider = {
+      transcribe: async () => ({ text: "should not be called" }),
+    };
+
+    const result = await tryTranscribeAudioAttachments([]);
+
+    expect(result).toEqual({ status: "no_audio" });
+  });
+
+  test("attachment with empty transcription returns no_audio", async () => {
+    const audio = makeAudioAttachment("a1");
+    mockAttachments = [audio];
+    mockProvider = {
+      transcribe: async () => ({ text: "   " }), // whitespace-only
+    };
+
+    const result = await tryTranscribeAudioAttachments(["a1"]);
+
+    expect(result).toEqual({ status: "no_audio" });
+  });
+});

package/src/runtime/routes/inbound-stages/transcribe-audio.ts

@@ -0,0 +1,122 @@
+/**
+ * Auto-transcribe audio attachments from channel inbound messages.
+ *
+ * Returns a discriminated result type so callers can handle each outcome
+ * (transcribed, no audio, disabled, no provider, error) without exceptions.
+ * Never throws — failures are represented as result variants so that message
+ * delivery is never blocked by transcription issues.
+ */
+
+import { isAssistantFeatureFlagEnabled } from "../../../config/assistant-feature-flags.js";
+import { getConfig } from "../../../config/loader.js";
+import * as attachmentsStore from "../../../memory/attachments-store.js";
+import { resolveSpeechToTextProvider } from "../../../providers/speech-to-text/resolve.js";
+import { getLogger } from "../../../util/logger.js";
+
+const log = getLogger("transcribe-audio");
+
+const VOICE_TRANSCRIPTION_FLAG_KEY =
+  "feature_flags.channel-voice-transcription.enabled" as const;
+
+/** Timeout for the entire transcription pipeline (all attachments). */
+const TRANSCRIPTION_TIMEOUT_MS = 30_000;
+
+// ---------------------------------------------------------------------------
+// Result type
+// ---------------------------------------------------------------------------
+
+export type TranscribeResult =
+  | { status: "transcribed"; text: string }
+  | { status: "no_audio" }
+  | { status: "disabled" }
+  | { status: "no_provider"; reason: string }
+  | { status: "error"; reason: string };
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+export async function tryTranscribeAudioAttachments(
+  attachmentIds: string[],
+): Promise<TranscribeResult> {
+  try {
+    // Check feature flag
+    const config = getConfig();
+    if (!isAssistantFeatureFlagEnabled(VOICE_TRANSCRIPTION_FLAG_KEY, config)) {
+      return { status: "disabled" };
+    }
+
+    // Look up attachments and filter to audio MIME types
+    const resolved = attachmentsStore.getAttachmentsByIds(attachmentIds);
+    const audioAttachments = resolved.filter((a) =>
+      a.mimeType.startsWith("audio/"),
+    );
+
+    if (audioAttachments.length === 0) {
+      return { status: "no_audio" };
+    }
+
+    // Resolve STT provider
+    const provider = await resolveSpeechToTextProvider();
+    if (!provider) {
+      return {
+        status: "no_provider",
+        reason:
+          "No OpenAI API key configured. Set one up to enable voice message transcription.",
+      };
+    }
+
+    // Transcribe each audio attachment with a shared timeout
+    const abortController = new AbortController();
+    const timeoutId = setTimeout(
+      () => abortController.abort(),
+      TRANSCRIPTION_TIMEOUT_MS,
+    );
+
+    try {
+      const transcriptions: string[] = [];
+
+      for (const attachment of audioAttachments) {
+        // Hydrate the base64 data for the attachment
+        const hydrated = attachmentsStore.getAttachmentById(attachment.id, {
+          hydrateFileData: true,
+        });
+        if (!hydrated || !hydrated.dataBase64) {
+          log.warn(
+            { attachmentId: attachment.id },
+            "Could not hydrate audio attachment data; skipping",
+          );
+          continue;
+        }
+
+        const buffer = Buffer.from(hydrated.dataBase64, "base64");
+        const result = await provider.transcribe(
+          buffer,
+          attachment.mimeType,
+          abortController.signal,
+        );
+
+        if (result.text.trim()) {
+          transcriptions.push(result.text.trim());
+        }
+      }
+
+      if (transcriptions.length === 0) {
+        return { status: "no_audio" };
+      }
+
+      return { status: "transcribed", text: transcriptions.join("\n\n") };
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  } catch (err: unknown) {
+    const reason =
+      err instanceof Error
+        ? err.name === "AbortError"
+          ? "Transcription timed out"
+          : err.message
+        : String(err);
+    log.warn({ err }, "Audio transcription failed");
+    return { status: "error", reason };
+  }
+}

package/src/runtime/routes/log-export-routes.ts

@@ -444,6 +444,7 @@ const WORKSPACE_SKIP_DIRS = new Set([
   "embedding-models",
   "data/qdrant",
   "data/attachments",
+  "data/sounds",
   "conversations",
 ]);