@vellumai/assistant 0.4.42 → 0.4.44

package/src/config/schemas/inference.ts

@@ -0,0 +1,136 @@
+import { z } from "zod";
+
+const VALID_LATEST_TURN_COMPRESSION_POLICIES = [
+  "truncate",
+  "summarize",
+  "drop",
+] as const;
+
+export { VALID_LATEST_TURN_COMPRESSION_POLICIES };
+
+export const ThinkingConfigSchema = z.object({
+  enabled: z
+    .boolean({ error: "thinking.enabled must be a boolean" })
+    .default(false),
+  streamThinking: z
+    .boolean({ error: "thinking.streamThinking must be a boolean" })
+    .default(false),
+});
+
+export const EffortSchema = z
+  .enum(["low", "medium", "high"], {
+    error: 'effort must be "low", "medium", or "high"',
+  })
+  .default("high");
+
+export type Effort = z.infer<typeof EffortSchema>;
+
+export const ContextOverflowRecoveryConfigSchema = z.object({
+  enabled: z
+    .boolean({
+      error: "contextWindow.overflowRecovery.enabled must be a boolean",
+    })
+    .default(true),
+  safetyMarginRatio: z
+    .number({
+      error:
+        "contextWindow.overflowRecovery.safetyMarginRatio must be a number",
+    })
+    .finite("contextWindow.overflowRecovery.safetyMarginRatio must be finite")
+    .gt(
+      0,
+      "contextWindow.overflowRecovery.safetyMarginRatio must be greater than 0",
+    )
+    .lt(
+      1,
+      "contextWindow.overflowRecovery.safetyMarginRatio must be less than 1",
+    )
+    .default(0.05),
+  maxAttempts: z
+    .number({
+      error: "contextWindow.overflowRecovery.maxAttempts must be a number",
+    })
+    .int("contextWindow.overflowRecovery.maxAttempts must be an integer")
+    .positive(
+      "contextWindow.overflowRecovery.maxAttempts must be a positive integer",
+    )
+    .default(3),
+  interactiveLatestTurnCompression: z
+    .enum(VALID_LATEST_TURN_COMPRESSION_POLICIES, {
+      error: `contextWindow.overflowRecovery.interactiveLatestTurnCompression must be one of: ${VALID_LATEST_TURN_COMPRESSION_POLICIES.join(
+        ", ",
+      )}`,
+    })
+    .default("summarize"),
+  nonInteractiveLatestTurnCompression: z
+    .enum(VALID_LATEST_TURN_COMPRESSION_POLICIES, {
+      error: `contextWindow.overflowRecovery.nonInteractiveLatestTurnCompression must be one of: ${VALID_LATEST_TURN_COMPRESSION_POLICIES.join(
+        ", ",
+      )}`,
+    })
+    .default("truncate"),
+});
+
+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(200000),
+  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),
+  overflowRecovery: ContextOverflowRecoveryConfigSchema.default(
+    ContextOverflowRecoveryConfigSchema.parse({}),
+  ),
+});
+
+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 type ThinkingConfig = z.infer<typeof ThinkingConfigSchema>;
+export type ContextOverflowRecoveryConfig = z.infer<
+  typeof ContextOverflowRecoveryConfigSchema
+>;
+export type ContextWindowConfig = z.infer<typeof ContextWindowConfigSchema>;
+export type ModelPricingOverride = z.infer<typeof ModelPricingOverrideSchema>;

package/src/config/schemas/ingress.ts

@@ -0,0 +1,81 @@
+import { z } from "zod";
+
+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(
+    IngressWebhookConfigSchema.parse({}),
+  ),
+  rateLimit: IngressRateLimitConfigSchema.default(
+    IngressRateLimitConfigSchema.parse({}),
+  ),
+  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(
+  IngressBaseSchema.parse({}),
+).transform((val) => ({
+  ...val,
+  enabled: val.enabled,
+}));
+
+export type IngressWebhookConfig = z.infer<typeof IngressWebhookConfigSchema>;
+export type IngressRateLimitConfig = z.infer<
+  typeof IngressRateLimitConfigSchema
+>;
+export type IngressConfig = z.infer<typeof IngressConfigSchema>;

package/src/config/schemas/logging.ts

@@ -0,0 +1,21 @@
+import { z } from "zod";
+
+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 type AuditLogConfig = z.infer<typeof AuditLogConfigSchema>;
+export type LogFileConfig = z.infer<typeof LogFileConfigSchema>;

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

@@ -0,0 +1,67 @@
+import { z } from "zod";
+
+export const MemoryJobsConfigSchema = z.object({
+  workerConcurrency: z
+    .number({ error: "memory.jobs.workerConcurrency must be a number" })
+    .int("memory.jobs.workerConcurrency must be an integer")
+    .positive("memory.jobs.workerConcurrency must be a positive integer")
+    .default(2),
+  batchSize: z
+    .number({ error: "memory.jobs.batchSize must be a number" })
+    .int("memory.jobs.batchSize must be an integer")
+    .positive("memory.jobs.batchSize must be a positive integer")
+    .default(10),
+  stalledJobTimeoutMs: z
+    .number({ error: "memory.jobs.stalledJobTimeoutMs must be a number" })
+    .int("memory.jobs.stalledJobTimeoutMs must be an integer")
+    .positive("memory.jobs.stalledJobTimeoutMs must be a positive integer")
+    .default(30 * 60 * 1000),
+});
+
+export const MemoryRetentionConfigSchema = z.object({
+  keepRawForever: z
+    .boolean({ error: "memory.retention.keepRawForever must be a boolean" })
+    .default(true),
+});
+
+export const MemoryCleanupConfigSchema = z.object({
+  enabled: z
+    .boolean({ error: "memory.cleanup.enabled must be a boolean" })
+    .default(true),
+  enqueueIntervalMs: z
+    .number({ error: "memory.cleanup.enqueueIntervalMs must be a number" })
+    .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",
+    })
+    .int("memory.cleanup.supersededItemRetentionMs must be an integer")
+    .positive(
+      "memory.cleanup.supersededItemRetentionMs must be a positive integer",
+    )
+    .default(30 * 24 * 60 * 60 * 1000),
+  conversationRetentionDays: z
+    .number({
+      error: "memory.cleanup.conversationRetentionDays must be a number",
+    })
+    .int("memory.cleanup.conversationRetentionDays must be an integer")
+    .nonnegative(
+      "memory.cleanup.conversationRetentionDays must be non-negative",
+    )
+    .default(90),
+});
+
+export type MemoryJobsConfig = z.infer<typeof MemoryJobsConfigSchema>;
+export type MemoryRetentionConfig = z.infer<typeof MemoryRetentionConfigSchema>;
+export type MemoryCleanupConfig = z.infer<typeof MemoryCleanupConfigSchema>;

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

@@ -0,0 +1,215 @@
+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" })
+    .default(true),
+  modelIntent: z
+    .enum(["latency-optimized", "quality-optimized", "vision-optimized"], {
+      error: "memory.extraction.modelIntent must be a valid model intent",
+    })
+    .default("latency-optimized"),
+  extractFromAssistant: z
+    .boolean({
+      error: "memory.extraction.extractFromAssistant must be a boolean",
+    })
+    .default(true),
+});
+
+export const MemorySummarizationConfigSchema = z.object({
+  useLLM: z
+    .boolean({ error: "memory.summarization.useLLM must be a boolean" })
+    .default(true),
+  modelIntent: z
+    .enum(["latency-optimized", "quality-optimized", "vision-optimized"], {
+      error: "memory.summarization.modelIntent must be a valid model intent",
+    })
+    .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>;