@vellumai/assistant 0.4.26 → 0.4.30

package/src/config/notifications-schema.ts

@@ -1,11 +1,11 @@
-import { z } from 'zod';
+import { z } from "zod";
 
 export const NotificationsConfigSchema = z.object({
   decisionModelIntent: z
-    .enum(['latency-optimized', 'quality-optimized', 'vision-optimized'], {
-      error: 'notifications.decisionModelIntent must be a valid model intent',
+    .enum(["latency-optimized", "quality-optimized", "vision-optimized"], {
+      error: "notifications.decisionModelIntent must be a valid model intent",
     })
-    .default('latency-optimized'),
+    .default("latency-optimized"),
 });
 
 export type NotificationsConfig = z.infer<typeof NotificationsConfigSchema>;

package/src/config/sandbox-schema.ts

@@ -1,8 +1,8 @@
-import { z } from 'zod';
+import { z } from "zod";
 
 export const SandboxConfigSchema = z.object({
   enabled: z
-    .boolean({ error: 'sandbox.enabled must be a boolean' })
+    .boolean({ error: "sandbox.enabled must be a boolean" })
     .default(true),
 });
 

package/src/config/schema.ts

@@ -32,8 +32,10 @@ export {
 } from "./calls-schema.js";
 export type {
   AuditLogConfig,
+  ContextOverflowRecoveryConfig,
   ContextWindowConfig,
   DaemonConfig,
+  Effort,
   IngressConfig,
   IngressRateLimitConfig,
   IngressWebhookConfig,
@@ -50,8 +52,10 @@ export type {
 } from "./core-schema.js";
 export {
   AuditLogConfigSchema,
+  ContextOverflowRecoveryConfigSchema,
   ContextWindowConfigSchema,
   DaemonConfigSchema,
+  EffortSchema,
   IngressConfigSchema,
   IngressRateLimitConfigSchema,
   IngressWebhookConfigSchema,
@@ -145,6 +149,7 @@ import {
   AuditLogConfigSchema,
   ContextWindowConfigSchema,
   DaemonConfigSchema,
+  EffortSchema,
   IngressConfigSchema,
   LogFileConfigSchema,
   ModelPricingOverrideSchema,
@@ -199,13 +204,17 @@ export const AssistantConfigSchema = z
       .default({} as any),
     webSearchProvider: z
       .enum(VALID_WEB_SEARCH_PROVIDERS, {
-        error: `webSearchProvider must be one of: ${VALID_WEB_SEARCH_PROVIDERS.join(", ")}`,
+        error: `webSearchProvider must be one of: ${VALID_WEB_SEARCH_PROVIDERS.join(
+          ", ",
+        )}`,
       })
       .default("anthropic-native"),
     providerOrder: z
       .array(
         z.enum(VALID_PROVIDERS, {
-          error: `Each providerOrder entry must be one of: ${VALID_PROVIDERS.join(", ")}`,
+          error: `Each providerOrder entry must be one of: ${VALID_PROVIDERS.join(
+            ", ",
+          )}`,
         }),
       )
       .default([]),
@@ -219,6 +228,7 @@ export const AssistantConfigSchema = z
       .int("maxToolUseTurns must be an integer")
       .nonnegative("maxToolUseTurns must be a non-negative integer")
       .default(40),
+    effort: EffortSchema,
     thinking: ThinkingConfigSchema.default(ThinkingConfigSchema.parse({})),
     contextWindow: ContextWindowConfigSchema.default(
       ContextWindowConfigSchema.parse({}),

package/src/config/skill-state.ts

@@ -1,9 +1,9 @@
-import { isAssistantFeatureFlagEnabled } from './assistant-feature-flags.js';
-import type { AssistantConfig, SkillEntryConfig } from './schema.js';
-import type { SkillSummary } from './skills.js';
-import { checkSkillRequirements } from './skills.js';
+import { isAssistantFeatureFlagEnabled } from "./assistant-feature-flags.js";
+import type { AssistantConfig, SkillEntryConfig } from "./schema.js";
+import type { SkillSummary } from "./skills.js";
+import { checkSkillRequirements } from "./skills.js";
 
-export type SkillState = 'enabled' | 'disabled' | 'degraded' | 'available';
+export type SkillState = "enabled" | "disabled" | "degraded" | "available";
 
 export interface ResolvedSkill {
   summary: SkillSummary;
@@ -18,7 +18,7 @@ export interface ResolvedSkill {
 // gated by the `sms` flag so that the macOS Settings SMS toggle controls
 // both the channel UI and the setup skill.
 const SKILL_FLAG_KEY_OVERRIDES: Record<string, string> = {
-  'sms-setup': 'feature_flags.sms.enabled',
+  "sms-setup": "feature_flags.sms.enabled",
 };
 
 /**
@@ -28,7 +28,9 @@ const SKILL_FLAG_KEY_OVERRIDES: Record<string, string> = {
  * can perform the same mapping without duplicating the override table.
  */
 export function skillFlagKey(skillId: string): string {
-  return SKILL_FLAG_KEY_OVERRIDES[skillId] ?? `feature_flags.${skillId}.enabled`;
+  return (
+    SKILL_FLAG_KEY_OVERRIDES[skillId] ?? `feature_flags.${skillId}.enabled`
+  );
 }
 
 /**
@@ -37,7 +39,10 @@ export function skillFlagKey(skillId: string): string {
  * Thin backward-compatible wrapper that delegates to the canonical resolver.
  * Kept to avoid breaking existing call sites during migration.
  */
-export function isSkillFeatureEnabled(skillId: string, config: AssistantConfig): boolean {
+export function isSkillFeatureEnabled(
+  skillId: string,
+  config: AssistantConfig,
+): boolean {
   return isAssistantFeatureFlagEnabled(skillFlagKey(skillId), config);
 }
 
@@ -46,7 +51,10 @@ export function resolveSkillStates(
   config: AssistantConfig,
 ): ResolvedSkill[] {
   const results: ResolvedSkill[] = [];
-  const { entries, allowBundled } = config.skills ?? { entries: {}, allowBundled: null };
+  const { entries, allowBundled } = config.skills ?? {
+    entries: {},
+    allowBundled: null,
+  };
 
   for (const skill of catalog) {
     // Assistant feature flag gate: if the flag is explicitly OFF, skip this skill entirely
@@ -55,7 +63,11 @@ export function resolveSkillStates(
     }
 
     // Filter bundled skills by allowlist
-    if (skill.source === 'bundled' && allowBundled != null && !allowBundled.includes(skill.id)) {
+    if (
+      skill.source === "bundled" &&
+      allowBundled != null &&
+      !allowBundled.includes(skill.id)
+    ) {
       continue;
     }
 
@@ -64,17 +76,17 @@ export function resolveSkillStates(
 
     // Determine enabled state
     let isEnabled: boolean;
-    if (entry && typeof entry.enabled === 'boolean') {
+    if (entry && typeof entry.enabled === "boolean") {
       isEnabled = entry.enabled;
     } else {
       // Default: bundled and managed (user-installed) skills are enabled, others are disabled
-      isEnabled = skill.source === 'bundled' || skill.source === 'managed';
+      isEnabled = skill.source === "bundled" || skill.source === "managed";
     }
 
     if (!isEnabled) {
       results.push({
         summary: skill,
-        state: 'disabled',
+        state: "disabled",
         degraded: false,
         configEntry: entry,
       });
@@ -88,7 +100,7 @@ export function resolveSkillStates(
     if (!reqCheck.eligible) {
       results.push({
         summary: skill,
-        state: 'degraded',
+        state: "degraded",
         degraded: true,
         missingRequirements: reqCheck.missing,
         configEntry: entry,
@@ -96,7 +108,7 @@ export function resolveSkillStates(
     } else {
       results.push({
         summary: skill,
-        state: 'enabled',
+        state: "enabled",
         degraded: false,
         configEntry: entry,
       });

package/src/config/skills-schema.ts

@@ -1,52 +1,101 @@
-import { z } from 'zod';
+import { z } from "zod";
 
 export const SkillEntryConfigSchema = z.object({
-  enabled: z.boolean({ error: 'skills.entries[].enabled must be a boolean' }).default(true),
-  apiKey: z.string({ error: 'skills.entries[].apiKey must be a string' }).optional(),
-  env: z.record(z.string(), z.string({ error: 'skills.entries[].env values must be strings' })).optional(),
+  enabled: z
+    .boolean({ error: "skills.entries[].enabled must be a boolean" })
+    .default(true),
+  apiKey: z
+    .string({ error: "skills.entries[].apiKey must be a string" })
+    .optional(),
+  env: z
+    .record(
+      z.string(),
+      z.string({ error: "skills.entries[].env values must be strings" }),
+    )
+    .optional(),
   config: z.record(z.string(), z.unknown()).optional(),
 });
 
 export const SkillsLoadConfigSchema = z.object({
-  extraDirs: z.array(z.string({ error: 'skills.load.extraDirs values must be strings' })).default([]),
-  watch: z.boolean({ error: 'skills.load.watch must be a boolean' }).default(true),
-  watchDebounceMs: z.number({ error: 'skills.load.watchDebounceMs must be a number' }).int().positive().default(250),
+  extraDirs: z
+    .array(z.string({ error: "skills.load.extraDirs values must be strings" }))
+    .default([]),
+  watch: z
+    .boolean({ error: "skills.load.watch must be a boolean" })
+    .default(true),
+  watchDebounceMs: z
+    .number({ error: "skills.load.watchDebounceMs must be a number" })
+    .int()
+    .positive()
+    .default(250),
 });
 
 export const SkillsInstallConfigSchema = z.object({
-  nodeManager: z.enum(['npm', 'pnpm', 'yarn', 'bun'], {
-    error: 'skills.install.nodeManager must be one of: npm, pnpm, yarn, bun',
-  }).default('npm'),
+  nodeManager: z
+    .enum(["npm", "pnpm", "yarn", "bun"], {
+      error: "skills.install.nodeManager must be one of: npm, pnpm, yarn, bun",
+    })
+    .default("npm"),
 });
 
 export const RemoteProviderConfigSchema = z.object({
-  enabled: z.boolean({ error: 'skills.remoteProviders.<provider>.enabled must be a boolean' }).default(true),
+  enabled: z
+    .boolean({
+      error: "skills.remoteProviders.<provider>.enabled must be a boolean",
+    })
+    .default(true),
 });
 
 export const RemoteProvidersConfigSchema = z.object({
-  skillssh: RemoteProviderConfigSchema.default(RemoteProviderConfigSchema.parse({})),
-  clawhub: RemoteProviderConfigSchema.default(RemoteProviderConfigSchema.parse({})),
+  skillssh: RemoteProviderConfigSchema.default(
+    RemoteProviderConfigSchema.parse({}),
+  ),
+  clawhub: RemoteProviderConfigSchema.default(
+    RemoteProviderConfigSchema.parse({}),
+  ),
 });
 
 // 'unknown' is valid as a risk label on a skill but not as a threshold — setting the threshold
 // to 'unknown' would silently disable fail-closed behavior since nothing can exceed it.
-const VALID_MAX_RISK_LEVELS = ['safe', 'low', 'medium', 'high', 'critical'] as const;
+const VALID_MAX_RISK_LEVELS = [
+  "safe",
+  "low",
+  "medium",
+  "high",
+  "critical",
+] as const;
 
 export const RemotePolicyConfigSchema = z.object({
-  blockSuspicious: z.boolean({ error: 'skills.remotePolicy.blockSuspicious must be a boolean' }).default(true),
-  blockMalware: z.boolean({ error: 'skills.remotePolicy.blockMalware must be a boolean' }).default(true),
-  maxSkillsShRisk: z.enum(VALID_MAX_RISK_LEVELS, {
-    error: `skills.remotePolicy.maxSkillsShRisk must be one of: ${VALID_MAX_RISK_LEVELS.join(', ')}`,
-  }).default('medium'),
+  blockSuspicious: z
+    .boolean({ error: "skills.remotePolicy.blockSuspicious must be a boolean" })
+    .default(true),
+  blockMalware: z
+    .boolean({ error: "skills.remotePolicy.blockMalware must be a boolean" })
+    .default(true),
+  maxSkillsShRisk: z
+    .enum(VALID_MAX_RISK_LEVELS, {
+      error: `skills.remotePolicy.maxSkillsShRisk must be one of: ${VALID_MAX_RISK_LEVELS.join(
+        ", ",
+      )}`,
+    })
+    .default("medium"),
 });
 
 export const SkillsConfigSchema = z.object({
-  entries: z.record(z.string(), SkillEntryConfigSchema).default({} as Record<string, never>),
+  entries: z
+    .record(z.string(), SkillEntryConfigSchema)
+    .default({} as Record<string, never>),
   load: SkillsLoadConfigSchema.default(SkillsLoadConfigSchema.parse({})),
-  install: SkillsInstallConfigSchema.default(SkillsInstallConfigSchema.parse({})),
+  install: SkillsInstallConfigSchema.default(
+    SkillsInstallConfigSchema.parse({}),
+  ),
   allowBundled: z.array(z.string()).nullable().default(null),
-  remoteProviders: RemoteProvidersConfigSchema.default(RemoteProvidersConfigSchema.parse({})),
-  remotePolicy: RemotePolicyConfigSchema.default(RemotePolicyConfigSchema.parse({})),
+  remoteProviders: RemoteProvidersConfigSchema.default(
+    RemoteProvidersConfigSchema.parse({}),
+  ),
+  remotePolicy: RemotePolicyConfigSchema.default(
+    RemotePolicyConfigSchema.parse({}),
+  ),
 });
 
 export type SkillEntryConfig = z.infer<typeof SkillEntryConfigSchema>;