@vellumai/assistant 0.11.0 → 0.11.1-staging.2

package/src/skills/install-meta.ts

@@ -172,10 +172,14 @@ function inferFromLegacyVersionJson(
 export function touchSkillLastUsed(skillDir: string, today: string): boolean {
   try {
     const meta = readInstallMeta(skillDir);
-    if (!meta) return false;
+    if (!meta) {
+      return false;
+    }
 
     // Compare only the date portion so multiple loads within a day are a no-op.
-    if (meta.lastUsedAt?.slice(0, 10) === today) return false;
+    if (meta.lastUsedAt?.slice(0, 10) === today) {
+      return false;
+    }
 
     writeInstallMeta(skillDir, {
       ...meta,
@@ -211,15 +215,18 @@ export function collectFileContents(
   prefix = "",
 ): Array<{ relPath: string; content: Buffer }> {
   const results: Array<{ relPath: string; content: Buffer }> = [];
-  if (!existsSync(dir)) return results;
+  if (!existsSync(dir)) {
+    return results;
+  }
 
   const entries = readdirSync(dir, { withFileTypes: true });
   for (const entry of entries) {
     // Exclude metadata files at the root level (prefix === "").
     // Only exclude actual files — a directory with a metadata name should
     // still be traversed so nested content contributes to the hash.
-    if (!prefix && entry.isFile() && METADATA_FILENAMES.has(entry.name))
+    if (!prefix && entry.isFile() && METADATA_FILENAMES.has(entry.name)) {
       continue;
+    }
 
     const relPath = prefix ? `${prefix}/${entry.name}` : entry.name;
     const fullPath = join(dir, entry.name);
@@ -242,10 +249,14 @@ export function collectFileContents(
  * different hashing strategy (v1: prefix) for version identity.
  */
 export function computeSkillHash(skillDir: string): string | null {
-  if (!existsSync(skillDir) || !statSync(skillDir).isDirectory()) return null;
+  if (!existsSync(skillDir) || !statSync(skillDir).isDirectory()) {
+    return null;
+  }
 
   const files = collectFileContents(skillDir);
-  if (files.length === 0) return null;
+  if (files.length === 0) {
+    return null;
+  }
 
   const hasher = new Bun.CryptoHasher("sha256");
   for (const file of files) {

package/src/skills/managed-store.ts

@@ -27,7 +27,9 @@ const log = getLogger("managed-store");
 const VALID_SKILL_ID = /^[a-z0-9][a-z0-9._-]*$/;
 
 export function validateManagedSkillId(id: string): string | null {
-  if (!id || typeof id !== "string") return "skill_id is required";
+  if (!id || typeof id !== "string") {
+    return "skill_id is required";
+  }
   if (id.includes("..") || id.includes("/") || id.includes("\\")) {
     return "skill_id must not contain path traversal characters";
   }

package/src/skills/remote-skill-policy.ts

@@ -78,9 +78,13 @@ function normalizeSkillsShRisk(
   audit: SkillsShAuditState | null | undefined,
 ): SkillsShRisk {
   const risk = audit?.risk;
-  if (risk == null) return "unknown";
+  if (risk == null) {
+    return "unknown";
+  }
   // Coerce unrecognized risk labels to 'unknown' so we fail closed.
-  if (!Object.hasOwn(SKILLS_SH_RISK_RANK, risk)) return "unknown";
+  if (!Object.hasOwn(SKILLS_SH_RISK_RANK, risk)) {
+    return "unknown";
+  }
   return risk;
 }
 

package/src/skills/skill-cache-store.ts

@@ -46,7 +46,9 @@ export function setCacheEntry(
   // drop the oldest entry (first key in Map iteration order).
   if (_store.size >= DEFAULT_MAX_ENTRIES) {
     const oldest = _store.keys().next().value;
-    if (oldest !== undefined) _store.delete(oldest);
+    if (oldest !== undefined) {
+      _store.delete(oldest);
+    }
   }
 
   _store.set(key, { data, expiresAt: Date.now() + ttl });
@@ -61,7 +63,9 @@ export function setCacheEntry(
  */
 export function getCacheEntry(key: string): { data: unknown } | null {
   const entry = _store.get(key);
-  if (!entry) return null;
+  if (!entry) {
+    return null;
+  }
 
   // Lazy TTL eviction.
   if (Date.now() >= entry.expiresAt) {

package/src/skills/skillssh-files.ts

@@ -61,7 +61,9 @@ function getCachedDirPath(
 ): string | null {
   const key = cacheKey(owner, repo, skillSlug);
   const entry = dirPathCache.get(key);
-  if (!entry) return null;
+  if (!entry) {
+    return null;
+  }
   if (Date.now() > entry.expiresAt) {
     dirPathCache.delete(key);
     return null;
@@ -110,7 +112,9 @@ async function resolveSkillDir(
 ): Promise<string | null> {
   // Check cache first
   const cached = getCachedDirPath(owner, repo, skillSlug);
-  if (cached !== null) return cached;
+  if (cached !== null) {
+    return cached;
+  }
 
   const headers = githubHeaders();
   const conventionalPath = `skills/${encodeURIComponent(skillSlug)}`;
@@ -185,19 +189,25 @@ async function listGitHubDir(
   }
 
   const entries = (await response.json()) as GitHubContentsEntry[];
-  if (!Array.isArray(entries)) return [];
+  if (!Array.isArray(entries)) {
+    return [];
+  }
 
   const result: SkillFileEntry[] = [];
 
   for (const entry of entries) {
     // Skip hidden files/dirs (same as walkSkillDir)
-    if (entry.name.startsWith(".")) continue;
+    if (entry.name.startsWith(".")) {
+      continue;
+    }
 
     const relativePath = prefix ? `${prefix}/${entry.name}` : entry.name;
 
     if (entry.type === "dir") {
       // Skip well-known heavyweight directories
-      if (SKIP_DIRS.has(entry.name)) continue;
+      if (SKIP_DIRS.has(entry.name)) {
+        continue;
+      }
 
       const subEntries = await listGitHubDir(
         owner,
@@ -211,7 +221,9 @@ async function listGitHubDir(
       continue;
     }
 
-    if (entry.type !== "file") continue;
+    if (entry.type !== "file") {
+      continue;
+    }
 
     result.push({
       path: relativePath,
@@ -249,7 +261,9 @@ export function createSkillsShProvider(): SkillFileProvider {
           source.skillSlug,
           source.ref,
         );
-        if (!dirPath) return null;
+        if (!dirPath) {
+          return null;
+        }
 
         const headers = githubHeaders();
         const entries = await listGitHubDir(
@@ -274,8 +288,12 @@ export function createSkillsShProvider(): SkillFileProvider {
     ): Promise<SkillFileEntry | null> {
       // Re-validate the path even though the caller should have sanitized
       const safe = sanitizeRelativePath(sanitizedPath);
-      if (!safe) return null;
-      if (hasHiddenOrSkippedSegment(safe)) return null;
+      if (!safe) {
+        return null;
+      }
+      if (hasHiddenOrSkippedSegment(safe)) {
+        return null;
+      }
 
       let source;
       try {
@@ -291,7 +309,9 @@ export function createSkillsShProvider(): SkillFileProvider {
           source.skillSlug,
           source.ref,
         );
-        if (!dirPath) return null;
+        if (!dirPath) {
+          return null;
+        }
 
         const headers = githubHeaders();
         const filePath = `${dirPath}/${safe}`;
@@ -307,14 +327,18 @@ export function createSkillsShProvider(): SkillFileProvider {
           signal: AbortSignal.timeout(15_000),
         });
 
-        if (!response.ok) return null;
+        if (!response.ok) {
+          return null;
+        }
 
         const entry = (await response.json()) as GitHubContentsEntry & {
           size?: number;
         };
 
         // Ensure it's a file, not a directory
-        if (entry.type !== "file") return null;
+        if (entry.type !== "file") {
+          return null;
+        }
 
         const name = basename(safe);
         const isBinary = classifyByName(name);
@@ -345,14 +369,18 @@ export function createSkillsShProvider(): SkillFileProvider {
         }
 
         // Fetch the actual file content via download_url
-        if (!entry.download_url) return null;
+        if (!entry.download_url) {
+          return null;
+        }
 
         const contentResponse = await fetch(entry.download_url, {
           headers,
           signal: AbortSignal.timeout(10_000),
         });
 
-        if (!contentResponse.ok) return null;
+        if (!contentResponse.ok) {
+          return null;
+        }
 
         const content = await contentResponse.text();
 

package/src/skills/skillssh-registry.ts

@@ -65,7 +65,9 @@ export function providerDisplayName(provider: string): string {
 
 export function formatAuditBadges(auditData: SkillAuditData): string {
   const providers = Object.keys(auditData);
-  if (providers.length === 0) return "Security: no audit data";
+  if (providers.length === 0) {
+    return "Security: no audit data";
+  }
 
   const badges = providers.map((provider) => {
     const audit = auditData[provider]!;
@@ -107,7 +109,9 @@ export async function fetchSkillAudits(
   source: string,
   skillSlugs: string[],
 ): Promise<AuditResponse> {
-  if (skillSlugs.length === 0) return {};
+  if (skillSlugs.length === 0) {
+    return {};
+  }
 
   const params = new URLSearchParams({
     source,
@@ -219,7 +223,9 @@ export async function findSkillDirInTree(
     headers,
     signal: AbortSignal.timeout(15_000),
   });
-  if (response.status === 404) return null;
+  if (response.status === 404) {
+    return null;
+  }
   if (!response.ok) {
     throw new Error(
       `GitHub API error while searching repo tree: HTTP ${response.status} ${response.statusText}`,
@@ -233,7 +239,9 @@ export async function findSkillDirInTree(
       entry.type === "blob" &&
       (entry.path === suffix || entry.path.endsWith(`/${suffix}`)),
   );
-  if (!match) return null;
+  if (!match) {
+    return null;
+  }
 
   // Return the directory containing SKILL.md (strip the trailing /SKILL.md)
   return match.path.slice(0, -"/SKILL.md".length);
@@ -299,7 +307,9 @@ export async function fetchSkillFromGitHub(
         continue;
       }
 
-      if (entry.type !== "file" || !entry.download_url) continue;
+      if (entry.type !== "file" || !entry.download_url) {
+        continue;
+      }
       const fileResponse = await fetch(entry.download_url, {
         headers,
         signal: AbortSignal.timeout(10_000),
@@ -369,7 +379,9 @@ export async function fetchSkillFromGitHub(
         Object.assign(result, subFiles);
         continue;
       }
-      if (entry.type !== "file" || !entry.download_url) continue;
+      if (entry.type !== "file" || !entry.download_url) {
+        continue;
+      }
       const fileResponse = await fetch(entry.download_url, {
         headers,
         signal: AbortSignal.timeout(10_000),

package/src/skills/validate-input.ts

@@ -84,18 +84,30 @@ export function coerceStringBooleans(
   input: Record<string, unknown>,
   schema: Record<string, unknown> | undefined,
 ): Record<string, unknown> {
-  if (!schema) return input;
+  if (!schema) {
+    return input;
+  }
   const properties = schema.properties;
-  if (!isPlainObject(properties)) return input;
+  if (!isPlainObject(properties)) {
+    return input;
+  }
 
   let coerced: Record<string, unknown> | undefined;
   for (const [key, rawSubSchema] of Object.entries(properties)) {
-    if (!isPlainObject(rawSubSchema)) continue;
-    if (rawSubSchema.type !== "boolean") continue;
+    if (!isPlainObject(rawSubSchema)) {
+      continue;
+    }
+    if (rawSubSchema.type !== "boolean") {
+      continue;
+    }
     const value = input[key];
-    if (typeof value !== "string") continue;
+    if (typeof value !== "string") {
+      continue;
+    }
     const normalized = value.trim().toLowerCase();
-    if (normalized !== "true" && normalized !== "false") continue;
+    if (normalized !== "true" && normalized !== "false") {
+      continue;
+    }
     coerced ??= { ...input };
     coerced[key] = normalized === "true";
   }
@@ -129,20 +141,32 @@ export function coerceStringNumbers(
   input: Record<string, unknown>,
   schema: Record<string, unknown> | undefined,
 ): Record<string, unknown> {
-  if (!schema) return input;
+  if (!schema) {
+    return input;
+  }
   const properties = schema.properties;
-  if (!isPlainObject(properties)) return input;
+  if (!isPlainObject(properties)) {
+    return input;
+  }
 
   let coerced: Record<string, unknown> | undefined;
   for (const [key, rawSubSchema] of Object.entries(properties)) {
-    if (!isPlainObject(rawSubSchema)) continue;
-    if (rawSubSchema.type !== "string") continue;
+    if (!isPlainObject(rawSubSchema)) {
+      continue;
+    }
+    if (rawSubSchema.type !== "string") {
+      continue;
+    }
     const value = input[key];
-    if (typeof value !== "number" || !Number.isFinite(value)) continue;
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+      continue;
+    }
     // An integer beyond the safe range was already rounded by JSON.parse;
     // coercing it would lock in a corrupted identifier. Skip it so validation
     // fails and the model retries with a lossless quoted string.
-    if (Number.isInteger(value) && !Number.isSafeInteger(value)) continue;
+    if (Number.isInteger(value) && !Number.isSafeInteger(value)) {
+      continue;
+    }
     coerced ??= { ...input };
     coerced[key] = String(value);
   }
@@ -164,9 +188,13 @@ export function validateInputAgainstSchema(
 ): InputValidationResult {
   // Skip when there's no schema or no properties block — matches today's
   // lenient behaviour for tools that declare only `{ type: "object" }`.
-  if (!schema) return { ok: true };
+  if (!schema) {
+    return { ok: true };
+  }
   const properties = schema.properties;
-  if (!isPlainObject(properties)) return { ok: true };
+  if (!isPlainObject(properties)) {
+    return { ok: true };
+  }
 
   const errors: string[] = [];
   const knownKeys = Object.keys(properties);
@@ -178,7 +206,9 @@ export function validateInputAgainstSchema(
   const required = schema.required;
   if (Array.isArray(required)) {
     for (const key of required) {
-      if (typeof key !== "string") continue;
+      if (typeof key !== "string") {
+        continue;
+      }
       if (!(key in input)) {
         errors.push(`${key} is required`);
       }
@@ -187,20 +217,28 @@ export function validateInputAgainstSchema(
 
   // 2. Per-property checks: type, enum, items.type.
   for (const [key, rawSubSchema] of Object.entries(properties)) {
-    if (!(key in input)) continue;
+    if (!(key in input)) {
+      continue;
+    }
     const value = input[key];
     // Skip type-checking for absent values; presence is enforced by the
     // `required` check above. Note: `null` IS a present value and is
     // type-checked below — only schemas that explicitly opt in to null via
     // a union type (`type: ["string","null"]`) bypass the check, handled
     // by the `Array.isArray(declaredType)` skip immediately below.
-    if (value === undefined) continue;
-    if (!isPlainObject(rawSubSchema)) continue;
+    if (value === undefined) {
+      continue;
+    }
+    if (!isPlainObject(rawSubSchema)) {
+      continue;
+    }
 
     const declaredType = rawSubSchema.type;
     // Skip union types (e.g. `["string", "null"]`) — same lenient treatment
     // we give `oneOf`/`anyOf`/`$ref`. We only validate single-type schemas.
-    if (Array.isArray(declaredType)) continue;
+    if (Array.isArray(declaredType)) {
+      continue;
+    }
     if (typeof declaredType === "string" && SUPPORTED_TYPES.has(declaredType)) {
       const type = declaredType as SupportedType;
       if (!matchesType(value, type)) {
@@ -252,7 +290,9 @@ export function validateInputAgainstSchema(
     );
   }
 
-  if (errors.length === 0) return { ok: true };
+  if (errors.length === 0) {
+    return { ok: true };
+  }
   return { ok: false, errors };
 }
 

package/src/skills/version-hash.ts

@@ -39,7 +39,9 @@ function collectFiles(
   } catch {
     return entries;
   }
-  if (ancestors.has(realDir)) return entries;
+  if (ancestors.has(realDir)) {
+    return entries;
+  }
   ancestors.add(realDir);
 
   let items: string[];
@@ -51,7 +53,9 @@ function collectFiles(
   }
 
   for (const name of items) {
-    if (EXCLUDED_NAMES.has(name)) continue;
+    if (EXCLUDED_NAMES.has(name)) {
+      continue;
+    }
     const full = join(dir, name);
     let stat;
     try {

package/src/stt/__tests__/daemon-batch-transcriber.test.ts

@@ -24,9 +24,25 @@ mock.module("../../providers/speech-to-text/openai-whisper.js", () => ({
 let mockDeepgramTranscribeResult: { text: string } = { text: "" };
 let mockDeepgramTranscribeError: Error | null = null;
 
+/**
+ * Captured DeepgramProvider constructor calls so tests can assert which
+ * options (language, model) the batch adapter forwards.
+ */
+const deepgramProviderCtorCalls: Array<{ apiKey: string; options: unknown }> =
+  [];
+
+// Real module captured before the mock replaces it, so pure exports
+// (deepgramLanguageOptions) stay real while the provider class
+// alone is stubbed.
+const actualDeepgram =
+  await import("../../providers/speech-to-text/deepgram.js");
+
 mock.module("../../providers/speech-to-text/deepgram.js", () => ({
+  ...actualDeepgram,
   DeepgramProvider: class MockDeepgramProvider {
-    constructor(_apiKey: string) {}
+    constructor(apiKey: string, options?: unknown) {
+      deepgramProviderCtorCalls.push({ apiKey, options });
+    }
     async transcribe(_audio: Buffer, _mimeType: string, _signal?: AbortSignal) {
       if (mockDeepgramTranscribeError) {
         throw mockDeepgramTranscribeError;
@@ -54,9 +70,22 @@ mock.module("../../providers/speech-to-text/google-gemini.js", () => ({
 let mockXAITranscribeResult: { text: string } = { text: "" };
 let mockXAITranscribeError: Error | null = null;
 
+/**
+ * Captured XAIProvider constructor calls so tests can assert which options
+ * (language) the batch adapter forwards.
+ */
+const xaiProviderCtorCalls: Array<{ apiKey: string; options: unknown }> = [];
+
+// Real module captured before the mock replaces it, so pure exports
+// (xaiLanguageOptions) stay real while the provider class alone is stubbed.
+const actualXai = await import("../../providers/speech-to-text/xai.js");
+
 mock.module("../../providers/speech-to-text/xai.js", () => ({
+  ...actualXai,
   XAIProvider: class MockXAIProvider {
-    constructor(_apiKey: string) {}
+    constructor(apiKey: string, options?: unknown) {
+      xaiProviderCtorCalls.push({ apiKey, options });
+    }
     async transcribe(_audio: Buffer, _mimeType: string, _signal?: AbortSignal) {
       if (mockXAITranscribeError) {
         throw mockXAITranscribeError;
@@ -80,10 +109,12 @@ describe("createDaemonBatchTranscriber", () => {
     mockWhisperTranscribeError = null;
     mockDeepgramTranscribeResult = { text: "" };
     mockDeepgramTranscribeError = null;
+    deepgramProviderCtorCalls.length = 0;
     mockGeminiTranscribeResult = { text: "" };
     mockGeminiTranscribeError = null;
     mockXAITranscribeResult = { text: "" };
     mockXAITranscribeError = null;
+    xaiProviderCtorCalls.length = 0;
   });
 
   // -------------------------------------------------------------------------
@@ -245,6 +276,64 @@ describe("createDaemonBatchTranscriber", () => {
     }
   });
 
+  // -------------------------------------------------------------------------
+  // Language forwarding - Deepgram
+  // -------------------------------------------------------------------------
+
+  test("forwards the configured language to the Deepgram provider", async () => {
+    const transcriber = createDaemonBatchTranscriber(
+      "dg-test-key",
+      "deepgram",
+      "hi",
+    );
+    await transcriber!.transcribe({
+      audio: Buffer.from("fake-audio"),
+      mimeType: "audio/ogg",
+    });
+
+    expect(deepgramProviderCtorCalls).toHaveLength(1);
+    expect(deepgramProviderCtorCalls[0]?.options).toMatchObject({
+      language: "hi",
+      // Any configured language pins nova-3, the model the roster is
+      // verified for; the provider default (nova-2) covers only a subset.
+      model: "nova-3",
+    });
+  });
+
+  test("pins nova-3 on the Deepgram provider when language is 'multi'", async () => {
+    // multi is a nova-3-only code-switching feature; the provider's default
+    // model (nova-2) rejects it.
+    const transcriber = createDaemonBatchTranscriber(
+      "dg-test-key",
+      "deepgram",
+      "multi",
+    );
+    await transcriber!.transcribe({
+      audio: Buffer.from("fake-audio"),
+      mimeType: "audio/ogg",
+    });
+
+    expect(deepgramProviderCtorCalls).toHaveLength(1);
+    expect(deepgramProviderCtorCalls[0]?.options).toMatchObject({
+      language: "multi",
+      model: "nova-3",
+    });
+  });
+
+  test("passes neither language nor model to Deepgram when no language is configured", async () => {
+    const transcriber = createDaemonBatchTranscriber("dg-test-key", "deepgram");
+    await transcriber!.transcribe({
+      audio: Buffer.from("fake-audio"),
+      mimeType: "audio/ogg",
+    });
+
+    expect(deepgramProviderCtorCalls).toHaveLength(1);
+    expect(deepgramProviderCtorCalls[0]?.options).not.toHaveProperty(
+      "language",
+    );
+    expect(deepgramProviderCtorCalls[0]?.options).not.toHaveProperty("model");
+  });
+
   // -------------------------------------------------------------------------
   // Null on missing key — Deepgram
   // -------------------------------------------------------------------------
@@ -381,6 +470,51 @@ describe("createDaemonBatchTranscriber", () => {
     }
   });
 
+  // -------------------------------------------------------------------------
+  // Language forwarding - xAI
+  // -------------------------------------------------------------------------
+
+  test("forwards the configured language to the xAI provider", async () => {
+    const transcriber = createDaemonBatchTranscriber(
+      "xai-test-key",
+      "xai",
+      "hi",
+    );
+    await transcriber!.transcribe({
+      audio: Buffer.from("fake-audio"),
+      mimeType: "audio/ogg",
+    });
+
+    expect(xaiProviderCtorCalls).toHaveLength(1);
+    expect(xaiProviderCtorCalls[0]?.options).toMatchObject({ language: "hi" });
+  });
+
+  test("never passes 'multi' to the xAI provider (a Deepgram-specific value, not a language code)", async () => {
+    const transcriber = createDaemonBatchTranscriber(
+      "xai-test-key",
+      "xai",
+      "multi",
+    );
+    await transcriber!.transcribe({
+      audio: Buffer.from("fake-audio"),
+      mimeType: "audio/ogg",
+    });
+
+    expect(xaiProviderCtorCalls).toHaveLength(1);
+    expect(xaiProviderCtorCalls[0]?.options).not.toHaveProperty("language");
+  });
+
+  test("passes no language to the xAI provider when none is configured", async () => {
+    const transcriber = createDaemonBatchTranscriber("xai-test-key", "xai");
+    await transcriber!.transcribe({
+      audio: Buffer.from("fake-audio"),
+      mimeType: "audio/ogg",
+    });
+
+    expect(xaiProviderCtorCalls).toHaveLength(1);
+    expect(xaiProviderCtorCalls[0]?.options).not.toHaveProperty("language");
+  });
+
   // -------------------------------------------------------------------------
   // Null on missing key — xAI
   // -------------------------------------------------------------------------