@vellumai/assistant 0.3.5 → 0.3.7

package/src/config/core-schema.ts

@@ -0,0 +1,309 @@
+import { z } from 'zod';
+
+const VALID_SECRET_ACTIONS = ['redact', 'warn', 'block', 'prompt'] as const;
+const VALID_PERMISSIONS_MODES = ['legacy', 'strict', 'workspace'] as const;
+const VALID_SMS_PROVIDERS = ['twilio'] as const;
+
+export const TimeoutConfigSchema = z.object({
+  shellMaxTimeoutSec: z
+    .number({ error: 'timeouts.shellMaxTimeoutSec must be a number' })
+    .finite('timeouts.shellMaxTimeoutSec must be finite')
+    .positive('timeouts.shellMaxTimeoutSec must be a positive number')
+    .default(600),
+  shellDefaultTimeoutSec: z
+    .number({ error: 'timeouts.shellDefaultTimeoutSec must be a number' })
+    .finite('timeouts.shellDefaultTimeoutSec must be finite')
+    .positive('timeouts.shellDefaultTimeoutSec must be a positive number')
+    .default(120),
+  permissionTimeoutSec: z
+    .number({ error: 'timeouts.permissionTimeoutSec must be a number' })
+    .finite('timeouts.permissionTimeoutSec must be finite')
+    .positive('timeouts.permissionTimeoutSec must be a positive number')
+    .default(300),
+  toolExecutionTimeoutSec: z
+    .number({ error: 'timeouts.toolExecutionTimeoutSec must be a number' })
+    .finite('timeouts.toolExecutionTimeoutSec must be finite')
+    .positive('timeouts.toolExecutionTimeoutSec must be a positive number')
+    .default(120),
+  providerStreamTimeoutSec: z
+    .number({ error: 'timeouts.providerStreamTimeoutSec must be a number' })
+    .finite('timeouts.providerStreamTimeoutSec must be finite')
+    .positive('timeouts.providerStreamTimeoutSec must be a positive number')
+    .default(300),
+});
+
+export const RateLimitConfigSchema = z.object({
+  maxRequestsPerMinute: z
+    .number({ error: 'rateLimit.maxRequestsPerMinute must be a number' })
+    .int('rateLimit.maxRequestsPerMinute must be an integer')
+    .nonnegative('rateLimit.maxRequestsPerMinute must be a non-negative integer')
+    .default(0),
+  maxTokensPerSession: z
+    .number({ error: 'rateLimit.maxTokensPerSession must be a number' })
+    .int('rateLimit.maxTokensPerSession must be an integer')
+    .nonnegative('rateLimit.maxTokensPerSession must be a non-negative integer')
+    .default(0),
+});
+
+export const SecretDetectionConfigSchema = z.object({
+  enabled: z
+    .boolean({ error: 'secretDetection.enabled must be a boolean' })
+    .default(true),
+  action: z
+    .enum(VALID_SECRET_ACTIONS, {
+      error: `secretDetection.action must be one of: ${VALID_SECRET_ACTIONS.join(', ')}`,
+    })
+    .default('redact'),
+  entropyThreshold: z
+    .number({ error: 'secretDetection.entropyThreshold must be a number' })
+    .finite('secretDetection.entropyThreshold must be finite')
+    .positive('secretDetection.entropyThreshold must be a positive number')
+    .default(4.0),
+  allowOneTimeSend: z
+    .boolean({ error: 'secretDetection.allowOneTimeSend must be a boolean' })
+    .default(false),
+  blockIngress: z
+    .boolean({ error: 'secretDetection.blockIngress must be a boolean' })
+    .default(true),
+});
+
+export const PermissionsConfigSchema = z.object({
+  mode: z
+    .enum(VALID_PERMISSIONS_MODES, {
+      error: `permissions.mode must be one of: ${VALID_PERMISSIONS_MODES.join(', ')}`,
+    })
+    .default('workspace'),
+});
+
+export const AuditLogConfigSchema = z.object({
+  retentionDays: z
+    .number({ error: 'auditLog.retentionDays must be a number' })
+    .int('auditLog.retentionDays must be an integer')
+    .nonnegative('auditLog.retentionDays must be a non-negative integer')
+    .default(0),
+});
+
+export const LogFileConfigSchema = z.object({
+  dir: z
+    .string({ error: 'logFile.dir must be a string' })
+    .optional(),
+  retentionDays: z
+    .number({ error: 'logFile.retentionDays must be a number' })
+    .int('logFile.retentionDays must be an integer')
+    .positive('logFile.retentionDays must be a positive integer')
+    .default(30),
+});
+
+export const ThinkingConfigSchema = z.object({
+  enabled: z
+    .boolean({ error: 'thinking.enabled must be a boolean' })
+    .default(false),
+  budgetTokens: z
+    .number({ error: 'thinking.budgetTokens must be a number' })
+    .int('thinking.budgetTokens must be an integer')
+    .positive('thinking.budgetTokens must be a positive integer')
+    .default(10000),
+  streamThinking: z
+    .boolean({ error: 'thinking.streamThinking must be a boolean' })
+    .default(false),
+});
+
+export const ContextWindowConfigSchema = z.object({
+  enabled: z
+    .boolean({ error: 'contextWindow.enabled must be a boolean' })
+    .default(true),
+  maxInputTokens: z
+    .number({ error: 'contextWindow.maxInputTokens must be a number' })
+    .int('contextWindow.maxInputTokens must be an integer')
+    .positive('contextWindow.maxInputTokens must be a positive integer')
+    .default(180000),
+  targetInputTokens: z
+    .number({ error: 'contextWindow.targetInputTokens must be a number' })
+    .int('contextWindow.targetInputTokens must be an integer')
+    .positive('contextWindow.targetInputTokens must be a positive integer')
+    .default(110000),
+  compactThreshold: z
+    .number({ error: 'contextWindow.compactThreshold must be a number' })
+    .finite('contextWindow.compactThreshold must be finite')
+    .gt(0, 'contextWindow.compactThreshold must be greater than 0')
+    .lte(1, 'contextWindow.compactThreshold must be less than or equal to 1')
+    .default(0.8),
+  preserveRecentUserTurns: z
+    .number({ error: 'contextWindow.preserveRecentUserTurns must be a number' })
+    .int('contextWindow.preserveRecentUserTurns must be an integer')
+    .positive('contextWindow.preserveRecentUserTurns must be a positive integer')
+    .default(8),
+  summaryMaxTokens: z
+    .number({ error: 'contextWindow.summaryMaxTokens must be a number' })
+    .int('contextWindow.summaryMaxTokens must be an integer')
+    .positive('contextWindow.summaryMaxTokens must be a positive integer')
+    .default(1200),
+  chunkTokens: z
+    .number({ error: 'contextWindow.chunkTokens must be a number' })
+    .int('contextWindow.chunkTokens must be an integer')
+    .positive('contextWindow.chunkTokens must be a positive integer')
+    .default(12000),
+});
+
+export const ModelPricingOverrideSchema = z.object({
+  provider: z.string({ error: 'pricingOverrides[].provider must be a string' }),
+  modelPattern: z.string({ error: 'pricingOverrides[].modelPattern must be a string' }),
+  inputPer1M: z
+    .number({ error: 'pricingOverrides[].inputPer1M must be a number' })
+    .nonnegative('pricingOverrides[].inputPer1M must be a non-negative number'),
+  outputPer1M: z
+    .number({ error: 'pricingOverrides[].outputPer1M must be a number' })
+    .nonnegative('pricingOverrides[].outputPer1M must be a non-negative number'),
+});
+
+export const SmsConfigSchema = z.object({
+  enabled: z
+    .boolean({ error: 'sms.enabled must be a boolean' })
+    .default(false),
+  provider: z
+    .enum(VALID_SMS_PROVIDERS, {
+      error: `sms.provider must be one of: ${VALID_SMS_PROVIDERS.join(', ')}`,
+    })
+    .default('twilio'),
+  phoneNumber: z
+    .string({ error: 'sms.phoneNumber must be a string' })
+    .default(''),
+  assistantPhoneNumbers: z
+    .record(z.string(), z.string({ error: 'sms.assistantPhoneNumbers values must be strings' }))
+    .optional(),
+});
+
+export const IngressWebhookConfigSchema = z.object({
+  secret: z
+    .string({ error: 'ingress.webhook.secret must be a string' })
+    .default(''),
+  timeoutMs: z
+    .number({ error: 'ingress.webhook.timeoutMs must be a number' })
+    .int('ingress.webhook.timeoutMs must be an integer')
+    .positive('ingress.webhook.timeoutMs must be a positive integer')
+    .default(30_000),
+  maxRetries: z
+    .number({ error: 'ingress.webhook.maxRetries must be a number' })
+    .int('ingress.webhook.maxRetries must be an integer')
+    .nonnegative('ingress.webhook.maxRetries must be a non-negative integer')
+    .default(2),
+  initialBackoffMs: z
+    .number({ error: 'ingress.webhook.initialBackoffMs must be a number' })
+    .int('ingress.webhook.initialBackoffMs must be an integer')
+    .positive('ingress.webhook.initialBackoffMs must be a positive integer')
+    .default(500),
+  maxPayloadBytes: z
+    .number({ error: 'ingress.webhook.maxPayloadBytes must be a number' })
+    .int('ingress.webhook.maxPayloadBytes must be an integer')
+    .positive('ingress.webhook.maxPayloadBytes must be a positive integer')
+    .default(1_048_576),
+});
+
+export const IngressRateLimitConfigSchema = z.object({
+  maxRequestsPerMinute: z
+    .number({ error: 'ingress.rateLimit.maxRequestsPerMinute must be a number' })
+    .int('ingress.rateLimit.maxRequestsPerMinute must be an integer')
+    .nonnegative('ingress.rateLimit.maxRequestsPerMinute must be a non-negative integer')
+    .default(0),
+  maxRequestsPerHour: z
+    .number({ error: 'ingress.rateLimit.maxRequestsPerHour must be a number' })
+    .int('ingress.rateLimit.maxRequestsPerHour must be an integer')
+    .nonnegative('ingress.rateLimit.maxRequestsPerHour must be a non-negative integer')
+    .default(0),
+});
+
+const IngressBaseSchema = z.object({
+  enabled: z
+    .boolean({ error: 'ingress.enabled must be a boolean' })
+    .optional(),
+  publicBaseUrl: z
+    .string({ error: 'ingress.publicBaseUrl must be a string' })
+    .refine(
+      (val) => val === '' || /^https?:\/\//i.test(val),
+      'ingress.publicBaseUrl must be an absolute URL starting with http:// or https://',
+    )
+    .default(''),
+  webhook: IngressWebhookConfigSchema.default({
+    secret: '',
+    timeoutMs: 30_000,
+    maxRetries: 2,
+    initialBackoffMs: 500,
+    maxPayloadBytes: 1_048_576,
+  }),
+  rateLimit: IngressRateLimitConfigSchema.default({
+    maxRequestsPerMinute: 0,
+    maxRequestsPerHour: 0,
+  }),
+  shutdownDrainMs: z
+    .number({ error: 'ingress.shutdownDrainMs must be a number' })
+    .int('ingress.shutdownDrainMs must be an integer')
+    .nonnegative('ingress.shutdownDrainMs must be a non-negative integer')
+    .default(5_000),
+});
+
+export const IngressConfigSchema = IngressBaseSchema
+  .default({
+    publicBaseUrl: '',
+    webhook: {
+      secret: '',
+      timeoutMs: 30_000,
+      maxRetries: 2,
+      initialBackoffMs: 500,
+      maxPayloadBytes: 1_048_576,
+    },
+    rateLimit: {
+      maxRequestsPerMinute: 0,
+      maxRequestsPerHour: 0,
+    },
+    shutdownDrainMs: 5_000,
+  })
+  .transform((val) => ({
+    ...val,
+    // Backward compatibility: if `enabled` was never explicitly set (undefined),
+    // infer it from whether a publicBaseUrl is configured. Existing users who
+    // have a URL but predate the `enabled` field should not have their webhooks
+    // silently disabled on upgrade.
+    //
+    // When publicBaseUrl is empty and enabled is unset, leave enabled as
+    // undefined so getPublicBaseUrl() can still fall through to the
+    // INGRESS_PUBLIC_BASE_URL env-var fallback (env-only setups).
+    enabled: val.enabled ?? (val.publicBaseUrl ? true : undefined),
+  }));
+
+export const DaemonConfigSchema = z.object({
+  startupSocketWaitMs: z
+    .number({ error: 'daemon.startupSocketWaitMs must be a number' })
+    .int('daemon.startupSocketWaitMs must be an integer')
+    .positive('daemon.startupSocketWaitMs must be a positive integer')
+    .default(5000),
+  stopTimeoutMs: z
+    .number({ error: 'daemon.stopTimeoutMs must be a number' })
+    .int('daemon.stopTimeoutMs must be an integer')
+    .positive('daemon.stopTimeoutMs must be a positive integer')
+    .default(5000),
+  sigkillGracePeriodMs: z
+    .number({ error: 'daemon.sigkillGracePeriodMs must be a number' })
+    .int('daemon.sigkillGracePeriodMs must be an integer')
+    .positive('daemon.sigkillGracePeriodMs must be a positive integer')
+    .default(2000),
+  titleGenerationMaxTokens: z
+    .number({ error: 'daemon.titleGenerationMaxTokens must be a number' })
+    .int('daemon.titleGenerationMaxTokens must be an integer')
+    .positive('daemon.titleGenerationMaxTokens must be a positive integer')
+    .default(30),
+});
+
+export type TimeoutConfig = z.infer<typeof TimeoutConfigSchema>;
+export type RateLimitConfig = z.infer<typeof RateLimitConfigSchema>;
+export type SecretDetectionConfig = z.infer<typeof SecretDetectionConfigSchema>;
+export type PermissionsConfig = z.infer<typeof PermissionsConfigSchema>;
+export type AuditLogConfig = z.infer<typeof AuditLogConfigSchema>;
+export type LogFileConfig = z.infer<typeof LogFileConfigSchema>;
+export type ThinkingConfig = z.infer<typeof ThinkingConfigSchema>;
+export type ContextWindowConfig = z.infer<typeof ContextWindowConfigSchema>;
+export type ModelPricingOverride = z.infer<typeof ModelPricingOverrideSchema>;
+export type SmsConfig = z.infer<typeof SmsConfigSchema>;
+export type IngressWebhookConfig = z.infer<typeof IngressWebhookConfigSchema>;
+export type IngressRateLimitConfig = z.infer<typeof IngressRateLimitConfigSchema>;
+export type DaemonConfig = z.infer<typeof DaemonConfigSchema>;
+export type IngressConfig = z.infer<typeof IngressConfigSchema>;

package/src/config/defaults.ts

@@ -8,14 +8,15 @@ export const DEFAULT_CONFIG: AssistantConfig = {
   apiKeys: {},
   webSearchProvider: 'perplexity',
   providerOrder: [],
-  maxTokens: 64000,
+  maxTokens: 16000,
   thinking: {
     enabled: false,
     budgetTokens: 10000,
+    streamThinking: false,
   },
   contextWindow: {
     enabled: true,
-    maxInputTokens: 180000,
+    maxInputTokens: 200000,
     targetInputTokens: 110000,
     compactThreshold: 0.8,
     preserveRecentUserTurns: 8,
@@ -46,7 +47,7 @@ export const DEFAULT_CONFIG: AssistantConfig = {
       injectionFormat: 'markdown' as const,
       injectionStrategy: 'prepend_user_block' as const,
       reranking: {
-        enabled: true,
+        enabled: false,
         model: 'claude-haiku-4-5-20251001',
         topK: 20,
       },
@@ -251,6 +252,11 @@ export const DEFAULT_CONFIG: AssistantConfig = {
     callerIdentity: {
       allowPerCallOverride: true,
     },
+    verification: {
+      enabled: false,
+      maxAttempts: 3,
+      codeLength: 6,
+    },
   },
   sms: {
     enabled: false,
@@ -260,5 +266,23 @@ export const DEFAULT_CONFIG: AssistantConfig = {
   ingress: {
     enabled: undefined,
     publicBaseUrl: '',
+    webhook: {
+      secret: '',
+      timeoutMs: 30_000,
+      maxRetries: 2,
+      initialBackoffMs: 500,
+      maxPayloadBytes: 1_048_576,
+    },
+    rateLimit: {
+      maxRequestsPerMinute: 0,
+      maxRequestsPerHour: 0,
+    },
+    shutdownDrainMs: 5_000,
+  },
+  daemon: {
+    startupSocketWaitMs: 5000,
+    stopTimeoutMs: 5000,
+    sigkillGracePeriodMs: 2000,
+    titleGenerationMaxTokens: 30,
   },
 };

package/src/config/env-registry.ts

@@ -0,0 +1,169 @@
+/**
+ * Centralized environment variable registry.
+ *
+ * This module documents every VELLUM_* and related env var with its type,
+ * default, and description, and exports typed accessor functions for each.
+ *
+ * IMPORTANT: This module has NO internal imports (no logger, no platform
+ * utilities) so it can be safely imported from bootstrap-level code like
+ * util/platform.ts and util/logger.ts without circular dependencies.
+ *
+ * Higher-level env vars that depend on the logger or config system live in
+ * config/env.ts, which re-exports selected accessors from this module.
+ */
+
+// ── Helpers (dependency-free) ────────────────────────────────────────────────
+
+function str(name: string): string | undefined {
+  const v = process.env[name]?.trim();
+  return v || undefined;
+}
+
+function flag(name: string): boolean {
+  const raw = str(name);
+  return raw === 'true' || raw === '1';
+}
+
+function flagTriState(name: string): boolean | undefined {
+  const raw = str(name);
+  if (raw === 'true' || raw === '1') return true;
+  if (raw === 'false' || raw === '0') return false;
+  return undefined;
+}
+
+// ── Registry ─────────────────────────────────────────────────────────────────
+// Each entry documents the env var name, type, default, and purpose.
+
+/**
+ * BASE_DATA_DIR — string, default: os.homedir()
+ * Overrides the home directory used as the base for ~/.vellum and lockfiles.
+ * Primarily used in tests to isolate filesystem state.
+ */
+export function getBaseDataDir(): string | undefined {
+  return str('BASE_DATA_DIR');
+}
+
+/**
+ * VELLUM_DAEMON_SOCKET — string, default: ~/.vellum/vellum.sock
+ * Overrides the Unix domain socket path for daemon IPC.
+ * Supports ~ expansion.
+ */
+export function getDaemonSocket(): string | undefined {
+  return str('VELLUM_DAEMON_SOCKET');
+}
+
+/**
+ * VELLUM_DAEMON_TCP_PORT — number, default: 8765
+ * TCP port for the daemon's TCP listener (used by iOS clients).
+ */
+export function getDaemonTcpPort(): number {
+  const raw = str('VELLUM_DAEMON_TCP_PORT');
+  if (raw) {
+    const port = parseInt(raw, 10);
+    if (!isNaN(port) && port > 0 && port <= 65535) return port;
+  }
+  return 8765;
+}
+
+/**
+ * VELLUM_DAEMON_TCP_ENABLED — boolean tri-state, default: undefined (falls back to flag file)
+ * Whether the daemon TCP listener should be active.
+ * 'true'/'1' → on, 'false'/'0' → off, unset → check flag file.
+ */
+export function getDaemonTcpEnabled(): boolean | undefined {
+  return flagTriState('VELLUM_DAEMON_TCP_ENABLED');
+}
+
+/**
+ * VELLUM_DAEMON_TCP_HOST — string, default: context-dependent (127.0.0.1 or 0.0.0.0)
+ * Hostname/address for the TCP listener. When unset, platform.ts resolves
+ * based on whether iOS pairing is enabled.
+ */
+export function getDaemonTcpHost(): string | undefined {
+  return str('VELLUM_DAEMON_TCP_HOST');
+}
+
+/**
+ * VELLUM_DAEMON_IOS_PAIRING — boolean tri-state, default: undefined (falls back to flag file)
+ * Whether iOS pairing mode is enabled. When on, TCP binds to 0.0.0.0.
+ * 'true'/'1' → on, 'false'/'0' → off, unset → check flag file.
+ */
+export function getDaemonIosPairing(): boolean | undefined {
+  return flagTriState('VELLUM_DAEMON_IOS_PAIRING');
+}
+
+/**
+ * VELLUM_DEBUG — boolean, default: false
+ * Enables debug-level logging and verbose output.
+ */
+export function getDebugMode(): boolean {
+  return flag('VELLUM_DEBUG');
+}
+
+/**
+ * VELLUM_LOG_STDERR — boolean, default: false
+ * Forces logger output to stderr instead of log files.
+ */
+export function getLogStderr(): boolean {
+  return flag('VELLUM_LOG_STDERR');
+}
+
+/**
+ * DEBUG_STDOUT_LOGS — boolean, default: false
+ * Enables additional log output to stdout (alongside file logging).
+ */
+export function getDebugStdoutLogs(): boolean {
+  return flag('DEBUG_STDOUT_LOGS');
+}
+
+/**
+ * VELLUM_ENABLE_MONITORING — boolean, default: false
+ * Enables monitoring/telemetry (Logfire, etc.).
+ */
+export function getEnableMonitoring(): boolean {
+  return flag('VELLUM_ENABLE_MONITORING');
+}
+
+// ── Known env var names ──────────────────────────────────────────────────────
+
+/**
+ * Complete set of recognized VELLUM_* env var names. Used by validateEnvVars()
+ * to warn about typos or unrecognized variables.
+ */
+const KNOWN_VELLUM_VARS = new Set([
+  'VELLUM_DAEMON_SOCKET',
+  'VELLUM_DAEMON_TCP_PORT',
+  'VELLUM_DAEMON_TCP_ENABLED',
+  'VELLUM_DAEMON_TCP_HOST',
+  'VELLUM_DAEMON_IOS_PAIRING',
+  'VELLUM_DAEMON_NOAUTH',
+  'VELLUM_DAEMON_AUTOSTART',
+  'VELLUM_DEBUG',
+  'VELLUM_LOG_STDERR',
+  'VELLUM_ENABLE_MONITORING',
+  'VELLUM_HOOK_EVENT',
+  'VELLUM_HOOK_NAME',
+  'VELLUM_HOOK_SETTINGS',
+  'VELLUM_ROOT_DIR',
+  'VELLUM_WORKSPACE_DIR',
+  'VELLUM_CLAUDE_CODE_DEPTH',
+  'VELLUM_ASSISTANT_PLATFORM_URL',
+]);
+
+/**
+ * Check all VELLUM_* env vars and return warnings for any unrecognized ones.
+ * Returns an array of warning messages (empty if all vars are recognized).
+ *
+ * This is intentionally a pure function that returns strings rather than
+ * logging directly, so it can be called from bootstrap code before the
+ * logger is initialized.
+ */
+export function checkUnrecognizedEnvVars(): string[] {
+  const warnings: string[] = [];
+  for (const key of Object.keys(process.env)) {
+    if (key.startsWith('VELLUM_') && !KNOWN_VELLUM_VARS.has(key)) {
+      warnings.push(`Unrecognized environment variable: ${key}`);
+    }
+  }
+  return warnings;
+}