@vellumai/assistant 0.4.26 → 0.4.30

package/src/util/diff.ts

@@ -4,7 +4,7 @@
  */
 
 interface DiffEntry {
-  type: 'same' | 'add' | 'remove';
+  type: "same" | "add" | "remove";
   line: string;
 }
 
@@ -16,7 +16,9 @@ function computeLineDiff(oldLines: string[], newLines: string[]): DiffEntry[] {
   const m = oldLines.length;
   const n = newLines.length;
 
-  const dp: number[][] = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0));
+  const dp: number[][] = Array.from({ length: m + 1 }, () =>
+    Array(n + 1).fill(0),
+  );
   for (let i = 1; i <= m; i++) {
     for (let j = 1; j <= n; j++) {
       if (oldLines[i - 1] === newLines[j - 1]) {
@@ -28,16 +30,18 @@ function computeLineDiff(oldLines: string[], newLines: string[]): DiffEntry[] {
   }
 
   const result: DiffEntry[] = [];
-  let i = m, j = n;
+  let i = m,
+    j = n;
   while (i > 0 || j > 0) {
     if (i > 0 && j > 0 && oldLines[i - 1] === newLines[j - 1]) {
-      result.unshift({ type: 'same', line: oldLines[i - 1] });
-      i--; j--;
+      result.unshift({ type: "same", line: oldLines[i - 1] });
+      i--;
+      j--;
     } else if (j > 0 && (i === 0 || dp[i][j - 1] >= dp[i - 1][j])) {
-      result.unshift({ type: 'add', line: newLines[j - 1] });
+      result.unshift({ type: "add", line: newLines[j - 1] });
       j--;
     } else {
-      result.unshift({ type: 'remove', line: oldLines[i - 1] });
+      result.unshift({ type: "remove", line: oldLines[i - 1] });
       i--;
     }
   }
@@ -62,8 +66,11 @@ const DEFAULT_MAX_EXACT_DIFF_LINES = 1000;
 function buildHunks(entries: DiffEntry[]): Hunk[] {
   const changeRanges: Array<{ start: number; end: number }> = [];
   for (let i = 0; i < entries.length; i++) {
-    if (entries[i].type !== 'same') {
-      if (changeRanges.length > 0 && i - changeRanges[changeRanges.length - 1].end <= CONTEXT_LINES * 2) {
+    if (entries[i].type !== "same") {
+      if (
+        changeRanges.length > 0 &&
+        i - changeRanges[changeRanges.length - 1].end <= CONTEXT_LINES * 2
+      ) {
         changeRanges[changeRanges.length - 1].end = i + 1;
       } else {
         changeRanges.push({ start: i, end: i + 1 });
@@ -77,16 +84,18 @@ function buildHunks(entries: DiffEntry[]): Hunk[] {
     const contextEnd = Math.min(entries.length, range.end + CONTEXT_LINES);
     const hunkEntries = entries.slice(contextStart, contextEnd);
 
-    let oldLine = 1, newLine = 1;
+    let oldLine = 1,
+      newLine = 1;
     for (let i = 0; i < contextStart; i++) {
-      if (entries[i].type === 'same' || entries[i].type === 'remove') oldLine++;
-      if (entries[i].type === 'same' || entries[i].type === 'add') newLine++;
+      if (entries[i].type === "same" || entries[i].type === "remove") oldLine++;
+      if (entries[i].type === "same" || entries[i].type === "add") newLine++;
     }
 
-    let oldCount = 0, newCount = 0;
+    let oldCount = 0,
+      newCount = 0;
     for (const entry of hunkEntries) {
-      if (entry.type === 'same' || entry.type === 'remove') oldCount++;
-      if (entry.type === 'same' || entry.type === 'add') newCount++;
+      if (entry.type === "same" || entry.type === "remove") oldCount++;
+      if (entry.type === "same" || entry.type === "add") newCount++;
     }
 
     hunks.push({
@@ -102,17 +111,21 @@ function buildHunks(entries: DiffEntry[]): Hunk[] {
 }
 
 // ANSI color codes
-const RED = '\x1b[31m';
-const GREEN = '\x1b[32m';
-const CYAN = '\x1b[36m';
-const DIM = '\x1b[2m';
-const RESET = '\x1b[0m';
+const RED = "\x1b[31m";
+const GREEN = "\x1b[32m";
+const CYAN = "\x1b[36m";
+const DIM = "\x1b[2m";
+const RESET = "\x1b[0m";
 
 export interface FormatDiffOptions {
   maxExactLines?: number;
 }
 
-function formatLargeDiffFallback(oldLines: string[], newLines: string[], filePath: string): string {
+function formatLargeDiffFallback(
+  oldLines: string[],
+  newLines: string[],
+  filePath: string,
+): string {
   let output = `${DIM}--- a/${filePath}${RESET}\n`;
   output += `${DIM}+++ b/${filePath}${RESET}\n`;
   output += `${CYAN}@@ -1,${oldLines.length} +1,${newLines.length} @@${RESET}\n`;
@@ -137,10 +150,10 @@ export function formatDiff(
   filePath: string,
   options: FormatDiffOptions = {},
 ): string {
-  if (oldContent === newContent) return '';
+  if (oldContent === newContent) return "";
 
-  const oldLines = oldContent.split('\n');
-  const newLines = newContent.split('\n');
+  const oldLines = oldContent.split("\n");
+  const newLines = newContent.split("\n");
   const maxExactLines = options.maxExactLines ?? DEFAULT_MAX_EXACT_DIFF_LINES;
 
   // Guard against quadratic blowup on large files
@@ -151,7 +164,7 @@ export function formatDiff(
   const entries = computeLineDiff(oldLines, newLines);
   const hunks = buildHunks(entries);
 
-  if (hunks.length === 0) return '';
+  if (hunks.length === 0) return "";
 
   let output = `${DIM}--- a/${filePath}${RESET}\n`;
   output += `${DIM}+++ b/${filePath}${RESET}\n`;
@@ -160,13 +173,13 @@ export function formatDiff(
     output += `${CYAN}@@ -${hunk.oldStart},${hunk.oldCount} +${hunk.newStart},${hunk.newCount} @@${RESET}\n`;
     for (const entry of hunk.lines) {
       switch (entry.type) {
-        case 'same':
+        case "same":
           output += ` ${entry.line}\n`;
           break;
-        case 'remove':
+        case "remove":
           output += `${RED}-${entry.line}${RESET}\n`;
           break;
-        case 'add':
+        case "add":
           output += `${GREEN}+${entry.line}${RESET}\n`;
           break;
       }
@@ -181,10 +194,17 @@ export function formatDiff(
  * Truncates to maxLines to avoid flooding the terminal.
  * Pass `null` for unbounded output.
  */
-export function formatNewFileDiff(content: string, filePath: string, maxLines: number | null = 20): string {
-  const lines = content.split('\n');
-  const shouldTruncate = typeof maxLines === 'number' && Number.isFinite(maxLines);
-  const boundedMaxLines = shouldTruncate ? Math.max(0, Math.floor(maxLines)) : lines.length;
+export function formatNewFileDiff(
+  content: string,
+  filePath: string,
+  maxLines: number | null = 20,
+): string {
+  const lines = content.split("\n");
+  const shouldTruncate =
+    typeof maxLines === "number" && Number.isFinite(maxLines);
+  const boundedMaxLines = shouldTruncate
+    ? Math.max(0, Math.floor(maxLines))
+    : lines.length;
   const truncated = lines.length > boundedMaxLines;
   const displayLines = truncated ? lines.slice(0, boundedMaxLines) : lines;
 
@@ -197,7 +217,9 @@ export function formatNewFileDiff(content: string, filePath: string, maxLines: n
   }
 
   if (truncated) {
-    output += `${DIM}... ${lines.length - boundedMaxLines} more lines${RESET}\n`;
+    output += `${DIM}... ${
+      lines.length - boundedMaxLines
+    } more lines${RESET}\n`;
   }
 
   return output;

package/src/util/errors.ts

@@ -1,36 +1,36 @@
 export enum ErrorCode {
   // Provider errors
-  PROVIDER_ERROR = 'PROVIDER_ERROR',
+  PROVIDER_ERROR = "PROVIDER_ERROR",
 
   // Tool errors
-  TOOL_ERROR = 'TOOL_ERROR',
+  TOOL_ERROR = "TOOL_ERROR",
 
   // Permission errors
-  PERMISSION_DENIED = 'PERMISSION_DENIED',
+  PERMISSION_DENIED = "PERMISSION_DENIED",
 
   // Config errors
-  CONFIG_ERROR = 'CONFIG_ERROR',
+  CONFIG_ERROR = "CONFIG_ERROR",
 
   // Daemon errors
-  DAEMON_ERROR = 'DAEMON_ERROR',
+  DAEMON_ERROR = "DAEMON_ERROR",
 
   // IPC/socket errors
-  IPC_ERROR = 'IPC_ERROR',
+  IPC_ERROR = "IPC_ERROR",
 
   // Platform-specific errors (clipboard, unsupported OS features)
-  PLATFORM_ERROR = 'PLATFORM_ERROR',
+  PLATFORM_ERROR = "PLATFORM_ERROR",
 
   // WASM integrity check failures
-  INTEGRITY_ERROR = 'INTEGRITY_ERROR',
+  INTEGRITY_ERROR = "INTEGRITY_ERROR",
 
   // Rate limit exceeded
-  RATE_LIMIT_ERROR = 'RATE_LIMIT_ERROR',
+  RATE_LIMIT_ERROR = "RATE_LIMIT_ERROR",
 
   // Secret detected in inbound content
-  INGRESS_BLOCKED = 'INGRESS_BLOCKED',
+  INGRESS_BLOCKED = "INGRESS_BLOCKED",
 
   // Internal/unexpected errors
-  INTERNAL_ERROR = 'INTERNAL_ERROR',
+  INTERNAL_ERROR = "INTERNAL_ERROR",
 }
 
 // ── Root ──────────────────────────────────────────────────────────────────────
@@ -39,7 +39,7 @@ export enum ErrorCode {
 export class VellumError extends Error {
   constructor(message: string, options?: ErrorOptions) {
     super(message, options);
-    this.name = 'VellumError';
+    this.name = "VellumError";
   }
 }
 
@@ -52,7 +52,7 @@ export class VellumError extends Error {
 export class BackendError extends VellumError {
   constructor(message: string, options?: ErrorOptions) {
     super(message, options);
-    this.name = 'BackendError';
+    this.name = "BackendError";
   }
 }
 
@@ -63,7 +63,7 @@ export class BackendError extends VellumError {
 export class BackendUnavailableError extends BackendError {
   constructor(reason: string) {
     super(reason);
-    this.name = 'BackendUnavailableError';
+    this.name = "BackendUnavailableError";
   }
 }
 
@@ -74,7 +74,7 @@ export class BackendUnavailableError extends BackendError {
 export class RateLimitError extends BackendError {
   constructor(message: string) {
     super(message);
-    this.name = 'RateLimitError';
+    this.name = "RateLimitError";
   }
 }
 
@@ -87,7 +87,7 @@ export class RateLimitError extends BackendError {
 export class UserError extends VellumError {
   constructor(message: string, options?: ErrorOptions) {
     super(message, options);
-    this.name = 'UserError';
+    this.name = "UserError";
   }
 }
 
@@ -104,19 +104,23 @@ export class AssistantError extends VellumError {
     options?: { cause?: unknown },
   ) {
     super(message, options);
-    this.name = 'AssistantError';
+    this.name = "AssistantError";
   }
 }
 
 export class ProviderError extends AssistantError {
+  /** Delay (in ms) suggested by the server's Retry-After header, if present. */
+  public readonly retryAfterMs?: number;
+
   constructor(
     message: string,
     public readonly provider: string,
     public readonly statusCode?: number,
-    options?: { cause?: unknown },
+    options?: { cause?: unknown; retryAfterMs?: number },
   ) {
     super(message, ErrorCode.PROVIDER_ERROR, options);
-    this.name = 'ProviderError';
+    this.name = "ProviderError";
+    this.retryAfterMs = options?.retryAfterMs;
   }
 }
 
@@ -126,7 +130,7 @@ export class ToolError extends AssistantError {
     public readonly toolName: string,
   ) {
     super(message, ErrorCode.TOOL_ERROR);
-    this.name = 'ToolError';
+    this.name = "ToolError";
   }
 }
 
@@ -136,42 +140,42 @@ export class PermissionDeniedError extends AssistantError {
     public readonly toolName: string,
   ) {
     super(message, ErrorCode.PERMISSION_DENIED);
-    this.name = 'PermissionDeniedError';
+    this.name = "PermissionDeniedError";
   }
 }
 
 export class ConfigError extends AssistantError {
   constructor(message: string, options?: { cause?: unknown }) {
     super(message, ErrorCode.CONFIG_ERROR, options);
-    this.name = 'ConfigError';
+    this.name = "ConfigError";
   }
 }
 
 export class DaemonError extends AssistantError {
   constructor(message: string, options?: { cause?: unknown }) {
     super(message, ErrorCode.DAEMON_ERROR, options);
-    this.name = 'DaemonError';
+    this.name = "DaemonError";
   }
 }
 
 export class IpcError extends AssistantError {
   constructor(message: string, options?: { cause?: unknown }) {
     super(message, ErrorCode.IPC_ERROR, options);
-    this.name = 'IpcError';
+    this.name = "IpcError";
   }
 }
 
 export class PlatformError extends AssistantError {
   constructor(message: string, options?: { cause?: unknown }) {
     super(message, ErrorCode.PLATFORM_ERROR, options);
-    this.name = 'PlatformError';
+    this.name = "PlatformError";
   }
 }
 
 export class IntegrityError extends AssistantError {
   constructor(message: string, options?: { cause?: unknown }) {
     super(message, ErrorCode.INTEGRITY_ERROR, options);
-    this.name = 'IntegrityError';
+    this.name = "IntegrityError";
   }
 }
 
@@ -181,6 +185,6 @@ export class IngressBlockedError extends AssistantError {
     public readonly detectedTypes: string[],
   ) {
     super(message, ErrorCode.INGRESS_BLOCKED);
-    this.name = 'IngressBlockedError';
+    this.name = "IngressBlockedError";
   }
 }

package/src/util/fs.ts

@@ -6,7 +6,13 @@
  * from 'node:fs' for these patterns.
  */
 
-import { existsSync, mkdirSync, readFileSync, type Stats,statSync } from 'node:fs';
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  type Stats,
+  statSync,
+} from "node:fs";
 
 /** Check whether a path (file or directory) exists on disk. */
 export function pathExists(path: string): boolean {
@@ -24,7 +30,7 @@ export function ensureDir(dir: string): void {
 export function readTextFileSync(path: string): string | null {
   try {
     if (!existsSync(path)) return null;
-    return readFileSync(path, 'utf-8');
+    return readFileSync(path, "utf-8");
   } catch {
     return null;
   }

package/src/util/log-redact.ts

@@ -47,12 +47,12 @@ const API_KEY_PATTERNS: RegExp[] = [
 
 // Header names whose values should always be fully redacted
 const SENSITIVE_HEADERS = new Set([
-  'authorization',
-  'proxy-authorization',
-  'cookie',
-  'set-cookie',
-  'x-api-key',
-  'x-auth-token',
+  "authorization",
+  "proxy-authorization",
+  "cookie",
+  "set-cookie",
+  "x-api-key",
+  "x-auth-token",
 ]);
 
 // ---------------------------------------------------------------------------
@@ -63,12 +63,12 @@ function redactString(value: string): string {
   let result = value;
 
   // Redact bearer tokens
-  result = result.replace(BEARER_RE, 'Bearer [REDACTED]');
+  result = result.replace(BEARER_RE, "Bearer [REDACTED]");
 
   // Redact API key patterns
   for (const pattern of API_KEY_PATTERNS) {
     pattern.lastIndex = 0;
-    result = result.replace(pattern, '[REDACTED]');
+    result = result.replace(pattern, "[REDACTED]");
   }
 
   return result;
@@ -81,7 +81,7 @@ function redactString(value: string): string {
 function redactValue(value: unknown, depth: number): unknown {
   if (depth > 8) return value;
 
-  if (typeof value === 'string') {
+  if (typeof value === "string") {
     return redactString(value);
   }
 
@@ -89,13 +89,13 @@ function redactValue(value: unknown, depth: number): unknown {
     return value.map((item) => redactValue(item, depth + 1));
   }
 
-  if (value != null && typeof value === 'object') {
+  if (value != null && typeof value === "object") {
     const result: Record<string, unknown> = {};
     for (const [key, val] of Object.entries(value as Record<string, unknown>)) {
       const lowerKey = key.toLowerCase();
       // Fully redact sensitive header values
       if (SENSITIVE_HEADERS.has(lowerKey)) {
-        result[key] = '[REDACTED]';
+        result[key] = "[REDACTED]";
       } else {
         result[key] = redactValue(val, depth + 1);
       }
@@ -123,7 +123,7 @@ function serializeError(err: unknown, depth: number): unknown {
   };
 
   // AssistantError and subclasses carry a structured ErrorCode
-  if ('code' in err && typeof (err as { code: unknown }).code === 'string') {
+  if ("code" in err && typeof (err as { code: unknown }).code === "string") {
     serialized.code = (err as { code: string }).code;
   }