@vellumai/assistant 0.4.43 → 0.4.45

package/src/home-base/prebuilt/seed-metadata.json

@@ -1,21 +0,0 @@
-{
-  "version": "v1",
-  "appName": "Home Base",
-  "descriptionPrefix": "[home-base-prebuilt:v1]",
-  "requiredAnchors": [
-    "home-base-root",
-    "home-base-onboarding-lane",
-    "home-base-starter-lane"
-  ],
-  "starterTasks": [
-    "Change the look and feel",
-    "Research something for me about X",
-    "Turn it into a webpage or interactive UI"
-  ],
-  "onboardingTasks": [
-    "Make it mine",
-    "Enable voice mode",
-    "Enable computer control",
-    "Try ambient mode"
-  ]
-}

package/src/home-base/prebuilt/seed.ts

@@ -1,122 +0,0 @@
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-
-import {
-  type AppDefinition,
-  createApp,
-  listApps,
-} from "../../memory/app-store.js";
-import { resolveBundledDir } from "../../util/bundled-asset.js";
-import { getLogger } from "../../util/logger.js";
-import {
-  HOME_BASE_PREBUILT_DESCRIPTION_PREFIX,
-  isPrebuiltHomeBaseApp,
-} from "../prebuilt-home-base-updater.js";
-// Static import so the JSON is bundled into compiled binaries (avoids ENOENT on $bunfs)
-import seedMetadataJson from "./seed-metadata.json" with { type: "json" };
-
-const log = getLogger("home-base-seed");
-
-interface SeedMetadata {
-  version: string;
-  appName: string;
-  starterTasks: string[];
-  onboardingTasks: string[];
-}
-
-export interface PrebuiltHomeBaseTaskPayload {
-  starterTasks: string[];
-  onboardingTasks: string[];
-}
-
-function getPrebuiltDir(): string {
-  return resolveBundledDir(import.meta.dirname ?? __dirname, ".", "prebuilt");
-}
-
-function loadSeedMetadata(): SeedMetadata {
-  return seedMetadataJson as SeedMetadata;
-}
-
-export function loadPrebuiltHtml(): string | null {
-  try {
-    return readFileSync(join(getPrebuiltDir(), "index.html"), "utf-8");
-  } catch {
-    log.warn(
-      "Could not load prebuilt index.html (expected in compiled binary)",
-    );
-    return null;
-  }
-}
-
-function buildDescription(metadata: SeedMetadata): string {
-  return [
-    `${HOME_BASE_PREBUILT_DESCRIPTION_PREFIX} ${metadata.version}`,
-    "Prebuilt Home Base dashboard scaffold seeded during onboarding/bootstrap.",
-    `Starter tasks: ${metadata.starterTasks.join(", ")}`,
-    `Onboarding tasks: ${metadata.onboardingTasks.join(", ")}`,
-  ].join(" ");
-}
-
-export function findSeededHomeBaseApp(): AppDefinition | null {
-  const apps = listApps();
-  for (const app of apps) {
-    if (isPrebuiltHomeBaseApp(app)) {
-      return app;
-    }
-  }
-  return null;
-}
-
-export function getPrebuiltHomeBasePreview(): {
-  title: string;
-  subtitle: string;
-  description: string;
-  icon: string;
-  metrics: Array<{ label: string; value: string }>;
-} {
-  return {
-    title: "Home Base",
-    subtitle: "Dashboard",
-    description: "Prebuilt onboarding + starter task canvas",
-    icon: "🏠",
-    metrics: [
-      { label: "Starter tasks", value: "3" },
-      { label: "Onboarding tasks", value: "4" },
-    ],
-  };
-}
-
-export function getPrebuiltHomeBaseTaskPayload(): PrebuiltHomeBaseTaskPayload {
-  const metadata = loadSeedMetadata();
-  return {
-    starterTasks: metadata.starterTasks,
-    onboardingTasks: metadata.onboardingTasks,
-  };
-}
-
-export function ensurePrebuiltHomeBaseSeeded(): {
-  appId: string;
-  created: boolean;
-} | null {
-  const existing = findSeededHomeBaseApp();
-  if (existing) {
-    return { appId: existing.id, created: false };
-  }
-
-  const metadata = loadSeedMetadata();
-  const html = loadPrebuiltHtml();
-  if (html == null) {
-    log.warn("Skipping Home Base seed — prebuilt HTML not available");
-    return null;
-  }
-
-  const created = createApp({
-    name: metadata.appName,
-    description: buildDescription(metadata),
-    schemaJson: "{}",
-    htmlDefinition: html,
-  });
-
-  log.info({ appId: created.id }, "Seeded prebuilt Home Base app");
-  return { appId: created.id, created: true };
-}

package/src/home-base/prebuilt-home-base-updater.ts

@@ -1,36 +0,0 @@
-import type { AppDefinition } from "../memory/app-store.js";
-
-export const HOME_BASE_REQUIRED_ANCHORS = [
-  "home-base-root",
-  "home-base-onboarding-lane",
-  "home-base-starter-lane",
-] as const;
-
-export const HOME_BASE_PREBUILT_DESCRIPTION_PREFIX = "[home-base-prebuilt:v1]";
-
-export function isPrebuiltHomeBaseApp(
-  app: Pick<AppDefinition, "name" | "description" | "htmlDefinition">,
-): boolean {
-  if (app.description?.startsWith(HOME_BASE_PREBUILT_DESCRIPTION_PREFIX)) {
-    return true;
-  }
-  return app.htmlDefinition?.includes('data-vellum-home-base="v1"') ?? false;
-}
-
-export function validatePrebuiltHomeBaseHtml(html: string): {
-  valid: boolean;
-  missingAnchors: string[];
-} {
-  const missingAnchors: string[] = [];
-  for (const anchor of HOME_BASE_REQUIRED_ANCHORS) {
-    const hasId =
-      html.includes(`id="${anchor}"`) || html.includes(`id='${anchor}'`);
-    if (!hasId) {
-      missingAnchors.push(anchor);
-    }
-  }
-  return {
-    valid: missingAnchors.length === 0,
-    missingAnchors,
-  };
-}

package/src/memory/account-store.ts

@@ -1,117 +0,0 @@
-import { randomUUID } from "node:crypto";
-
-import { and, eq } from "drizzle-orm";
-
-import { getDb } from "./db.js";
-import { accounts } from "./schema.js";
-
-export interface AccountRecord {
-  id: string;
-  service: string;
-  username: string | null;
-  email: string | null;
-  displayName: string | null;
-  status: string;
-  credentialRef: string | null;
-  metadataJson: string | null;
-  createdAt: number;
-  updatedAt: number;
-}
-
-export function createAccount(params: {
-  service: string;
-  username?: string;
-  email?: string;
-  displayName?: string;
-  status?: string;
-  credentialRef?: string;
-  metadata?: Record<string, unknown>;
-}): AccountRecord {
-  const db = getDb();
-  const now = Date.now();
-  const id = randomUUID();
-
-  const record = {
-    id,
-    service: params.service,
-    username: params.username ?? null,
-    email: params.email ?? null,
-    displayName: params.displayName ?? null,
-    status: params.status ?? "active",
-    credentialRef: params.credentialRef ?? null,
-    metadataJson: params.metadata ? JSON.stringify(params.metadata) : null,
-    createdAt: now,
-    updatedAt: now,
-  };
-
-  db.insert(accounts).values(record).run();
-  return record;
-}
-
-export function listAccounts(filters?: {
-  service?: string;
-  status?: string;
-}): AccountRecord[] {
-  const db = getDb();
-
-  const conditions = [];
-  if (filters?.service) {
-    conditions.push(eq(accounts.service, filters.service));
-  }
-  if (filters?.status) {
-    conditions.push(eq(accounts.status, filters.status));
-  }
-
-  if (conditions.length === 0) {
-    return db.select().from(accounts).all();
-  }
-  if (conditions.length === 1) {
-    return db.select().from(accounts).where(conditions[0]).all();
-  }
-  return db
-    .select()
-    .from(accounts)
-    .where(and(...conditions))
-    .all();
-}
-
-export function getAccount(id: string): AccountRecord | undefined {
-  const db = getDb();
-  const rows = db.select().from(accounts).where(eq(accounts.id, id)).all();
-  return rows[0] ?? undefined;
-}
-
-export function updateAccount(
-  id: string,
-  updates: {
-    service?: string;
-    username?: string;
-    email?: string;
-    displayName?: string;
-    status?: string;
-    credentialRef?: string;
-    metadata?: Record<string, unknown>;
-  },
-): AccountRecord | undefined {
-  const existing = getAccount(id);
-  if (!existing) return undefined;
-
-  const now = Date.now();
-  const values: Record<string, unknown> = { updatedAt: now };
-
-  if (updates.service !== undefined) values.service = updates.service;
-  if (updates.username !== undefined) values.username = updates.username;
-  if (updates.email !== undefined) values.email = updates.email;
-  if (updates.displayName !== undefined)
-    values.displayName = updates.displayName;
-  if (updates.status !== undefined) values.status = updates.status;
-  if (updates.credentialRef !== undefined)
-    values.credentialRef = updates.credentialRef;
-  if (updates.metadata !== undefined)
-    values.metadataJson = JSON.stringify(updates.metadata);
-
-  const db = getDb();
-  db.update(accounts).set(values).where(eq(accounts.id, id)).run();
-
-  return getAccount(id);
-}

package/src/messaging/activity-analyzer.ts

@@ -1,76 +0,0 @@
-/**
- * Activity classifier for messaging conversations.
- *
- * Takes Conversation[] from any provider and groups them by activity level.
- * Works for Slack channels, Gmail senders, Discord servers — anything
- * that maps to the Conversation type.
- */
-
-import type { Conversation } from "./provider-types.js";
-
-export type ActivityLevel = "dead" | "low" | "medium" | "high";
-
-export interface ActivityGroup {
-  level: ActivityLevel;
-  conversations: Conversation[];
-}
-
-export interface ActivitySummary {
-  platform: string;
-  totalConversations: number;
-  groups: ActivityGroup[];
-}
-
-const ONE_DAY_MS = 24 * 60 * 60 * 1000;
-
-/**
- * Classify conversations by activity level based on last activity timestamp
- * and unread count. Returns sorted groups from high to dead.
- */
-export function classifyActivity(
-  conversations: Conversation[],
-  platform: string,
-  now = Date.now(),
-): ActivitySummary {
-  const groups: Record<ActivityLevel, Conversation[]> = {
-    high: [],
-    medium: [],
-    low: [],
-    dead: [],
-  };
-
-  for (const conv of conversations) {
-    const ageDays = (now - conv.lastActivityAt) / ONE_DAY_MS;
-
-    let level: ActivityLevel;
-    if (conv.unreadCount > 0 && ageDays < 1) {
-      level = "high";
-    } else if (ageDays < 7) {
-      level = "medium";
-    } else if (ageDays < 30) {
-      level = "low";
-    } else {
-      level = "dead";
-    }
-
-    groups[level].push(conv);
-  }
-
-  // Sort each group by lastActivityAt descending
-  for (const level of Object.keys(groups) as ActivityLevel[]) {
-    groups[level].sort((a, b) => b.lastActivityAt - a.lastActivityAt);
-  }
-
-  const result: ActivityGroup[] = [];
-  for (const level of ["high", "medium", "low", "dead"] as ActivityLevel[]) {
-    if (groups[level].length > 0) {
-      result.push({ level, conversations: groups[level] });
-    }
-  }
-
-  return {
-    platform,
-    totalConversations: conversations.length,
-    groups: result,
-  };
-}

package/src/messaging/email-classifier.ts

@@ -1,208 +0,0 @@
-/**
- * LLM-powered email classification for inbox triage.
- * Works with metadata only (from, subject, snippet, labels) to keep token usage low.
- */
-
-import {
-  createTimeout,
-  extractToolUse,
-  getConfiguredProvider,
-  userMessage,
-} from "../providers/provider-send-message.js";
-import { getLogger } from "../util/logger.js";
-
-const log = getLogger("email-classifier");
-
-const CLASSIFICATION_MODEL_INTENT = "latency-optimized" as const;
-const CLASSIFICATION_TIMEOUT_MS = 30_000;
-
-export type EmailCategory =
-  | "needs_reply"
-  | "fyi_only"
-  | "can_archive"
-  | "urgent"
-  | "newsletter"
-  | "promotional";
-
-export interface EmailMetadata {
-  id: string;
-  from: string;
-  subject: string;
-  snippet: string;
-  labels: string[];
-}
-
-export interface ClassifiedEmail {
-  id: string;
-  category: EmailCategory;
-  reasoning: string;
-  suggestedAction: string;
-  urgencyScore: number; // 0-1
-}
-
-export interface ClassificationResult {
-  classifications: ClassifiedEmail[];
-}
-
-const VALID_CATEGORIES = new Set<EmailCategory>([
-  "needs_reply",
-  "fyi_only",
-  "can_archive",
-  "urgent",
-  "newsletter",
-  "promotional",
-]);
-
-const SYSTEM_PROMPT = `You are an email triage system. Given email metadata (sender, subject, snippet, labels), classify each email into exactly one category:
-
-- needs_reply: Requires a personal response from the user
-- fyi_only: Informational, no action needed but worth reading
-- can_archive: Safe to archive without reading (automated notifications, receipts, etc.)
-- urgent: Time-sensitive and requires immediate attention
-- newsletter: Regular newsletter or digest
-- promotional: Marketing, sales, or promotional content
-
-For each email, provide:
-- category: One of the categories above
-- reasoning: Brief explanation of the classification (1 sentence)
-- suggested_action: What the user should do (e.g., "Reply to confirm", "Archive", "Read later")
-- urgency_score: 0.0 (not urgent) to 1.0 (extremely urgent)
-
-You MUST respond using the \`store_classifications\` tool. Do not respond with text.`;
-
-const STORE_CLASSIFICATIONS_TOOL = {
-  name: "store_classifications",
-  description: "Store email classification results",
-  input_schema: {
-    type: "object" as const,
-    properties: {
-      classifications: {
-        type: "array",
-        items: {
-          type: "object",
-          properties: {
-            id: { type: "string", description: "Email ID" },
-            category: {
-              type: "string",
-              enum: [
-                "needs_reply",
-                "fyi_only",
-                "can_archive",
-                "urgent",
-                "newsletter",
-                "promotional",
-              ],
-            },
-            reasoning: {
-              type: "string",
-              description: "Brief classification reasoning",
-            },
-            suggested_action: {
-              type: "string",
-              description: "Suggested action for the user",
-            },
-            urgency_score: { type: "number", description: "Urgency score 0-1" },
-          },
-          required: [
-            "id",
-            "category",
-            "reasoning",
-            "suggested_action",
-            "urgency_score",
-          ],
-        },
-      },
-    },
-    required: ["classifications"],
-  },
-};
-
-function formatEmailsForPrompt(emails: EmailMetadata[]): string {
-  return emails
-    .map((e, i) =>
-      [
-        `--- Email ${i + 1} (ID: ${e.id}) ---`,
-        `From: ${e.from}`,
-        `Subject: ${e.subject}`,
-        `Snippet: ${e.snippet}`,
-        `Labels: ${e.labels.join(", ") || "none"}`,
-      ].join("\n"),
-    )
-    .join("\n\n");
-}
-
-export async function classifyEmails(
-  emails: EmailMetadata[],
-): Promise<ClassificationResult> {
-  if (emails.length === 0) {
-    return { classifications: [] };
-  }
-
-  const provider = getConfiguredProvider();
-  if (!provider) {
-    log.warn("Configured provider unavailable for email classification");
-    return { classifications: [] };
-  }
-
-  const prompt = `Classify these ${
-    emails.length
-  } emails:\n\n${formatEmailsForPrompt(emails)}`;
-
-  try {
-    const { signal, cleanup } = createTimeout(CLASSIFICATION_TIMEOUT_MS);
-
-    try {
-      const response = await provider.sendMessage(
-        [userMessage(prompt)],
-        [STORE_CLASSIFICATIONS_TOOL],
-        SYSTEM_PROMPT,
-        {
-          config: {
-            modelIntent: CLASSIFICATION_MODEL_INTENT,
-            max_tokens: 2048,
-            tool_choice: {
-              type: "tool" as const,
-              name: "store_classifications",
-            },
-          },
-          signal,
-        },
-      );
-      cleanup();
-
-      const toolBlock = extractToolUse(response);
-      if (!toolBlock) {
-        log.warn("No tool_use block in classification response");
-        return { classifications: [] };
-      }
-
-      const input = toolBlock.input as {
-        classifications?: Array<{
-          id: string;
-          category: string;
-          reasoning: string;
-          suggested_action: string;
-          urgency_score: number;
-        }>;
-      };
-
-      const classifications: ClassifiedEmail[] = (input.classifications ?? [])
-        .filter((c) => VALID_CATEGORIES.has(c.category as EmailCategory))
-        .map((c) => ({
-          id: c.id,
-          category: c.category as EmailCategory,
-          reasoning: c.reasoning,
-          suggestedAction: c.suggested_action,
-          urgencyScore: Math.max(0, Math.min(1, c.urgency_score)),
-        }));
-
-      return { classifications };
-    } finally {
-      cleanup();
-    }
-  } catch (e) {
-    const message = e instanceof Error ? e.message : String(e);
-    log.warn({ err: message }, "Email classification LLM call failed");
-    return { classifications: [] };
-  }
-}

package/src/messaging/index.ts

@@ -1,2 +0,0 @@
-export { summarizeThread } from "./thread-summarizer.js";
-export * from "./types.js";