@vellumai/assistant 0.11.0 → 0.11.1-staging.2

package/src/tools/execution-target.ts

@@ -21,7 +21,9 @@ export function resolveExecutionTarget(tool: {
   name: string;
   executionTarget?: ExecutionTarget;
 }): ExecutionTarget {
-  if (tool.executionTarget) return tool.executionTarget;
+  if (tool.executionTarget) {
+    return tool.executionTarget;
+  }
   if (tool.name.startsWith("host_") || tool.name.startsWith("computer_use_")) {
     return "host";
   }

package/src/tools/filesystem/fuzzy-match.ts

@@ -20,8 +20,12 @@ export function levenshtein(a: string, b: string): number {
   const dp: number[][] = Array.from({ length: m + 1 }, () =>
     Array(n + 1).fill(0),
   );
-  for (let i = 0; i <= m; i++) dp[i][0] = i;
-  for (let j = 0; j <= n; j++) dp[0][j] = j;
+  for (let i = 0; i <= m; i++) {
+    dp[i][0] = i;
+  }
+  for (let j = 0; j <= n; j++) {
+    dp[0][j] = j;
+  }
   for (let i = 1; i <= m; i++) {
     for (let j = 1; j <= n; j++) {
       dp[i][j] =
@@ -35,7 +39,9 @@ export function levenshtein(a: string, b: string): number {
 
 function lineSimilarity(a: string, b: string): number {
   const maxLen = Math.max(a.length, b.length);
-  if (maxLen === 0) return 1;
+  if (maxLen === 0) {
+    return 1;
+  }
   return 1 - levenshtein(a, b) / maxLen;
 }
 
@@ -55,7 +61,9 @@ function indexLines(content: string): IndexedLine[] {
 
 function tryExactMatch(content: string, target: string): MatchResult | null {
   const idx = content.indexOf(target);
-  if (idx === -1) return null;
+  if (idx === -1) {
+    return null;
+  }
   return {
     start: idx,
     end: idx + target.length,
@@ -87,7 +95,9 @@ function tryWhitespaceMatch(
 ): MatchResult[] {
   const results: MatchResult[] = [];
   const windowSize = targetNorm.length;
-  if (windowSize === 0 || contentLines.length < windowSize) return results;
+  if (windowSize === 0 || contentLines.length < windowSize) {
+    return results;
+  }
 
   for (let i = 0; i <= contentLines.length - windowSize; i++) {
     let allMatch = true;
@@ -123,7 +133,9 @@ function tryFuzzyMatch(
 ): MatchResult[] {
   const results: MatchResult[] = [];
   const windowSize = targetNorm.length;
-  if (windowSize === 0 || contentLines.length < windowSize) return results;
+  if (windowSize === 0 || contentLines.length < windowSize) {
+    return results;
+  }
 
   for (let i = 0; i <= contentLines.length - windowSize; i++) {
     let totalSimilarity = 0;
@@ -156,36 +168,52 @@ function tryFuzzyMatch(
 const FUZZY_THRESHOLD = 0.8;
 
 export function findMatch(content: string, target: string): MatchResult | null {
-  if (target.length === 0) return null;
+  if (target.length === 0) {
+    return null;
+  }
 
   const exact = tryExactMatch(content, target);
-  if (exact) return exact;
+  if (exact) {
+    return exact;
+  }
 
   const contentLines = indexLines(content);
   const targetNorm = normalizeLines(target);
 
   const wsMatches = tryWhitespaceMatch(contentLines, targetNorm);
-  if (wsMatches.length === 1) return wsMatches[0];
-  if (wsMatches.length > 1) return wsMatches[0]; // findAllMatches handles ambiguity
+  if (wsMatches.length === 1) {
+    return wsMatches[0];
+  }
+  if (wsMatches.length > 1) {
+    return wsMatches[0];
+  } // findAllMatches handles ambiguity
 
   const fuzzyMatches = tryFuzzyMatch(contentLines, targetNorm, FUZZY_THRESHOLD);
-  if (fuzzyMatches.length === 0) return null;
+  if (fuzzyMatches.length === 0) {
+    return null;
+  }
 
   fuzzyMatches.sort((a, b) => b.similarity - a.similarity);
   return fuzzyMatches[0];
 }
 
 export function findAllMatches(content: string, target: string): MatchResult[] {
-  if (target.length === 0) return [];
+  if (target.length === 0) {
+    return [];
+  }
 
   const exactMatches = findAllExactMatches(content, target);
-  if (exactMatches.length > 0) return exactMatches;
+  if (exactMatches.length > 0) {
+    return exactMatches;
+  }
 
   const contentLines = indexLines(content);
   const targetNorm = normalizeLines(target);
 
   const wsMatches = tryWhitespaceMatch(contentLines, targetNorm);
-  if (wsMatches.length > 0) return wsMatches;
+  if (wsMatches.length > 0) {
+    return wsMatches;
+  }
 
   const fuzzyMatches = tryFuzzyMatch(contentLines, targetNorm, FUZZY_THRESHOLD);
   fuzzyMatches.sort((a, b) => b.similarity - a.similarity);
@@ -199,7 +227,9 @@ function getLeadingWhitespace(line: string): string {
 
 function findFirstNonEmptyLine(str: string): string | null {
   for (const line of str.split("\n")) {
-    if (line.trim().length > 0) return line;
+    if (line.trim().length > 0) {
+      return line;
+    }
   }
   return null;
 }
@@ -211,11 +241,15 @@ export function adjustIndentation(
 ): string {
   const oldLine = findFirstNonEmptyLine(oldString);
   const matchedLine = findFirstNonEmptyLine(matched);
-  if (!oldLine || !matchedLine) return newString;
+  if (!oldLine || !matchedLine) {
+    return newString;
+  }
 
   const oldIndent = getLeadingWhitespace(oldLine);
   const matchedIndent = getLeadingWhitespace(matchedLine);
-  if (oldIndent === matchedIndent) return newString;
+  if (oldIndent === matchedIndent) {
+    return newString;
+  }
 
   const oldLen = oldIndent.length;
   const matchedLen = matchedIndent.length;
@@ -223,7 +257,9 @@ export function adjustIndentation(
   return newString
     .split("\n")
     .map((line) => {
-      if (line.trim().length === 0) return line;
+      if (line.trim().length === 0) {
+        return line;
+      }
       const currentIndent = getLeadingWhitespace(line);
       if (matchedLen > oldLen) {
         const diff = matchedIndent.slice(0, matchedLen - oldLen);

package/src/tools/filesystem/search.ts

@@ -65,7 +65,9 @@ const MAX_CONTEXT_LINES = 20;
 function looksBinary(buf: Buffer): boolean {
   const len = Math.min(buf.length, 8000);
   for (let i = 0; i < len; i++) {
-    if (buf[i] === 0) return true;
+    if (buf[i] === 0) {
+      return true;
+    }
   }
   return false;
 }
@@ -263,7 +265,9 @@ export const codeSearchTool = {
     // Scan a single regular file for matches. Applies the denied-basename guard
     // and per-file size caps. Returns nothing; mutates the shared accumulators.
     const scanFile = (full: string, isExplicitRoot = false): void => {
-      if (truncated) return;
+      if (truncated) {
+        return;
+      }
 
       // Honor the wall-clock deadline / abort signal before doing any stat/size
       // work, not just inside the per-line loop. A tree full of oversized or
@@ -278,7 +282,9 @@ export const codeSearchTool = {
       // Never read files the assistant is forbidden from touching, even if a
       // broad pattern would otherwise match them. Reuses the same denylist as
       // file_read/file_write so the policies stay in sync.
-      if (isDeniedBasename(full)) return;
+      if (isDeniedBasename(full)) {
+        return;
+      }
 
       const rel = relative(root, full);
       // matchBase lets a slash-free pattern like "*.ts" match files at any
@@ -330,7 +336,9 @@ export const codeSearchTool = {
       }
       filesScanned++;
       totalBytes += buf.length;
-      if (looksBinary(buf)) return;
+      if (looksBinary(buf)) {
+        return;
+      }
 
       // Display path: when searching a single file at the root, `rel` is empty;
       // fall back to the basename so output stays readable.
@@ -357,7 +365,9 @@ export const codeSearchTool = {
         const line = fileLines[i];
         // Unanchored partial match anywhere in the line — the RE2 equivalent of
         // RegExp.prototype.test(). The compiled pattern is stateless per call.
-        if (!regex.test(line)) continue;
+        if (!regex.test(line)) {
+          continue;
+        }
         if (matchCount >= maxResults) {
           truncated = true;
           maxResultsHit = true;
@@ -378,23 +388,29 @@ export const codeSearchTool = {
               !pushLine(
                 `${display}:${j + 1}${sep} ${truncateForDisplay(fileLines[j])}`,
               )
-            )
+            ) {
               return;
+            }
+          }
+          if (!pushLine("--")) {
+            return;
           }
-          if (!pushLine("--")) return;
         } else {
           if (
             !pushLine(
               `${display}:${lineNo}: ${truncateForDisplay(fileLines[i])}`,
             )
-          )
+          ) {
             return;
+          }
         }
       }
     };
 
     const walk = (dir: string, isExplicitRoot = false): void => {
-      if (truncated) return;
+      if (truncated) {
+        return;
+      }
       // Bound the traversal itself, not just file reads: a deep/wide tree of
       // directories (or many entries that never get read) could otherwise run
       // the synchronous readdir/stat work far past the advertised deadline.
@@ -418,7 +434,9 @@ export const codeSearchTool = {
         return;
       }
       for (const entry of entries) {
-        if (truncated) return;
+        if (truncated) {
+          return;
+        }
         // Per-entry deadline/abort check (the Date.now()/.aborted reads are
         // negligible) plus a hard entry cap independent of wall-clock time so a
         // pathological tree is bounded even when every operation is fast.
@@ -437,11 +455,15 @@ export const codeSearchTool = {
         }
         const full = join(dir, entry.name);
         if (entry.isDirectory()) {
-          if (IGNORED_DIRS.has(entry.name)) continue;
+          if (IGNORED_DIRS.has(entry.name)) {
+            continue;
+          }
           walk(full);
           continue;
         }
-        if (!entry.isFile()) continue;
+        if (!entry.isFile()) {
+          continue;
+        }
         scanFile(full);
       }
     };

package/src/tools/filesystem/write.ts

@@ -37,9 +37,15 @@ const INLINE_SCRIPT_RE =
   /<script\b(?![^>]*\bsrc=)[^>]*>[\s\S]{400,}?<\/script>/i;
 
 function isSelfContainedArtifactHtml(path: string, content: string): boolean {
-  if (!/\.html?$/i.test(path)) return false;
-  if (content.length < 3000) return false;
-  if (!STANDALONE_HTML_RE.test(content)) return false;
+  if (!/\.html?$/i.test(path)) {
+    return false;
+  }
+  if (content.length < 3000) {
+    return false;
+  }
+  if (!STANDALONE_HTML_RE.test(content)) {
+    return false;
+  }
   return INLINE_SCRIPT_RE.test(content);
 }
 
@@ -55,7 +61,9 @@ const ARTIFACT_REDIRECT_MESSAGE =
 function isInsidePkbRoot(absPath: string, pkbRoot: string): boolean {
   const normalizedRoot = resolve(pkbRoot);
   const normalized = resolve(absPath);
-  if (normalized === normalizedRoot) return false;
+  if (normalized === normalizedRoot) {
+    return false;
+  }
   const rootWithSep = normalizedRoot.endsWith(sep)
     ? normalizedRoot
     : normalizedRoot + sep;

package/src/tools/network/__tests__/web-search-metadata.test.ts

@@ -15,9 +15,15 @@ function seedWebSearch(provider: string): void {
 
 mock.module("../../../security/secure-keys.js", () => ({
   getProviderKeyAsync: async (provider: string) => {
-    if (provider === "brave") return mockBraveSecureKey;
-    if (provider === "perplexity") return mockPerplexitySecureKey;
-    if (provider === "tavily") return mockTavilySecureKey;
+    if (provider === "brave") {
+      return mockBraveSecureKey;
+    }
+    if (provider === "perplexity") {
+      return mockPerplexitySecureKey;
+    }
+    if (provider === "tavily") {
+      return mockTavilySecureKey;
+    }
     return undefined;
   },
 }));

package/src/tools/network/__tests__/web-search.test.ts

@@ -8,6 +8,7 @@ let mockBraveSecureKey: string | undefined;
 let mockPerplexitySecureKey: string | undefined;
 let mockTavilySecureKey: string | undefined;
 let mockFirecrawlSecureKey: string | undefined;
+let mockKeenableSecureKey: string | undefined;
 let mockManagedSearchProxyResult: any;
 let mockManagedSearchAvailable = true;
 let mockManagedSearchProxyCalls: Array<{
@@ -28,10 +29,21 @@ function seedWebSearch(mode: string | undefined, provider: string): void {
 
 mock.module("../../../security/secure-keys.js", () => ({
   getProviderKeyAsync: async (provider: string) => {
-    if (provider === "brave") return mockBraveSecureKey;
-    if (provider === "perplexity") return mockPerplexitySecureKey;
-    if (provider === "tavily") return mockTavilySecureKey;
-    if (provider === "firecrawl") return mockFirecrawlSecureKey;
+    if (provider === "brave") {
+      return mockBraveSecureKey;
+    }
+    if (provider === "perplexity") {
+      return mockPerplexitySecureKey;
+    }
+    if (provider === "tavily") {
+      return mockTavilySecureKey;
+    }
+    if (provider === "firecrawl") {
+      return mockFirecrawlSecureKey;
+    }
+    if (provider === "keenable") {
+      return mockKeenableSecureKey;
+    }
     return undefined;
   },
 }));
@@ -74,6 +86,7 @@ describe("web_search tool", () => {
     mockPerplexitySecureKey = undefined;
     mockTavilySecureKey = undefined;
     mockFirecrawlSecureKey = undefined;
+    mockKeenableSecureKey = undefined;
     mockManagedSearchProxyCalls = [];
     mockManagedSearchAvailable = true;
     mockManagedSearchProxyResult = {
@@ -768,6 +781,100 @@ describe("web_search tool", () => {
     expect(callCount).toBe(4);
   });
 
+  // ---- Keenable provider (keyless by default) -----------------------------
+
+  test("executes Keenable search keyless (no key configured)", async () => {
+    seedWebSearch("your-own", "keenable");
+    // No key set — keyless must still run instead of erroring on a missing key.
+    let capturedUrl = "";
+    let capturedHeaders: any = null;
+    globalThis.fetch = (async (url: string, init?: RequestInit) => {
+      capturedUrl = url;
+      capturedHeaders = new Headers(init?.headers);
+      return new Response(
+        JSON.stringify({
+          results: [
+            {
+              title: "Keenable Result 1",
+              url: "https://example.com/keenable-1",
+              description: "First Keenable result",
+            },
+          ],
+        }),
+        { status: 200, headers: { "content-type": "application/json" } },
+      );
+    }) as any;
+
+    const result = await execute({ query: "what is RAG" });
+    expect(result.isError).toBe(false);
+    expect(capturedUrl).toContain("api.keenable.ai/v1/search/public");
+    expect(capturedHeaders.get("x-api-key")).toBeNull();
+    expect(capturedHeaders.get("x-keenable-title")).toBe("Vellum Assistant");
+    expect(result.content).toContain("Keenable Result 1");
+    expect(result.content).toContain("https://example.com/keenable-1");
+  });
+
+  test("Keenable uses the authenticated endpoint when a key is set", async () => {
+    seedWebSearch("your-own", "keenable");
+    mockKeenableSecureKey = "keen_test";
+    let capturedUrl = "";
+    let capturedBody: any = null;
+    let capturedHeaders: any = null;
+    globalThis.fetch = (async (url: string, init?: RequestInit) => {
+      capturedUrl = url;
+      capturedBody = JSON.parse(init?.body as string);
+      capturedHeaders = new Headers(init?.headers);
+      return new Response(JSON.stringify({ results: [] }), {
+        status: 200,
+        headers: { "content-type": "application/json" },
+      });
+    }) as any;
+
+    await execute({ query: "test query", count: 3, freshness: "pm" });
+    expect(capturedUrl).toContain("api.keenable.ai/v1/search");
+    expect(capturedUrl).not.toContain("/search/public");
+    expect(capturedHeaders.get("x-api-key")).toBe("keen_test");
+    expect(capturedBody.query).toBe("test query");
+    expect(capturedBody.mode).toBe("pro");
+    expect(typeof capturedBody.published_after).toBe("string");
+  });
+
+  test("Keenable trims results to the requested count", async () => {
+    seedWebSearch("your-own", "keenable");
+    globalThis.fetch = (async () => {
+      return new Response(
+        JSON.stringify({
+          results: [
+            { title: "A", url: "https://a.com", description: "a" },
+            { title: "B", url: "https://b.com", description: "b" },
+            { title: "C", url: "https://c.com", description: "c" },
+          ],
+        }),
+        { status: 200, headers: { "content-type": "application/json" } },
+      );
+    }) as any;
+
+    const result = await execute({ query: "test", count: 2 });
+    expect(result.content).toContain("A");
+    expect(result.content).toContain("B");
+    expect(result.content).not.toContain("https://c.com");
+  });
+
+  test.each([401, 403])("Keenable handles %d auth error", async (status) => {
+    seedWebSearch("your-own", "keenable");
+    mockKeenableSecureKey = "bad-key";
+    globalThis.fetch = (async () => {
+      return new Response(JSON.stringify({ message: "unauthorized" }), {
+        status,
+        headers: { "content-type": "application/json" },
+      });
+    }) as any;
+
+    const result = await execute({ query: "test" });
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("Invalid or expired Keenable API key");
+  });
+
   // ---- Firecrawl provider -------------------------------------------------
 
   test("executes Firecrawl search successfully", async () => {

package/src/tools/network/domain-normalize.ts

@@ -28,7 +28,9 @@ export interface DomainInfo {
  * (e.g. IP addresses, localhost, empty strings).
  */
 export function normalizeDomain(input: string): DomainInfo | null {
-  if (!input || typeof input !== "string") return null;
+  if (!input || typeof input !== "string") {
+    return null;
+  }
 
   let hostname: string;
 
@@ -53,7 +55,9 @@ export function normalizeDomain(input: string): DomainInfo | null {
   // Normalize: lowercase, strip trailing dot
   hostname = hostname.toLowerCase().replace(/\.$/, "");
 
-  if (!hostname) return null;
+  if (!hostname) {
+    return null;
+  }
 
   // Reject IP addresses and localhost - they don't have registrable domains
   if (isIPAddress(hostname) || hostname === "localhost") {
@@ -99,8 +103,12 @@ export function extractDomain(rawUrl: string): string {
 
 function isIPAddress(hostname: string): boolean {
   // IPv4
-  if (/^\d{1,3}(\.\d{1,3}){3}$/.test(hostname)) return true;
+  if (/^\d{1,3}(\.\d{1,3}){3}$/.test(hostname)) {
+    return true;
+  }
   // IPv6 (bracketed or bare)
-  if (hostname.startsWith("[") || hostname.includes(":")) return true;
+  if (hostname.startsWith("[") || hostname.includes(":")) {
+    return true;
+  }
   return false;
 }

package/src/tools/network/managed-search-proxy.ts

@@ -139,15 +139,23 @@ export async function callManagedSearchProxy(
 function isManagedSearchProxyResponse(
   value: unknown,
 ): value is ManagedSearchProxyResponse {
-  if (!isRecord(value)) return false;
-  if (typeof value.status !== "number") return false;
-  if (!isStringRecord(value.headers)) return false;
+  if (!isRecord(value)) {
+    return false;
+  }
+  if (typeof value.status !== "number") {
+    return false;
+  }
+  if (!isStringRecord(value.headers)) {
+    return false;
+  }
   return "body" in value;
 }
 
 async function readResponseBody(response: Response): Promise<unknown> {
   const text = await response.text().catch(() => "");
-  if (!text) return null;
+  if (!text) {
+    return null;
+  }
 
   const contentType = response.headers.get("content-type") ?? "";
   if (contentType.includes("application/json")) {
@@ -174,12 +182,18 @@ function platformErrorMessage(status: number, body: unknown): string {
 }
 
 function extractErrorDetail(body: unknown): string | undefined {
-  if (typeof body === "string") return body || undefined;
-  if (!isRecord(body)) return undefined;
+  if (typeof body === "string") {
+    return body || undefined;
+  }
+  if (!isRecord(body)) {
+    return undefined;
+  }
 
   for (const key of ["detail", "error", "message"]) {
     const value = body[key];
-    if (typeof value === "string" && value) return value;
+    if (typeof value === "string" && value) {
+      return value;
+    }
   }
 
   return undefined;
@@ -190,6 +204,8 @@ function isRecord(value: unknown): value is Record<string, unknown> {
 }
 
 function isStringRecord(value: unknown): value is Record<string, string> {
-  if (!isRecord(value)) return false;
+  if (!isRecord(value)) {
+    return false;
+  }
   return Object.values(value).every((entry) => typeof entry === "string");
 }

package/src/tools/network/script-proxy/session-manager.ts

@@ -101,11 +101,15 @@ const APPROVAL_HEADER_ALLOWLIST: readonly string[] = [
 function filterApprovalHeaders(
   raw: Record<string, string | string[] | undefined> | undefined,
 ): Record<string, string> | undefined {
-  if (!raw) return undefined;
+  if (!raw) {
+    return undefined;
+  }
   const out: Record<string, string> = {};
   for (const key of APPROVAL_HEADER_ALLOWLIST) {
     const value = raw[key];
-    if (value === undefined) continue;
+    if (value === undefined) {
+      continue;
+    }
     out[key] = Array.isArray(value) ? value.join(", ") : value;
   }
   return out;
@@ -149,9 +153,13 @@ async function buildInjectedValue(
       tpl.composeWith.service,
       tpl.composeWith.field,
     );
-    if (!composed) return null;
+    if (!composed) {
+      return null;
+    }
     const composedValue = await getSecureKeyAsync(composed.storageKey);
-    if (!composedValue) return null;
+    if (!composedValue) {
+      return null;
+    }
     value = `${value}${tpl.composeWith.separator}${composedValue}`;
   }
 
@@ -168,7 +176,9 @@ async function buildInjectedValue(
 function resolveInjectionTemplates(
   resolved: ResolvedCredential | undefined,
 ): CredentialInjectionTemplate[] {
-  if (!resolved) return [];
+  if (!resolved) {
+    return [];
+  }
   return resolved.injectionTemplates;
 }
 
@@ -243,11 +253,15 @@ function buildSessionStartHooks(): SessionStartHooks {
               let bestCandidates: CredentialInjectionTemplate[] = [];
 
               for (const tpl of tpls) {
-                if (tpl.injectionType === "query") continue;
+                if (tpl.injectionType === "query") {
+                  continue;
+                }
                 const match = matchHostPattern(req.hostname, tpl.hostPattern, {
                   includeApexForWildcard: true,
                 });
-                if (match === "none") continue;
+                if (match === "none") {
+                  continue;
+                }
 
                 const cmp = compareMatchSpecificity(match, bestMatch);
                 if (cmp < 0) {
@@ -266,9 +280,13 @@ function buildSessionStartHooks(): SessionStartHooks {
               }
             }
 
-            if (perCredentialBest.length === 0) return req.headers;
+            if (perCredentialBest.length === 0) {
+              return req.headers;
+            }
             // Cross-credential ambiguity - block
-            if (perCredentialBest.length > 1) return null;
+            if (perCredentialBest.length > 1) {
+              return null;
+            }
 
             const { credId, tpl } = perCredentialBest[0];
             log.debug(
@@ -282,9 +300,13 @@ function buildSessionStartHooks(): SessionStartHooks {
 
             if (tpl.injectionType === "header" && tpl.headerName) {
               const resolved = resolveById(credId);
-              if (!resolved) return req.headers;
+              if (!resolved) {
+                return req.headers;
+              }
               const value = await getSecureKeyAsync(resolved.storageKey);
-              if (!value) return req.headers;
+              if (!value) {
+                return req.headers;
+              }
 
               const headerValue = await buildInjectedValue(tpl, value);
               if (!headerValue) {
@@ -365,9 +387,13 @@ function buildSessionStartHooks(): SessionStartHooks {
           case "matched": {
             const { credentialId, template } = decision;
             const resolved = resolveById(credentialId);
-            if (!resolved) return {};
+            if (!resolved) {
+              return {};
+            }
             const value = await getSecureKeyAsync(resolved.storageKey);
-            if (!value) return {};
+            if (!value) {
+              return {};
+            }
 
             if (template.injectionType === "header" && template.headerName) {
               const headerValue = await buildInjectedValue(template, value);