@vellumai/assistant 0.4.26 → 0.4.29

package/src/config/bundled-skills/transcribe/tools/transcribe-media.ts

@@ -1,17 +1,47 @@
-import { randomUUID } from 'node:crypto';
-import { access, mkdir, readdir,readFile, unlink, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { extname,join } from 'node:path';
-
-import { getConfig } from '../../../../config/loader.js';
-import { getAttachmentsByIds } from '../../../../memory/attachments-store.js';
-import type { ToolContext, ToolExecutionResult } from '../../../../tools/types.js';
-
-const VIDEO_EXTENSIONS = new Set(['.mp4', '.mov', '.avi', '.mkv', '.webm', '.m4v', '.mpeg', '.mpg']);
-const AUDIO_EXTENSIONS = new Set(['.mp3', '.wav', '.m4a', '.aac', '.ogg', '.flac', '.aiff', '.wma']);
-
-/** Timeout for ffmpeg operations. */
-const FFMPEG_TIMEOUT_MS = 120_000;
+import { randomUUID } from "node:crypto";
+import {
+  access,
+  mkdir,
+  readdir,
+  readFile,
+  unlink,
+  writeFile,
+} from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { extname, join } from "node:path";
+
+import { getConfig } from "../../../../config/loader.js";
+import { getAttachmentsByIds } from "../../../../memory/attachments-store.js";
+import type {
+  ToolContext,
+  ToolExecutionResult,
+} from "../../../../tools/types.js";
+import {
+  FFMPEG_TRANSCODE_TIMEOUT_MS,
+  FFPROBE_TIMEOUT_MS,
+  spawnWithTimeout,
+} from "../../../../util/spawn.js";
+
+const VIDEO_EXTENSIONS = new Set([
+  ".mp4",
+  ".mov",
+  ".avi",
+  ".mkv",
+  ".webm",
+  ".m4v",
+  ".mpeg",
+  ".mpg",
+]);
+const AUDIO_EXTENSIONS = new Set([
+  ".mp3",
+  ".wav",
+  ".m4a",
+  ".aac",
+  ".ogg",
+  ".flac",
+  ".aiff",
+  ".wma",
+]);
 
 /** Max file size for a single OpenAI Whisper API request (25MB). */
 const WHISPER_API_MAX_BYTES = 25 * 1024 * 1024;
@@ -29,32 +59,20 @@ const LOCAL_CHUNK_TIMEOUT_MS = 600_000;
 // Helpers
 // ---------------------------------------------------------------------------
 
-function spawnWithTimeout(
-  cmd: string[],
-  timeoutMs: number,
-): Promise<{ exitCode: number; stdout: string; stderr: string }> {
-  return new Promise((resolve, reject) => {
-    const proc = Bun.spawn(cmd, { stdout: 'pipe', stderr: 'pipe' });
-    const timer = setTimeout(() => {
-      proc.kill();
-      reject(new Error(`Process timed out after ${timeoutMs}ms: ${cmd[0]}`));
-    }, timeoutMs);
-    proc.exited.then(async (exitCode) => {
-      clearTimeout(timer);
-      const stdout = await new Response(proc.stdout).text();
-      const stderr = await new Response(proc.stderr).text();
-      resolve({ exitCode, stdout, stderr });
-    });
-  });
-}
-
 async function getAudioDuration(audioPath: string): Promise<number> {
-  const result = await spawnWithTimeout([
-    'ffprobe', '-v', 'error',
-    '-show_entries', 'format=duration',
-    '-of', 'csv=p=0',
-    audioPath,
-  ], 10_000);
+  const result = await spawnWithTimeout(
+    [
+      "ffprobe",
+      "-v",
+      "error",
+      "-show_entries",
+      "format=duration",
+      "-of",
+      "csv=p=0",
+      audioPath,
+    ],
+    FFPROBE_TIMEOUT_MS,
+  );
   if (result.exitCode !== 0) return 0;
   return parseFloat(result.stdout.trim()) || 0;
 }
@@ -64,25 +82,35 @@ async function splitAudio(
   chunkDir: string,
   chunkDurationSecs: number,
 ): Promise<string[]> {
-  const chunkPattern = join(chunkDir, 'chunk-%03d.wav');
-  const result = await spawnWithTimeout([
-    'ffmpeg', '-y',
-    '-i', audioPath,
-    '-f', 'segment',
-    '-segment_time', String(chunkDurationSecs),
-    '-acodec', 'pcm_s16le',
-    '-ar', '16000',
-    '-ac', '1',
-    chunkPattern,
-  ], FFMPEG_TIMEOUT_MS);
+  const chunkPattern = join(chunkDir, "chunk-%03d.wav");
+  const result = await spawnWithTimeout(
+    [
+      "ffmpeg",
+      "-y",
+      "-i",
+      audioPath,
+      "-f",
+      "segment",
+      "-segment_time",
+      String(chunkDurationSecs),
+      "-acodec",
+      "pcm_s16le",
+      "-ar",
+      "16000",
+      "-ac",
+      "1",
+      chunkPattern,
+    ],
+    FFMPEG_TRANSCODE_TIMEOUT_MS,
+  );
   if (result.exitCode !== 0) {
     throw new Error(`Failed to split audio: ${result.stderr.slice(0, 300)}`);
   }
   const files = await readdir(chunkDir);
   return files
-    .filter(f => f.startsWith('chunk-') && f.endsWith('.wav'))
+    .filter((f) => f.startsWith("chunk-") && f.endsWith(".wav"))
     .sort()
-    .map(f => join(chunkDir, f));
+    .map((f) => join(chunkDir, f));
 }
 
 // ---------------------------------------------------------------------------
@@ -91,19 +119,27 @@ async function splitAudio(
 
 async function resolveSource(
   input: Record<string, unknown>,
-): Promise<{ inputPath: string; isVideo: boolean; tempFile: string | null } | ToolExecutionResult> {
+): Promise<
+  | { inputPath: string; isVideo: boolean; tempFile: string | null }
+  | ToolExecutionResult
+> {
   const filePath = input.file_path as string | undefined;
   const attachmentId = input.attachment_id as string | undefined;
 
   if (filePath) {
-    try { await access(filePath); } catch {
+    try {
+      await access(filePath);
+    } catch {
       return { content: `File not found: ${filePath}`, isError: true };
     }
     const ext = extname(filePath).toLowerCase();
     const isVideo = VIDEO_EXTENSIONS.has(ext);
     const isAudio = AUDIO_EXTENSIONS.has(ext);
     if (!isVideo && !isAudio) {
-      return { content: `Unsupported file type: ${ext}. Only video and audio files can be transcribed.`, isError: true };
+      return {
+        content: `Unsupported file type: ${ext}. Only video and audio files can be transcribed.`,
+        isError: true,
+      };
     }
     return { inputPath: filePath, isVideo, tempFile: null };
   }
@@ -111,29 +147,45 @@ async function resolveSource(
   if (attachmentId) {
     const attachments = getAttachmentsByIds([attachmentId]);
     if (attachments.length === 0) {
-      return { content: `Attachment not found: ${attachmentId}`, isError: true };
+      return {
+        content: `Attachment not found: ${attachmentId}`,
+        isError: true,
+      };
     }
     const attachment = attachments[0];
     const mime = attachment.mimeType;
-    if (!mime.startsWith('video/') && !mime.startsWith('audio/')) {
-      return { content: `Unsupported file type: ${mime}. Only video and audio files can be transcribed.`, isError: true };
+    if (!mime.startsWith("video/") && !mime.startsWith("audio/")) {
+      return {
+        content: `Unsupported file type: ${mime}. Only video and audio files can be transcribed.`,
+        isError: true,
+      };
     }
-    const ext = mime.startsWith('video/') ? '.mp4' : '.m4a';
-    const tempPath = join(tmpdir(), `vellum-transcribe-in-${randomUUID()}${ext}`);
-    await writeFile(tempPath, Buffer.from(attachment.dataBase64, 'base64'));
-    return { inputPath: tempPath, isVideo: mime.startsWith('video/'), tempFile: tempPath };
+    const ext = mime.startsWith("video/") ? ".mp4" : ".m4a";
+    const tempPath = join(
+      tmpdir(),
+      `vellum-transcribe-in-${randomUUID()}${ext}`,
+    );
+    await writeFile(tempPath, Buffer.from(attachment.dataBase64, "base64"));
+    return {
+      inputPath: tempPath,
+      isVideo: mime.startsWith("video/"),
+      tempFile: tempPath,
+    };
   }
 
-  return { content: 'Provide either file_path or attachment_id.', isError: true };
+  return {
+    content: "Provide either file_path or attachment_id.",
+    isError: true,
+  };
 }
 
 /** Convert source to 16kHz mono WAV for consistent processing. */
 async function toWav(inputPath: string, isVideo: boolean): Promise<string> {
   const wavPath = join(tmpdir(), `vellum-transcribe-${randomUUID()}.wav`);
-  const args = ['ffmpeg', '-y', '-i', inputPath];
-  if (isVideo) args.push('-vn');
-  args.push('-acodec', 'pcm_s16le', '-ar', '16000', '-ac', '1', wavPath);
-  const result = await spawnWithTimeout(args, FFMPEG_TIMEOUT_MS);
+  const args = ["ffmpeg", "-y", "-i", inputPath];
+  if (isVideo) args.push("-vn");
+  args.push("-acodec", "pcm_s16le", "-ar", "16000", "-ac", "1", wavPath);
+  const result = await spawnWithTimeout(args, FFMPEG_TRANSCODE_TIMEOUT_MS);
   if (result.exitCode !== 0) {
     throw new Error(`ffmpeg failed: ${result.stderr.slice(0, 500)}`);
   }
@@ -158,48 +210,71 @@ async function transcribeViaApi(
   }
 
   // Split into chunks for large files
-  const chunkDir = join(tmpdir(), `vellum-transcribe-api-chunks-${randomUUID()}`);
+  const chunkDir = join(
+    tmpdir(),
+    `vellum-transcribe-api-chunks-${randomUUID()}`,
+  );
   await mkdir(chunkDir, { recursive: true });
 
   try {
-    context.onOutput?.(`Large file (${Math.round(duration / 60)}min) — splitting into chunks...\n`);
-    const chunks = await splitAudio(audioPath, chunkDir, API_CHUNK_DURATION_SECS);
+    context.onOutput?.(
+      `Large file (${Math.round(
+        duration / 60,
+      )}min) — splitting into chunks...\n`,
+    );
+    const chunks = await splitAudio(
+      audioPath,
+      chunkDir,
+      API_CHUNK_DURATION_SECS,
+    );
     const parts: string[] = [];
 
     for (let i = 0; i < chunks.length; i++) {
-      if (context.signal?.aborted) throw new Error('Cancelled');
+      if (context.signal?.aborted) throw new Error("Cancelled");
       context.onOutput?.(`  Transcribing chunk ${i + 1}/${chunks.length}...\n`);
       const text = await whisperApiRequest(chunks[i], apiKey);
       if (text) parts.push(text);
     }
 
-    return parts.join(' ');
+    return parts.join(" ");
   } finally {
-    const { rm } = await import('node:fs/promises');
+    const { rm } = await import("node:fs/promises");
     await rm(chunkDir, { recursive: true, force: true }).catch(() => {});
   }
 }
 
-async function whisperApiRequest(audioPath: string, apiKey: string): Promise<string> {
+async function whisperApiRequest(
+  audioPath: string,
+  apiKey: string,
+): Promise<string> {
   const audioData = await readFile(audioPath);
   const formData = new FormData();
-  formData.append('file', new Blob([audioData], { type: 'audio/wav' }), 'audio.wav');
-  formData.append('model', 'whisper-1');
-
-  const response = await fetch('https://api.openai.com/v1/audio/transcriptions', {
-    method: 'POST',
-    headers: { 'Authorization': `Bearer ${apiKey}` },
-    body: formData,
-    signal: AbortSignal.timeout(API_REQUEST_TIMEOUT_MS),
-  });
+  formData.append(
+    "file",
+    new Blob([audioData], { type: "audio/wav" }),
+    "audio.wav",
+  );
+  formData.append("model", "whisper-1");
+
+  const response = await fetch(
+    "https://api.openai.com/v1/audio/transcriptions",
+    {
+      method: "POST",
+      headers: { Authorization: `Bearer ${apiKey}` },
+      body: formData,
+      signal: AbortSignal.timeout(API_REQUEST_TIMEOUT_MS),
+    },
+  );
 
   if (!response.ok) {
-    const body = await response.text().catch(() => '');
-    throw new Error(`Whisper API error (${response.status}): ${body.slice(0, 300)}`);
+    const body = await response.text().catch(() => "");
+    throw new Error(
+      `Whisper API error (${response.status}): ${body.slice(0, 300)}`,
+    );
   }
 
-  const result = await response.json() as { text?: string };
-  return result.text?.trim() ?? '';
+  const result = (await response.json()) as { text?: string };
+  return result.text?.trim() ?? "";
 }
 
 // ---------------------------------------------------------------------------
@@ -211,10 +286,10 @@ async function transcribeViaLocal(
   context: ToolContext,
 ): Promise<string> {
   // Check if whisper-cpp is installed
-  const whichResult = await spawnWithTimeout(['which', 'whisper-cpp'], 5_000);
+  const whichResult = await spawnWithTimeout(["which", "whisper-cpp"], 5_000);
   if (whichResult.exitCode !== 0) {
     throw new Error(
-      'whisper-cpp is not installed. Install it with: brew install whisper-cpp'
+      "whisper-cpp is not installed. Install it with: brew install whisper-cpp",
     );
   }
 
@@ -225,54 +300,69 @@ async function transcribeViaLocal(
 
   if (duration > 0 && duration <= 1800) {
     // Under 30 minutes — transcribe directly (whisper.cpp handles long files well)
-    context.onOutput?.(`Transcribing ${Math.round(duration / 60)}min of audio locally...\n`);
+    context.onOutput?.(
+      `Transcribing ${Math.round(duration / 60)}min of audio locally...\n`,
+    );
     return await whisperCppRun(audioPath, modelPath);
   }
 
   // Very long files — split into 10-minute chunks to show progress
-  const chunkDir = join(tmpdir(), `vellum-transcribe-local-chunks-${randomUUID()}`);
+  const chunkDir = join(
+    tmpdir(),
+    `vellum-transcribe-local-chunks-${randomUUID()}`,
+  );
   await mkdir(chunkDir, { recursive: true });
 
   try {
-    context.onOutput?.(`Large file (${Math.round(duration / 60)}min) — splitting into chunks...\n`);
+    context.onOutput?.(
+      `Large file (${Math.round(
+        duration / 60,
+      )}min) — splitting into chunks...\n`,
+    );
     const chunks = await splitAudio(audioPath, chunkDir, 600);
     const parts: string[] = [];
 
     for (let i = 0; i < chunks.length; i++) {
-      if (context.signal?.aborted) throw new Error('Cancelled');
+      if (context.signal?.aborted) throw new Error("Cancelled");
       context.onOutput?.(`  Transcribing chunk ${i + 1}/${chunks.length}...\n`);
       const text = await whisperCppRun(chunks[i], modelPath);
       if (text) parts.push(text);
     }
 
-    return parts.join(' ');
+    return parts.join(" ");
   } finally {
-    const { rm } = await import('node:fs/promises');
+    const { rm } = await import("node:fs/promises");
     await rm(chunkDir, { recursive: true, force: true }).catch(() => {});
   }
 }
 
 async function resolveWhisperModel(context: ToolContext): Promise<string> {
   // Check common locations for the base model
-  const homeDir = process.env.HOME ?? '/tmp';
+  const homeDir = process.env.HOME ?? "/tmp";
   const candidates = [
-    join(homeDir, '.vellum', 'models', 'ggml-base.en.bin'),
-    join(homeDir, '.vellum', 'models', 'ggml-base.bin'),
-    '/usr/local/share/whisper-cpp/models/ggml-base.en.bin',
-    '/opt/homebrew/share/whisper-cpp/models/ggml-base.en.bin',
+    join(homeDir, ".vellum", "models", "ggml-base.en.bin"),
+    join(homeDir, ".vellum", "models", "ggml-base.bin"),
+    "/usr/local/share/whisper-cpp/models/ggml-base.en.bin",
+    "/opt/homebrew/share/whisper-cpp/models/ggml-base.en.bin",
   ];
 
   for (const p of candidates) {
-    try { await access(p); return p; } catch { /* next */ }
+    try {
+      await access(p);
+      return p;
+    } catch {
+      /* next */
+    }
   }
 
   // Download the base.en model (~140MB)
-  const modelDir = join(homeDir, '.vellum', 'models');
+  const modelDir = join(homeDir, ".vellum", "models");
   await mkdir(modelDir, { recursive: true });
-  const modelPath = join(modelDir, 'ggml-base.en.bin');
-  const modelUrl = 'https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-base.en.bin';
+  const modelPath = join(modelDir, "ggml-base.en.bin");
+  const modelUrl =
+    "https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-base.en.bin";
 
-  context.onOutput?.('Downloading Whisper base.en model (~140MB)...\n');
+  context.onOutput?.("Downloading Whisper base.en model (~140MB)...\n");
 
   const response = await fetch(modelUrl);
   if (!response.ok) {
@@ -281,18 +371,19 @@ async function resolveWhisperModel(context: ToolContext): Promise<string> {
 
   const data = Buffer.from(await response.arrayBuffer());
   await writeFile(modelPath, data);
-  context.onOutput?.('Model downloaded.\n');
+  context.onOutput?.("Model downloaded.\n");
 
   return modelPath;
 }
 
-async function whisperCppRun(audioPath: string, modelPath: string): Promise<string> {
-  const result = await spawnWithTimeout([
-    'whisper-cpp',
-    '-m', modelPath,
-    '-f', audioPath,
-    '--no-timestamps',
-  ], LOCAL_CHUNK_TIMEOUT_MS);
+async function whisperCppRun(
+  audioPath: string,
+  modelPath: string,
+): Promise<string> {
+  const result = await spawnWithTimeout(
+    ["whisper-cpp", "-m", modelPath, "-f", audioPath, "--no-timestamps"],
+    LOCAL_CHUNK_TIMEOUT_MS,
+  );
 
   if (result.exitCode !== 0) {
     throw new Error(`whisper-cpp failed: ${result.stderr.slice(0, 300)}`);
@@ -301,10 +392,10 @@ async function whisperCppRun(audioPath: string, modelPath: string): Promise<stri
   // whisper-cpp outputs transcription to stderr with some logging, and
   // the actual text lines to stdout. Clean up whitespace.
   return result.stdout
-    .split('\n')
-    .map(l => l.trim())
-    .filter(l => l.length > 0)
-    .join(' ')
+    .split("\n")
+    .map((l) => l.trim())
+    .filter((l) => l.length > 0)
+    .join(" ")
     .trim();
 }
 
@@ -316,28 +407,30 @@ export async function run(
   input: Record<string, unknown>,
   context: ToolContext,
 ): Promise<ToolExecutionResult> {
-  const mode = input.mode as 'api' | 'local';
-  if (!mode || (mode !== 'api' && mode !== 'local')) {
+  const mode = input.mode as "api" | "local";
+  if (!mode || (mode !== "api" && mode !== "local")) {
     return {
-      content: "Please specify mode: 'api' (OpenAI cloud) or 'local' (whisper.cpp on-device). Ask the user which they prefer.",
+      content:
+        "Please specify mode: 'api' (OpenAI cloud) or 'local' (whisper.cpp on-device). Ask the user which they prefer.",
       isError: true,
     };
   }
 
   // Validate API key for api mode
-  if (mode === 'api') {
+  if (mode === "api") {
     const config = getConfig();
     const apiKey = config.apiKeys.openai;
     if (!apiKey) {
       return {
-        content: 'No OpenAI API key configured. Set your OpenAI API key to use cloud transcription, or use mode "local" for on-device transcription with whisper.cpp.',
+        content:
+          'No OpenAI API key configured. Set your OpenAI API key to use cloud transcription, or use mode "local" for on-device transcription with whisper.cpp.',
         isError: true,
       };
     }
   }
 
   const source = await resolveSource(input);
-  if ('isError' in source) return source;
+  if ("isError" in source) return source;
 
   const { inputPath, isVideo, tempFile } = source;
   let wavPath: string | null = null;
@@ -347,7 +440,7 @@ export async function run(
     wavPath = await toWav(inputPath, isVideo);
 
     let text: string;
-    if (mode === 'api') {
+    if (mode === "api") {
       const config = getConfig();
       text = await transcribeViaApi(wavPath, config.apiKeys.openai!, context);
     } else {
@@ -355,7 +448,7 @@ export async function run(
     }
 
     if (!text.trim()) {
-      return { content: 'No speech detected in the audio.', isError: false };
+      return { content: "No speech detected in the audio.", isError: false };
     }
 
     return { content: text, isError: false };
@@ -365,7 +458,19 @@ export async function run(
       isError: true,
     };
   } finally {
-    if (tempFile) { try { await unlink(tempFile); } catch { /* ignore */ } }
-    if (wavPath) { try { await unlink(wavPath); } catch { /* ignore */ } }
+    if (tempFile) {
+      try {
+        await unlink(tempFile);
+      } catch {
+        /* ignore */
+      }
+    }
+    if (wavPath) {
+      try {
+        await unlink(wavPath);
+      } catch {
+        /* ignore */
+      }
+    }
   }
 }

package/src/config/bundled-skills/twilio-setup/SKILL.md

@@ -12,8 +12,7 @@ You are helping your user configure Twilio for voice calls and SMS messaging. Tw
 
 ```bash
 # 1. Check current status
-curl -s "$INTERNAL_GATEWAY_BASE_URL/v1/integrations/twilio/config" \
-  -H "Authorization: Bearer $GATEWAY_AUTH_TOKEN"
+vellum integrations twilio config --json
 # 2. Store credentials (after collecting via credential_store prompt)
 curl -s -X POST "$INTERNAL_GATEWAY_BASE_URL/v1/integrations/twilio/credentials" \
   -H "Authorization: Bearer $GATEWAY_AUTH_TOKEN" -H "Content-Type: application/json" \
@@ -35,11 +34,11 @@ This skill manages the full Twilio lifecycle:
 - **Phone number assignment** — Assign an existing Twilio number to the assistant
 - **Status checking** — Verify credentials and assigned number
 
-All operations go through the Twilio HTTP control-plane endpoints on the gateway, which validates inputs, stores credentials securely, and manages phone number state.
+Mutating operations use Twilio HTTP control-plane endpoints on the gateway. Status/list retrieval uses `vellum integrations ...` CLI reads.
 
 ### Multi-Assistant Setups
 
-In a multi-assistant environment (multiple assistants sharing the same daemon), some actions are **assistant-scoped** while others are **global** (shared across all assistants):
+In a multi-assistant environment (multiple assistants sharing the same runtime), some actions are **assistant-scoped** while others are **global** (shared across all assistants):
 
 **Global actions** (ignore `assistantId` — credentials are shared across all assistants):
 
@@ -66,8 +65,7 @@ All HTTP examples below include the optional `assistantId` query parameter in as
 First, check whether Twilio is already configured:
 
 ```bash
-curl -s "$INTERNAL_GATEWAY_BASE_URL/v1/integrations/twilio/config" \
-  -H "Authorization: Bearer $GATEWAY_AUTH_TOKEN"
+vellum integrations twilio config --json
 ```
 
 The response includes:
@@ -139,8 +137,7 @@ If ingress is not yet configured, webhook setup is skipped gracefully — the nu
 If the user already has a Twilio phone number, first list available numbers:
 
 ```bash
-curl -s "$INTERNAL_GATEWAY_BASE_URL/v1/integrations/twilio/numbers" \
-  -H "Authorization: Bearer $GATEWAY_AUTH_TOKEN"
+vellum integrations twilio numbers --json
 ```
 
 The response includes a `numbers` array with each number's `phoneNumber`, `friendlyName`, and `capabilities` (voice, SMS). Present these to the user and let them choose.
@@ -204,8 +201,7 @@ Webhook URLs are automatically configured on the Twilio phone number when provis
 After configuration, verify by checking the config endpoint again.
 
 ```bash
-curl -s "$INTERNAL_GATEWAY_BASE_URL/v1/integrations/twilio/config" \
-  -H "Authorization: Bearer $GATEWAY_AUTH_TOKEN"
+vellum integrations twilio config --json
 ```
 
 Confirm:
@@ -241,8 +237,7 @@ After the guardian-verify-setup skill completes (or the user skips), continue to
 To re-check guardian status later:
 
 ```bash
-curl -s "$INTERNAL_GATEWAY_BASE_URL/v1/integrations/guardian/status?channel=voice" \
-  -H "Authorization: Bearer $GATEWAY_AUTH_TOKEN"
+vellum integrations guardian status --channel voice --json
 ```
 
 ## Step 6: Enable Features