@vellumai/assistant 0.6.4 → 0.6.6

package/src/config/bundled-skills/google-calendar/tools/calendar-rsvp.ts

@@ -1,58 +0,0 @@
-import type {
-  ToolContext,
-  ToolExecutionResult,
-} from "../../../../tools/types.js";
-import * as calendar from "../calendar-client.js";
-import { getCalendarConnection, ok } from "./shared.js";
-
-export async function run(
-  input: Record<string, unknown>,
-  _context: ToolContext,
-): Promise<ToolExecutionResult> {
-  const account = input.account as string | undefined;
-  const eventId = input.event_id as string;
-  const response = input.response as "accepted" | "declined" | "tentative";
-  const calendarId = (input.calendar_id as string) ?? "primary";
-
-  const connection = await getCalendarConnection(account);
-
-  // First get the event to find the user's attendee entry
-  const event = await calendar.getEvent(connection, eventId, calendarId);
-  const selfAttendee = event.attendees?.find((a) => a.self);
-
-  if (!selfAttendee) {
-    // If the user is the organizer and not in the attendees list,
-    // they don't need to RSVP
-    if (event.organizer?.self) {
-      return ok("You are the organizer of this event. No RSVP needed.");
-    }
-    return ok(
-      "Could not find your attendee entry for this event. You may not be invited.",
-    );
-  }
-
-  // Update the attendee's response status
-  const updatedAttendees = event.attendees!.map((a) =>
-    a.self ? { ...a, responseStatus: response } : a,
-  );
-
-  await calendar.patchEvent(
-    connection,
-    eventId,
-    {
-      attendees: updatedAttendees as Array<{
-        email: string;
-        responseStatus?: string;
-      }>,
-    },
-    calendarId,
-  );
-
-  const responseLabel =
-    response === "accepted"
-      ? "Accepted"
-      : response === "declined"
-        ? "Declined"
-        : "Tentatively accepted";
-  return ok(`${responseLabel} the event "${event.summary ?? eventId}".`);
-}

package/src/config/bundled-skills/google-calendar/tools/shared.ts

@@ -1,17 +0,0 @@
-import type { OAuthConnection } from "../../../../oauth/connection.js";
-import { resolveOAuthConnection } from "../../../../oauth/connection-resolver.js";
-import type { ToolExecutionResult } from "../../../../tools/types.js";
-
-export function ok(content: string): ToolExecutionResult {
-  return { content, isError: false };
-}
-
-/**
- * Calendar uses the same OAuth credential service as Gmail since both
- * scopes are granted in a single OAuth consent flow.
- */
-export async function getCalendarConnection(
-  account?: string,
-): Promise<OAuthConnection> {
-  return resolveOAuthConnection("google", { account });
-}

package/src/config/bundled-skills/google-calendar/types.ts

@@ -1,97 +0,0 @@
-/** Event time - either a dateTime with timezone or a date for all-day events. */
-export interface EventDateTime {
-  dateTime?: string;
-  date?: string;
-  timeZone?: string;
-}
-
-/** Calendar event attendee. */
-export interface EventAttendee {
-  email: string;
-  displayName?: string;
-  responseStatus?: "needsAction" | "declined" | "tentative" | "accepted";
-  self?: boolean;
-  organizer?: boolean;
-  optional?: boolean;
-}
-
-/** Calendar event organizer. */
-export interface EventOrganizer {
-  email?: string;
-  displayName?: string;
-  self?: boolean;
-}
-
-/** A single Google Calendar event. */
-export interface CalendarEvent {
-  id: string;
-  status?: "confirmed" | "tentative" | "cancelled";
-  summary?: string;
-  description?: string;
-  location?: string;
-  start?: EventDateTime;
-  end?: EventDateTime;
-  attendees?: EventAttendee[];
-  organizer?: EventOrganizer;
-  creator?: { email?: string; displayName?: string };
-  htmlLink?: string;
-  created?: string;
-  updated?: string;
-  recurringEventId?: string;
-  hangoutLink?: string;
-  conferenceData?: Record<string, unknown>;
-}
-
-/** Events list response. */
-export interface CalendarEventsListResponse {
-  items?: CalendarEvent[];
-  nextPageToken?: string;
-  summary?: string;
-  timeZone?: string;
-  updated?: string;
-  nextSyncToken?: string;
-}
-
-/** Free/busy query request body. */
-export interface FreeBusyRequest {
-  timeMin: string;
-  timeMax: string;
-  timeZone?: string;
-  items: Array<{ id: string }>;
-}
-
-/** A single busy period. */
-export interface BusyPeriod {
-  start: string;
-  end: string;
-}
-
-/** Free/busy response for a single calendar. */
-export interface CalendarFreeBusy {
-  busy: BusyPeriod[];
-  errors?: Array<{ domain: string; reason: string }>;
-}
-
-/** Free/busy query response. */
-export interface FreeBusyResponse {
-  kind?: string;
-  timeMin?: string;
-  timeMax?: string;
-  calendars?: Record<string, CalendarFreeBusy>;
-}
-
-/** Calendar list entry (metadata about a calendar). */
-export interface CalendarListEntry {
-  id: string;
-  summary?: string;
-  description?: string;
-  timeZone?: string;
-  primary?: boolean;
-  accessRole?: "freeBusyReader" | "reader" | "writer" | "owner";
-}
-
-/** Calendar list response. */
-export interface CalendarListResponse {
-  items?: CalendarListEntry[];
-  nextPageToken?: string;
-}

package/src/config/bundled-skills/heartbeat/SKILL.md

@@ -1,43 +0,0 @@
----
-name: heartbeat
-description: Configure periodic background checklist runs
-compatibility: "Designed for Vellum personal assistants"
-metadata:
-  emoji: "\U0001F493"
-  vellum:
-    display-name: "Heartbeat"
-    activation-hints:
-      - "Set up a heartbeat, periodic checklist, background health check, or recurring background task"
-    avoid-when:
-      - "One-off or recurring schedules with specific payloads - use the schedule skill instead"
----
-
-The heartbeat feature runs your `HEARTBEAT.md` checklist periodically in a background conversation. Each run, the assistant works through the checklist and flags anything that needs attention.
-
-## Setup
-
-Edit `config.json` using `file_edit`:
-
-1. **Enable heartbeat**: Set `heartbeat.enabled` to `true`.
-2. **Set interval**: Set `heartbeat.intervalMs` (milliseconds between runs, default: 3600000 = 1 hour).
-3. **Optional active hours**: Set `heartbeat.activeHoursStart` and `heartbeat.activeHoursEnd` (0-23) to restrict runs to certain hours. Both must be set together.
-
-Example config.json heartbeat section:
-```json
-{
-  "heartbeat": {
-    "enabled": true,
-    "intervalMs": 1800000,
-    "activeHoursStart": 8,
-    "activeHoursEnd": 22
-  }
-}
-```
-
-Then edit `HEARTBEAT.md` with the checklist items. The assistant will work through this file each heartbeat run.
-
-## Notes
-
-- Toggling `heartbeat.enabled` requires an assistant restart to take effect.
-- Changes to `HEARTBEAT.md` take effect on the next heartbeat run (no restart needed).
-- The heartbeat runs in a separate background conversation, not the user's active chat.

package/src/config/bundled-skills/notifications/SKILL.md

@@ -1,40 +0,0 @@
----
-name: notifications
-description: Send notifications through the unified notification router
-compatibility: "Designed for Vellum personal assistants"
-metadata:
-  emoji: "🔔"
-  vellum:
-    display-name: "Notifications"
----
-
-Use `send_notification` for user-facing alerts and notifications. This tool routes through the unified notification pipeline, which handles channel selection, delivery, deduplication, and audit logging.
-
-## Routing Behavior
-
-- `preferred_channels` are **routing hints**, not hard channel forcing. The notification router makes the final delivery decision based on user preferences, channel availability, and urgency.
-- Channel selection and delivery are handled entirely by the notification router -- do not attempt to control delivery manually.
-
-## Deduplication (`dedupe_key`)
-
-- `dedupe_key` suppresses duplicate signals **permanently**. A second notification with the same key is **dropped entirely** for the lifetime of the assistant's event store. Once a key has been used, it cannot be reused - any future notification with the same key will be silently discarded.
-- Never reuse a `dedupe_key` across logically distinct notifications, even if they are related. The key means "this exact event already fired," not "these events are in the same category."
-- If you omit `dedupe_key`, the LLM decision engine may generate one automatically based on signal context. This means even keyless signals can be deduplicated if the engine considers them duplicates of a recent event.
-
-## Conversation Grouping
-
-Conversation grouping is handled by the LLM-powered decision engine, not by any parameter you pass. There is no explicit "post to conversation X" parameter - conversation reuse is inferred, not commanded.
-
-**How it works:** The engine evaluates recent notification conversation candidates and decides whether a new signal is a continuation of an existing conversation based on `source_event_name`, provenance metadata, and message content. Use natural, descriptive titles and bodies - the engine groups by semantic relatedness, not string matching.
-
-**`source_event_name` is the primary grouping signal.** Use a stable event name for notifications that belong to the same logical stream (e.g. `dog.news.thread.reply` for all replies in a thread). Use a distinct event name when the notification represents a genuinely different kind of event.
-
-**Practical constraints:**
-
-- Conversation candidates are scoped to the **last 24 hours** (max 5 per channel). You cannot reuse an old conversation from days ago.
-- The engine will only reuse conversations originally created by the notification system (`source === 'notification'`). It will never append to a user-initiated conversation, even if it looks related.
-
-## Important
-
-- Do **NOT** use AppleScript `display notification` or other OS-level notification commands for assistant-managed alerts. Always use `send_notification`.
-- For sending rich content (digests, summaries, reports) to a specific chat or email destination, use the appropriate platform's API directly. For Gmail, use `messaging_send`. For Slack, use the Slack Web API directly (see the **slack** skill). The decision engine rewrites `send_notification` content into short alerts, which strips rich formatting.

package/src/config/bundled-skills/notifications/TOOLS.json

@@ -1,80 +0,0 @@
-{
-  "version": 1,
-  "tools": [
-    {
-      "name": "send_notification",
-      "description": "Send an immediate notification. Fires instantly with no delay capability. For one-time future alerts, use schedule_create with fire_at. For recurring alerts, use schedule_create with expression (cron/RRULE). The router decides channels/copy from preferences and urgency hints. Include a confidence score (0-1).",
-      "category": "notifications",
-      "risk": "medium",
-      "input_schema": {
-        "type": "object",
-        "properties": {
-          "message": {
-            "type": "string",
-            "description": "Notification message the user should receive"
-          },
-          "title": {
-            "type": "string",
-            "description": "Optional notification title"
-          },
-          "urgency": {
-            "type": "string",
-            "enum": ["low", "medium", "high"],
-            "description": "Urgency hint (default: \"medium\")"
-          },
-          "requires_action": {
-            "type": "boolean",
-            "description": "Whether the notification expects user action (default: true)"
-          },
-          "is_async_background": {
-            "type": "boolean",
-            "description": "Whether the event is asynchronous/background work (default: false)"
-          },
-          "visible_in_source_now": {
-            "type": "boolean",
-            "description": "Set true when user is already viewing the source context (default: false)"
-          },
-          "deadline_at": {
-            "type": "number",
-            "description": "Optional deadline timestamp in epoch milliseconds"
-          },
-          "preferred_channels": {
-            "type": "array",
-            "items": {
-              "type": "string",
-              "enum": ["vellum", "telegram", "slack"]
-            },
-            "description": "Optional routing hints for preferred channels (not deterministic)"
-          },
-          "conversation_id": {
-            "type": "string",
-            "description": "Optional source conversation ID for notification context"
-          },
-          "source_event_name": {
-            "type": "string",
-            "description": "Optional event name for audit and dedupe grouping (default: \"user.send_notification\")"
-          },
-          "deep_link_metadata": {
-            "type": "object",
-            "description": "Optional metadata clients can use for deep linking"
-          },
-          "dedupe_key": {
-            "type": "string",
-            "description": "Optional dedupe key to suppress duplicate notifications"
-          },
-          "confidence": {
-            "type": "number",
-            "description": "Confidence score (0-1) for this action"
-          },
-          "activity": {
-            "type": "string",
-            "description": "Brief non-technical explanation of why this tool is being called"
-          }
-        },
-        "required": ["message", "confidence"]
-      },
-      "executor": "tools/send-notification.ts",
-      "execution_target": "host"
-    }
-  ]
-}

package/src/config/bundled-skills/notifications/tools/send-notification.ts

@@ -1,152 +0,0 @@
-import { getDeliverableChannels } from "../../../../channels/config.js";
-import { emitNotificationSignal } from "../../../../notifications/emit-signal.js";
-import type { AttentionHints } from "../../../../notifications/signal.js";
-import type { NotificationChannel } from "../../../../notifications/types.js";
-import type {
-  ToolContext,
-  ToolExecutionResult,
-} from "../../../../tools/types.js";
-import { err, ok } from "./shared.js";
-
-const INVALID = Symbol("invalid");
-
-const VALID_URGENCY = new Set<AttentionHints["urgency"]>([
-  "low",
-  "medium",
-  "high",
-]);
-const VALID_CHANNEL_HINTS = new Set<NotificationChannel>(
-  getDeliverableChannels() as NotificationChannel[],
-);
-
-function asNonEmptyString(value: unknown): string | undefined {
-  if (typeof value !== "string") return undefined;
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : undefined;
-}
-
-function parseBool(value: unknown, defaultValue: boolean): boolean {
-  return typeof value === "boolean" ? value : defaultValue;
-}
-
-function parseDeadlineAt(value: unknown): number | undefined | typeof INVALID {
-  if (value == null) return undefined;
-  if (typeof value === "number" && Number.isFinite(value))
-    return Math.trunc(value);
-  if (typeof value === "string") {
-    const parsed = Number(value);
-    if (Number.isFinite(parsed)) return Math.trunc(parsed);
-  }
-  return INVALID;
-}
-
-function parseObject(
-  value: unknown,
-): Record<string, unknown> | undefined | typeof INVALID {
-  if (value === undefined) return undefined;
-  if (!value || typeof value !== "object" || Array.isArray(value))
-    return INVALID;
-  return value as Record<string, unknown>;
-}
-
-function parsePreferredChannels(
-  value: unknown,
-): NotificationChannel[] | undefined | typeof INVALID {
-  if (value === undefined) return undefined;
-  if (!Array.isArray(value)) return INVALID;
-
-  const channels: NotificationChannel[] = [];
-  for (const item of value) {
-    if (
-      typeof item !== "string" ||
-      !VALID_CHANNEL_HINTS.has(item as NotificationChannel)
-    ) {
-      return INVALID;
-    }
-    channels.push(item as NotificationChannel);
-  }
-  return [...new Set(channels)];
-}
-
-export async function run(
-  input: Record<string, unknown>,
-  context: ToolContext,
-): Promise<ToolExecutionResult> {
-  const message = asNonEmptyString(input.message);
-  if (!message) {
-    return err("message is required.");
-  }
-
-  const urgencyInput = asNonEmptyString(input.urgency)?.toLowerCase();
-  if (
-    urgencyInput &&
-    !VALID_URGENCY.has(urgencyInput as AttentionHints["urgency"])
-  ) {
-    return err("urgency must be one of: low, medium, high.");
-  }
-  const urgency =
-    (urgencyInput as AttentionHints["urgency"] | undefined) ?? "medium";
-
-  const deadlineAt = parseDeadlineAt(input.deadline_at);
-  if (deadlineAt === INVALID) {
-    return err("deadline_at must be a valid epoch timestamp (milliseconds).");
-  }
-
-  const deepLinkMetadata = parseObject(input.deep_link_metadata);
-  if (deepLinkMetadata === INVALID) {
-    return err("deep_link_metadata must be an object.");
-  }
-
-  const preferredChannels = parsePreferredChannels(input.preferred_channels);
-  if (preferredChannels === INVALID) {
-    return err(
-      `preferred_channels must be an array containing only: ${[
-        ...VALID_CHANNEL_HINTS,
-      ].join(", ")}.`,
-    );
-  }
-
-  const sourceEventName =
-    asNonEmptyString(input.source_event_name) ?? "user.send_notification";
-  const requestedConversationId =
-    asNonEmptyString(input.conversation_id) ?? context.conversationId;
-  const sourceContextId = requestedConversationId ?? context.conversationId;
-  const title = asNonEmptyString(input.title);
-  const dedupeKey = asNonEmptyString(input.dedupe_key);
-
-  const contextPayload: Record<string, unknown> = {
-    requestedMessage: message,
-    requestedByTool: "send_notification",
-    requestedByContextId: context.conversationId,
-  };
-  if (title) contextPayload.requestedTitle = title;
-  if (requestedConversationId)
-    contextPayload.requestedByConversationId = requestedConversationId;
-  if (preferredChannels && preferredChannels.length > 0)
-    contextPayload.preferredChannels = preferredChannels;
-  if (deepLinkMetadata) contextPayload.deepLinkMetadata = deepLinkMetadata;
-
-  try {
-    await emitNotificationSignal({
-      sourceEventName,
-      sourceChannel: "assistant_tool",
-      sourceContextId,
-      attentionHints: {
-        requiresAction: parseBool(input.requires_action, true),
-        urgency,
-        deadlineAt,
-        isAsyncBackground: parseBool(input.is_async_background, false),
-        visibleInSourceNow: parseBool(input.visible_in_source_now, false),
-      },
-      contextPayload,
-      dedupeKey,
-      throwOnError: true,
-    });
-
-    return ok(
-      "Notification request queued. Channel selection and delivery are handled by the notification router.",
-    );
-  } catch (e) {
-    return err(e instanceof Error ? e.message : String(e));
-  }
-}

package/src/config/bundled-skills/notifications/tools/shared.ts

@@ -1,13 +0,0 @@
-/**
- * Shared utilities for notifications skill tools.
- */
-
-import type { ToolExecutionResult } from "../../../../tools/types.js";
-
-export function ok(content: string): ToolExecutionResult {
-  return { content, isError: false };
-}
-
-export function err(message: string): ToolExecutionResult {
-  return { content: message, isError: true };
-}