@vellumai/assistant 0.4.48 → 0.4.50

package/src/config/feature-flag-registry.json

@@ -33,22 +33,6 @@
       "description": "Enable messaging skill section in the system prompt",
       "defaultEnabled": true
     },
-    {
-      "id": "messaging-gmail",
-      "scope": "assistant",
-      "key": "feature_flags.messaging.gmail.enabled",
-      "label": "Messaging: Gmail",
-      "description": "Allow messaging tools to operate on the Gmail platform",
-      "defaultEnabled": true
-    },
-    {
-      "id": "messaging-telegram",
-      "scope": "assistant",
-      "key": "feature_flags.messaging.telegram.enabled",
-      "label": "Messaging: Telegram",
-      "description": "Allow messaging tools to operate on the Telegram platform",
-      "defaultEnabled": false
-    },
     {
       "id": "collect-usage-data",
       "scope": "assistant",
@@ -81,6 +65,14 @@
       "description": "Show the Contacts tab in Settings for viewing and managing contacts",
       "defaultEnabled": false
     },
+    {
+      "id": "email-channel",
+      "scope": "assistant",
+      "key": "feature_flags.email-channel.enabled",
+      "label": "Email Channel",
+      "description": "Show the Email channel card on the Contacts page and enable the email-setup skill",
+      "defaultEnabled": false
+    },
     {
       "id": "outbound-proxy-sidecar",
       "scope": "assistant",
@@ -128,6 +120,14 @@
       "label": "Settings Developer Nav",
       "description": "Control Developer nav visibility in macOS settings",
       "defaultEnabled": true
+    },
+    {
+      "id": "logfire",
+      "scope": "assistant",
+      "key": "feature_flags.logfire.enabled",
+      "label": "Logfire LLM Observability",
+      "description": "Enable Logfire tracing for LLM request/response telemetry when LOGFIRE_TOKEN is set",
+      "defaultEnabled": false
     }
   ]
 }

package/src/config/loader.ts

@@ -333,12 +333,6 @@ export function loadConfig(): AssistantConfig {
     }
 
     // Environment variables override everything
-    if (process.env.VELLUM_CONFIG_SANDBOX_ENABLED === "false") {
-      config.sandbox.enabled = false;
-    } else if (process.env.VELLUM_CONFIG_SANDBOX_ENABLED === "true") {
-      config.sandbox.enabled = true;
-    }
-
     if (process.env.ANTHROPIC_API_KEY) {
       config.apiKeys.anthropic = process.env.ANTHROPIC_API_KEY;
     }

package/src/config/schema.ts

@@ -91,27 +91,16 @@ export {
   MemoryRetentionConfigSchema,
 } from "./schemas/memory-lifecycle.js";
 export type {
-  MemoryConflictsConfig,
-  MemoryEntityConfig,
   MemoryExtractionConfig,
-  MemoryProfileConfig,
   MemorySummarizationConfig,
 } from "./schemas/memory-processing.js";
 export {
-  MemoryConflictsConfigSchema,
-  MemoryEntityConfigSchema,
   MemoryExtractionConfigSchema,
-  MemoryProfileConfigSchema,
   MemorySummarizationConfigSchema,
 } from "./schemas/memory-processing.js";
-export type {
-  MemoryRerankingConfig,
-  MemoryRetrievalConfig,
-} from "./schemas/memory-retrieval.js";
+export type { MemoryRetrievalConfig } from "./schemas/memory-retrieval.js";
 export {
   MemoryDynamicBudgetConfigSchema,
-  MemoryEarlyTerminationConfigSchema,
-  MemoryRerankingConfigSchema,
   MemoryRetrievalConfigSchema,
 } from "./schemas/memory-retrieval.js";
 export type {
@@ -289,7 +278,9 @@ export const AssistantConfigSchema = z
       PermissionsConfigSchema.parse({}),
     ),
     auditLog: AuditLogConfigSchema.default(AuditLogConfigSchema.parse({})),
-    logFile: LogFileConfigSchema.default(LogFileConfigSchema.parse({})),
+    logFile: LogFileConfigSchema.default(
+      LogFileConfigSchema.parse({ dir: getDataDir() + "/logs" }),
+    ),
     pricingOverrides: z.array(ModelPricingOverrideSchema).default([]),
     heartbeat: HeartbeatConfigSchema.default(HeartbeatConfigSchema.parse({})),
     swarm: SwarmConfigSchema.default(SwarmConfigSchema.parse({})),

package/src/config/schemas/memory-lifecycle.ts

@@ -33,15 +33,6 @@ export const MemoryCleanupConfigSchema = z.object({
     .int("memory.cleanup.enqueueIntervalMs must be an integer")
     .positive("memory.cleanup.enqueueIntervalMs must be a positive integer")
     .default(6 * 60 * 60 * 1000),
-  resolvedConflictRetentionMs: z
-    .number({
-      error: "memory.cleanup.resolvedConflictRetentionMs must be a number",
-    })
-    .int("memory.cleanup.resolvedConflictRetentionMs must be an integer")
-    .positive(
-      "memory.cleanup.resolvedConflictRetentionMs must be a positive integer",
-    )
-    .default(30 * 24 * 60 * 60 * 1000),
   supersededItemRetentionMs: z
     .number({
       error: "memory.cleanup.supersededItemRetentionMs must be a number",

package/src/config/schemas/memory-processing.ts

@@ -1,28 +1,5 @@
 import { z } from "zod";
 
-const VALID_MEMORY_ITEM_KINDS = [
-  "preference",
-  "profile",
-  "project",
-  "decision",
-  "todo",
-  "fact",
-  "constraint",
-  "relationship",
-  "event",
-  "opinion",
-  "instruction",
-  "style",
-] as const;
-
-const DEFAULT_CONFLICTABLE_KINDS = [
-  "preference",
-  "profile",
-  "constraint",
-  "instruction",
-  "style",
-] as const;
-
 export const MemoryExtractionConfigSchema = z.object({
   useLLM: z
     .boolean({ error: "memory.extraction.useLLM must be a boolean" })
@@ -50,166 +27,9 @@ export const MemorySummarizationConfigSchema = z.object({
     .default("latency-optimized"),
 });
 
-export const MemoryEntityConfigSchema = z.object({
-  enabled: z
-    .boolean({ error: "memory.entity.enabled must be a boolean" })
-    .default(true),
-  modelIntent: z
-    .enum(["latency-optimized", "quality-optimized", "vision-optimized"], {
-      error: "memory.entity.modelIntent must be a valid model intent",
-    })
-    .default("latency-optimized"),
-  extractRelations: z
-    .object({
-      enabled: z
-        .boolean({
-          error: "memory.entity.extractRelations.enabled must be a boolean",
-        })
-        .default(true),
-      backfillBatchSize: z
-        .number({
-          error:
-            "memory.entity.extractRelations.backfillBatchSize must be a number",
-        })
-        .int(
-          "memory.entity.extractRelations.backfillBatchSize must be an integer",
-        )
-        .positive(
-          "memory.entity.extractRelations.backfillBatchSize must be a positive integer",
-        )
-        .default(200),
-    })
-    .default({ enabled: true, backfillBatchSize: 200 }),
-  relationRetrieval: z
-    .object({
-      enabled: z
-        .boolean({
-          error: "memory.entity.relationRetrieval.enabled must be a boolean",
-        })
-        .default(true),
-      maxSeedEntities: z
-        .number({
-          error:
-            "memory.entity.relationRetrieval.maxSeedEntities must be a number",
-        })
-        .int(
-          "memory.entity.relationRetrieval.maxSeedEntities must be an integer",
-        )
-        .positive(
-          "memory.entity.relationRetrieval.maxSeedEntities must be a positive integer",
-        )
-        .default(8),
-      maxNeighborEntities: z
-        .number({
-          error:
-            "memory.entity.relationRetrieval.maxNeighborEntities must be a number",
-        })
-        .int(
-          "memory.entity.relationRetrieval.maxNeighborEntities must be an integer",
-        )
-        .positive(
-          "memory.entity.relationRetrieval.maxNeighborEntities must be a positive integer",
-        )
-        .default(20),
-      maxEdges: z
-        .number({
-          error: "memory.entity.relationRetrieval.maxEdges must be a number",
-        })
-        .int("memory.entity.relationRetrieval.maxEdges must be an integer")
-        .positive(
-          "memory.entity.relationRetrieval.maxEdges must be a positive integer",
-        )
-        .default(40),
-      neighborScoreMultiplier: z
-        .number({
-          error:
-            "memory.entity.relationRetrieval.neighborScoreMultiplier must be a number",
-        })
-        .gt(
-          0,
-          "memory.entity.relationRetrieval.neighborScoreMultiplier must be > 0",
-        )
-        .lte(
-          1,
-          "memory.entity.relationRetrieval.neighborScoreMultiplier must be <= 1",
-        )
-        .default(0.7),
-      maxDepth: z
-        .number({
-          error: "memory.entity.relationRetrieval.maxDepth must be a number",
-        })
-        .int("memory.entity.relationRetrieval.maxDepth must be an integer")
-        .positive(
-          "memory.entity.relationRetrieval.maxDepth must be a positive integer",
-        )
-        .default(3),
-      depthDecay: z
-        .boolean({
-          error: "memory.entity.relationRetrieval.depthDecay must be a boolean",
-        })
-        .default(true),
-    })
-    .default({
-      enabled: true,
-      maxSeedEntities: 8,
-      maxNeighborEntities: 20,
-      maxEdges: 40,
-      neighborScoreMultiplier: 0.7,
-      maxDepth: 3,
-      depthDecay: true,
-    }),
-});
-
-export const MemoryConflictsConfigSchema = z.object({
-  enabled: z
-    .boolean({ error: "memory.conflicts.enabled must be a boolean" })
-    .default(true),
-  gateMode: z
-    .enum(["soft"], { error: 'memory.conflicts.gateMode must be "soft"' })
-    .default("soft"),
-  resolverLlmTimeoutMs: z
-    .number({ error: "memory.conflicts.resolverLlmTimeoutMs must be a number" })
-    .int("memory.conflicts.resolverLlmTimeoutMs must be an integer")
-    .positive(
-      "memory.conflicts.resolverLlmTimeoutMs must be a positive integer",
-    )
-    .default(12000),
-  relevanceThreshold: z
-    .number({ error: "memory.conflicts.relevanceThreshold must be a number" })
-    .min(0, "memory.conflicts.relevanceThreshold must be >= 0")
-    .max(1, "memory.conflicts.relevanceThreshold must be <= 1")
-    .default(0.3),
-  conflictableKinds: z
-    .array(
-      z.enum(VALID_MEMORY_ITEM_KINDS, {
-        error: `memory.conflicts.conflictableKinds entries must be one of: ${VALID_MEMORY_ITEM_KINDS.join(
-          ", ",
-        )}`,
-      }),
-    )
-    .nonempty({
-      message: "memory.conflicts.conflictableKinds must not be empty",
-    })
-    .default([...DEFAULT_CONFLICTABLE_KINDS]),
-});
-
-export const MemoryProfileConfigSchema = z.object({
-  enabled: z
-    .boolean({ error: "memory.profile.enabled must be a boolean" })
-    .default(true),
-  maxInjectTokens: z
-    .number({ error: "memory.profile.maxInjectTokens must be a number" })
-    .int("memory.profile.maxInjectTokens must be an integer")
-    .positive("memory.profile.maxInjectTokens must be a positive integer")
-    .default(800),
-});
-
 export type MemoryExtractionConfig = z.infer<
   typeof MemoryExtractionConfigSchema
 >;
 export type MemorySummarizationConfig = z.infer<
   typeof MemorySummarizationConfigSchema
 >;
-export type MemoryEntityConfig = z.infer<typeof MemoryEntityConfigSchema>;
-export type MemoryConflictsConfig = z.infer<typeof MemoryConflictsConfigSchema>;
-export type MemoryProfileConfig = z.infer<typeof MemoryProfileConfigSchema>;

package/src/config/schemas/memory-retrieval.ts

@@ -1,22 +1,5 @@
 import { z } from "zod";
 
-export const MemoryRerankingConfigSchema = z.object({
-  enabled: z
-    .boolean({ error: "memory.retrieval.reranking.enabled must be a boolean" })
-    .default(false),
-  modelIntent: z
-    .enum(["latency-optimized", "quality-optimized", "vision-optimized"], {
-      error:
-        "memory.retrieval.reranking.modelIntent must be a valid model intent",
-    })
-    .default("latency-optimized"),
-  topK: z
-    .number({ error: "memory.retrieval.reranking.topK must be a number" })
-    .int("memory.retrieval.reranking.topK must be an integer")
-    .positive("memory.retrieval.reranking.topK must be a positive integer")
-    .default(20),
-});
-
 export const MemoryDynamicBudgetConfigSchema = z.object({
   enabled: z
     .boolean({
@@ -55,49 +38,6 @@ export const MemoryDynamicBudgetConfigSchema = z.object({
     .default(10000),
 });
 
-export const MemoryEarlyTerminationConfigSchema = z.object({
-  enabled: z
-    .boolean({
-      error: "memory.retrieval.earlyTermination.enabled must be a boolean",
-    })
-    .default(true),
-  minCandidates: z
-    .number({
-      error: "memory.retrieval.earlyTermination.minCandidates must be a number",
-    })
-    .int("memory.retrieval.earlyTermination.minCandidates must be an integer")
-    .positive(
-      "memory.retrieval.earlyTermination.minCandidates must be a positive integer",
-    )
-    .default(20),
-  minHighConfidence: z
-    .number({
-      error:
-        "memory.retrieval.earlyTermination.minHighConfidence must be a number",
-    })
-    .int(
-      "memory.retrieval.earlyTermination.minHighConfidence must be an integer",
-    )
-    .positive(
-      "memory.retrieval.earlyTermination.minHighConfidence must be a positive integer",
-    )
-    .default(10),
-  confidenceThreshold: z
-    .number({
-      error:
-        "memory.retrieval.earlyTermination.confidenceThreshold must be a number",
-    })
-    .min(
-      0,
-      "memory.retrieval.earlyTermination.confidenceThreshold must be >= 0",
-    )
-    .max(
-      1,
-      "memory.retrieval.earlyTermination.confidenceThreshold must be <= 1",
-    )
-    .default(0.7),
-});
-
 /**
  * Per-kind freshness windows (in days). Items older than their window
  * (based on lastSeenAt) are down-ranked unless recently reinforced.
@@ -109,12 +49,13 @@ const MemoryFreshnessConfigSchema = z.object({
     .default(true),
   maxAgeDays: z
     .object({
-      fact: z
+      identity: z
         .number({
-          error: "memory.retrieval.freshness.maxAgeDays.fact must be a number",
+          error:
+            "memory.retrieval.freshness.maxAgeDays.identity must be a number",
         })
         .nonnegative(
-          "memory.retrieval.freshness.maxAgeDays.fact must be non-negative",
+          "memory.retrieval.freshness.maxAgeDays.identity must be non-negative",
         )
         .default(0),
       preference: z
@@ -126,34 +67,50 @@ const MemoryFreshnessConfigSchema = z.object({
           "memory.retrieval.freshness.maxAgeDays.preference must be non-negative",
         )
         .default(0),
-      behavior: z
+      project: z
         .number({
           error:
-            "memory.retrieval.freshness.maxAgeDays.behavior must be a number",
+            "memory.retrieval.freshness.maxAgeDays.project must be a number",
         })
         .nonnegative(
-          "memory.retrieval.freshness.maxAgeDays.behavior must be non-negative",
+          "memory.retrieval.freshness.maxAgeDays.project must be non-negative",
         )
-        .default(90),
-      event: z
+        .default(30),
+      decision: z
         .number({
-          error: "memory.retrieval.freshness.maxAgeDays.event must be a number",
+          error:
+            "memory.retrieval.freshness.maxAgeDays.decision must be a number",
         })
         .nonnegative(
-          "memory.retrieval.freshness.maxAgeDays.event must be non-negative",
+          "memory.retrieval.freshness.maxAgeDays.decision must be non-negative",
         )
         .default(30),
-      opinion: z
+      constraint: z
         .number({
           error:
-            "memory.retrieval.freshness.maxAgeDays.opinion must be a number",
+            "memory.retrieval.freshness.maxAgeDays.constraint must be a number",
+        })
+        .nonnegative(
+          "memory.retrieval.freshness.maxAgeDays.constraint must be non-negative",
+        )
+        .default(90),
+      event: z
+        .number({
+          error: "memory.retrieval.freshness.maxAgeDays.event must be a number",
         })
         .nonnegative(
-          "memory.retrieval.freshness.maxAgeDays.opinion must be non-negative",
+          "memory.retrieval.freshness.maxAgeDays.event must be non-negative",
         )
-        .default(60),
+        .default(30),
     })
-    .default({ fact: 0, preference: 0, behavior: 90, event: 30, opinion: 60 }),
+    .default({
+      identity: 0,
+      preference: 0,
+      project: 30,
+      decision: 30,
+      constraint: 90,
+      event: 30,
+    }),
   staleDecay: z
     .number({ error: "memory.retrieval.freshness.staleDecay must be a number" })
     .min(0, "memory.retrieval.freshness.staleDecay must be >= 0")
@@ -171,36 +128,11 @@ const MemoryFreshnessConfigSchema = z.object({
 });
 
 export const MemoryRetrievalConfigSchema = z.object({
-  lexicalTopK: z
-    .number({ error: "memory.retrieval.lexicalTopK must be a number" })
-    .int("memory.retrieval.lexicalTopK must be an integer")
-    .positive("memory.retrieval.lexicalTopK must be a positive integer")
-    .default(80),
-  semanticTopK: z
-    .number({ error: "memory.retrieval.semanticTopK must be a number" })
-    .int("memory.retrieval.semanticTopK must be an integer")
-    .positive("memory.retrieval.semanticTopK must be a positive integer")
-    .default(40),
   maxInjectTokens: z
     .number({ error: "memory.retrieval.maxInjectTokens must be a number" })
     .int("memory.retrieval.maxInjectTokens must be an integer")
     .positive("memory.retrieval.maxInjectTokens must be a positive integer")
     .default(10000),
-  injectionFormat: z
-    .enum(["markdown", "structured_v1"], {
-      error:
-        'memory.retrieval.injectionFormat must be "markdown" or "structured_v1"',
-    })
-    .default("markdown"),
-  injectionStrategy: z
-    .enum(["prepend_user_block", "separate_context_message"], {
-      error:
-        'memory.retrieval.injectionStrategy must be "prepend_user_block" or "separate_context_message"',
-    })
-    .default("prepend_user_block"),
-  reranking: MemoryRerankingConfigSchema.default(
-    MemoryRerankingConfigSchema.parse({}),
-  ),
   freshness: MemoryFreshnessConfigSchema.default(
     MemoryFreshnessConfigSchema.parse({}),
   ),
@@ -213,10 +145,6 @@ export const MemoryRetrievalConfigSchema = z.object({
   dynamicBudget: MemoryDynamicBudgetConfigSchema.default(
     MemoryDynamicBudgetConfigSchema.parse({}),
   ),
-  earlyTermination: MemoryEarlyTerminationConfigSchema.default(
-    MemoryEarlyTerminationConfigSchema.parse({}),
-  ),
 });
 
-export type MemoryRerankingConfig = z.infer<typeof MemoryRerankingConfigSchema>;
 export type MemoryRetrievalConfig = z.infer<typeof MemoryRetrievalConfigSchema>;

package/src/config/schemas/memory.ts

@@ -6,10 +6,7 @@ import {
   MemoryRetentionConfigSchema,
 } from "./memory-lifecycle.js";
 import {
-  MemoryConflictsConfigSchema,
-  MemoryEntityConfigSchema,
   MemoryExtractionConfigSchema,
-  MemoryProfileConfigSchema,
   MemorySummarizationConfigSchema,
 } from "./memory-processing.js";
 import { MemoryRetrievalConfigSchema } from "./memory-retrieval.js";
@@ -46,13 +43,6 @@ export const MemoryConfigSchema = z.object({
   summarization: MemorySummarizationConfigSchema.default(
     MemorySummarizationConfigSchema.parse({}),
   ),
-  entity: MemoryEntityConfigSchema.default(MemoryEntityConfigSchema.parse({})),
-  conflicts: MemoryConflictsConfigSchema.default(
-    MemoryConflictsConfigSchema.parse({}),
-  ),
-  profile: MemoryProfileConfigSchema.default(
-    MemoryProfileConfigSchema.parse({}),
-  ),
 });
 
 export type MemoryConfig = z.infer<typeof MemoryConfigSchema>;

package/src/config/skills.ts

@@ -146,14 +146,23 @@ export interface SkillDefinition extends SkillSummary {
   body: string;
 }
 
+export type SkillLookupErrorCode =
+  | "not_found"
+  | "ambiguous"
+  | "empty_catalog"
+  | "invalid_selector"
+  | "load_failed";
+
 export interface SkillLookupResult {
   skill?: SkillDefinition;
   error?: string;
+  errorCode?: SkillLookupErrorCode;
 }
 
 export interface SkillSelectorResult {
   skill?: SkillSummary;
   error?: string;
+  errorCode?: SkillLookupErrorCode;
 }
 
 // ─── Skill Tool Manifest Types ────────────────────────────────────────────────
@@ -1210,6 +1219,7 @@ export function resolveSkillSelector(
   if (!needle) {
     return {
       error: "Skill selector is required and must be a non-empty string.",
+      errorCode: "invalid_selector",
     };
   }
 
@@ -1218,6 +1228,7 @@ export function resolveSkillSelector(
     return {
       error:
         "No skills are available. Configure ~/.vellum/workspace/skills/SKILLS.md or add skill directories.",
+      errorCode: "empty_catalog",
     };
   }
 
@@ -1236,7 +1247,10 @@ export function resolveSkillSelector(
   }
   if (exactNameMatches.length > 1) {
     const ids = exactNameMatches.map((skill) => skill.id).join(", ");
-    return { error: `Ambiguous skill name "${needle}". Matching IDs: ${ids}` };
+    return {
+      error: `Ambiguous skill name "${needle}". Matching IDs: ${ids}`,
+      errorCode: "ambiguous",
+    };
   }
 
   const idPrefixMatches = catalog.filter((skill) =>
@@ -1249,12 +1263,14 @@ export function resolveSkillSelector(
     const ids = idPrefixMatches.map((skill) => skill.id).join(", ");
     return {
       error: `Ambiguous skill id prefix "${needle}". Matching IDs: ${ids}`,
+      errorCode: "ambiguous",
     };
   }
 
   const knownSkills = catalog.map((skill) => skill.id).join(", ");
   return {
     error: `No skill matched "${needle}". Available skills: ${knownSkills}`,
+    errorCode: "not_found",
   };
 }
 
@@ -1264,7 +1280,10 @@ export function loadSkillBySelector(
 ): SkillLookupResult {
   const resolved = resolveSkillSelector(selector, workspaceSkillsDir);
   if (!resolved.skill) {
-    return { error: resolved.error ?? "Failed to resolve skill selector." };
+    return {
+      error: resolved.error ?? "Failed to resolve skill selector.",
+      errorCode: resolved.errorCode ?? "load_failed",
+    };
   }
   return loadSkillDefinition(resolved.skill);
 }

package/src/config/types.ts

@@ -12,13 +12,9 @@ export type {
   IngressConfig,
   LogFileConfig,
   MemoryConfig,
-  MemoryConflictsConfig,
   MemoryEmbeddingsConfig,
-  MemoryEntityConfig,
   MemoryExtractionConfig,
   MemoryJobsConfig,
-  MemoryProfileConfig,
-  MemoryRerankingConfig,
   MemoryRetentionConfig,
   MemoryRetrievalConfig,
   MemorySegmentationConfig,