@vellumai/assistant 0.4.26 → 0.4.29

package/src/config/bundled-skills/messaging/tools/sequence-get.ts

@@ -1,10 +1,20 @@
-import { countActiveEnrollments,getSequence, listEnrollments } from '../../../../sequence/store.js';
-import type { ToolContext, ToolExecutionResult } from '../../../../tools/types.js';
-import { err,ok } from './shared.js';
+import {
+  countActiveEnrollments,
+  getSequence,
+  listEnrollments,
+} from "../../../../sequence/store.js";
+import type {
+  ToolContext,
+  ToolExecutionResult,
+} from "../../../../tools/types.js";
+import { err, ok } from "./shared.js";
 
-export async function run(input: Record<string, unknown>, _context: ToolContext): Promise<ToolExecutionResult> {
+export async function run(
+  input: Record<string, unknown>,
+  _context: ToolContext,
+): Promise<ToolExecutionResult> {
   const id = input.id as string;
-  if (!id) return err('id is required.');
+  if (!id) return err("id is required.");
 
   try {
     const seq = getSequence(id);
@@ -12,10 +22,13 @@ export async function run(input: Record<string, unknown>, _context: ToolContext)
 
     const activeCount = countActiveEnrollments(id);
     const allEnrollments = listEnrollments({ sequenceId: id });
-    const statusCounts = allEnrollments.reduce((acc, e) => {
-      acc[e.status] = (acc[e.status] || 0) + 1;
-      return acc;
-    }, {} as Record<string, number>);
+    const statusCounts = allEnrollments.reduce(
+      (acc, e) => {
+        acc[e.status] = (acc[e.status] || 0) + 1;
+        return acc;
+      },
+      {} as Record<string, number>,
+    );
 
     const lines = [
       `Name: ${seq.name}`,
@@ -24,15 +37,20 @@ export async function run(input: Record<string, unknown>, _context: ToolContext)
       `Channel: ${seq.channel}`,
       `Exit on reply: ${seq.exitOnReply}`,
       seq.description ? `Description: ${seq.description}` : null,
-      '',
+      "",
       `Steps (${seq.steps.length}):`,
-      ...seq.steps.map((s) => `  ${s.index + 1}. "${s.subjectTemplate}" — delay: ${s.delaySeconds}s${s.requireApproval ? ' [approval required]' : ''}`),
-      '',
+      ...seq.steps.map(
+        (s) =>
+          `  ${s.index + 1}. "${s.subjectTemplate}" — delay: ${
+            s.delaySeconds
+          }s${s.requireApproval ? " [approval required]" : ""}`,
+      ),
+      "",
       `Enrollments: ${allEnrollments.length} total, ${activeCount} active`,
       ...Object.entries(statusCounts).map(([k, v]) => `  ${k}: ${v}`),
     ].filter((line): line is string => line != null);
 
-    return ok(lines.join('\n'));
+    return ok(lines.join("\n"));
   } catch (e) {
     return err(e instanceof Error ? e.message : String(e));
   }

package/src/config/bundled-skills/messaging/tools/sequence-import.ts

@@ -1,15 +1,21 @@
-import { bulkEnroll,parseContactFile } from '../../../../sequence/importer.js';
-import { getSequence } from '../../../../sequence/store.js';
-import type { ToolContext, ToolExecutionResult } from '../../../../tools/types.js';
-import { err,ok } from './shared.js';
+import { bulkEnroll, parseContactFile } from "../../../../sequence/importer.js";
+import { getSequence } from "../../../../sequence/store.js";
+import type {
+  ToolContext,
+  ToolExecutionResult,
+} from "../../../../tools/types.js";
+import { err, ok } from "./shared.js";
 
-export async function run(input: Record<string, unknown>, _context: ToolContext): Promise<ToolExecutionResult> {
+export async function run(
+  input: Record<string, unknown>,
+  _context: ToolContext,
+): Promise<ToolExecutionResult> {
   const filePath = input.file_path as string;
   const sequenceId = input.sequence_id as string;
   const autoEnroll = input.auto_enroll as boolean | undefined;
 
-  if (!filePath) return err('file_path is required.');
-  if (!sequenceId) return err('sequence_id is required.');
+  if (!filePath) return err("file_path is required.");
+  if (!sequenceId) return err("sequence_id is required.");
 
   try {
     const seq = getSequence(sequenceId);
@@ -18,7 +24,11 @@ export async function run(input: Record<string, unknown>, _context: ToolContext)
     const parsed = parseContactFile(filePath);
 
     if (parsed.contacts.length === 0 && parsed.errors.length > 0) {
-      return err(`No valid contacts found.\n\nErrors:\n${parsed.errors.map((e) => `  Row ${e.row}: ${e.reason}`).join('\n')}`);
+      return err(
+        `No valid contacts found.\n\nErrors:\n${parsed.errors
+          .map((e) => `  Row ${e.row}: ${e.reason}`)
+          .join("\n")}`,
+      );
     }
 
     // Preview mode (default) — show what would happen
@@ -31,17 +41,21 @@ export async function run(input: Record<string, unknown>, _context: ToolContext)
         for (const e of parsed.errors.slice(0, 10)) {
           lines.push(`  Row ${e.row}: ${e.reason}`);
         }
-        if (parsed.errors.length > 10) lines.push(`  ... and ${parsed.errors.length - 10} more`);
+        if (parsed.errors.length > 10)
+          lines.push(`  ... and ${parsed.errors.length - 10} more`);
       }
-      lines.push('');
+      lines.push("");
       lines.push(`Sample contacts:`);
       for (const c of parsed.contacts.slice(0, 5)) {
-        lines.push(`  ${c.email}${c.name ? ` (${c.name})` : ''}`);
+        lines.push(`  ${c.email}${c.name ? ` (${c.name})` : ""}`);
       }
-      if (parsed.contacts.length > 5) lines.push(`  ... and ${parsed.contacts.length - 5} more`);
-      lines.push('');
-      lines.push(`Call again with auto_enroll=true to enroll all ${parsed.contacts.length} contacts in "${seq.name}".`);
-      return ok(lines.join('\n'));
+      if (parsed.contacts.length > 5)
+        lines.push(`  ... and ${parsed.contacts.length - 5} more`);
+      lines.push("");
+      lines.push(
+        `Call again with auto_enroll=true to enroll all ${parsed.contacts.length} contacts in "${seq.name}".`,
+      );
+      return ok(lines.join("\n"));
     }
 
     // Enroll mode
@@ -55,27 +69,29 @@ export async function run(input: Record<string, unknown>, _context: ToolContext)
     ];
 
     if (result.skipped.length > 0) {
-      lines.push('');
-      lines.push('Skipped:');
+      lines.push("");
+      lines.push("Skipped:");
       for (const s of result.skipped.slice(0, 10)) {
         lines.push(`  ${s.email} — ${s.reason}`);
       }
     }
 
     if (result.failed.length > 0) {
-      lines.push('');
-      lines.push('Failed:');
+      lines.push("");
+      lines.push("Failed:");
       for (const f of result.failed.slice(0, 10)) {
         lines.push(`  ${f.email} — ${f.reason}`);
       }
     }
 
     if (parsed.errors.length > 0) {
-      lines.push('');
-      lines.push(`${parsed.errors.length} row(s) in file had errors (not enrolled).`);
+      lines.push("");
+      lines.push(
+        `${parsed.errors.length} row(s) in file had errors (not enrolled).`,
+      );
     }
 
-    return ok(lines.join('\n'));
+    return ok(lines.join("\n"));
   } catch (e) {
     return err(e instanceof Error ? e.message : String(e));
   }

package/src/config/bundled-skills/messaging/tools/sequence-list.ts

@@ -1,20 +1,29 @@
-import { countActiveEnrollments,listSequences } from '../../../../sequence/store.js';
-import type { SequenceStatus } from '../../../../sequence/types.js';
-import type { ToolContext, ToolExecutionResult } from '../../../../tools/types.js';
-import { err,ok } from './shared.js';
+import {
+  countActiveEnrollments,
+  listSequences,
+} from "../../../../sequence/store.js";
+import type { SequenceStatus } from "../../../../sequence/types.js";
+import type {
+  ToolContext,
+  ToolExecutionResult,
+} from "../../../../tools/types.js";
+import { err, ok } from "./shared.js";
 
-export async function run(input: Record<string, unknown>, _context: ToolContext): Promise<ToolExecutionResult> {
+export async function run(
+  input: Record<string, unknown>,
+  _context: ToolContext,
+): Promise<ToolExecutionResult> {
   const status = input.status as SequenceStatus | undefined;
 
   try {
     const seqs = listSequences(status ? { status } : undefined);
-    if (seqs.length === 0) return ok('No sequences found.');
+    if (seqs.length === 0) return ok("No sequences found.");
 
     const lines = seqs.map((s) => {
       const enrollments = countActiveEnrollments(s.id);
       return `- ${s.name} (ID: ${s.id}) — ${s.status}, ${s.steps.length} steps, ${enrollments} active enrollments, channel: ${s.channel}`;
     });
-    return ok(`${seqs.length} sequence(s):\n${lines.join('\n')}`);
+    return ok(`${seqs.length} sequence(s):\n${lines.join("\n")}`);
   } catch (e) {
     return err(e instanceof Error ? e.message : String(e));
   }

package/src/config/bundled-skills/messaging/tools/sequence-pause.ts

@@ -1,28 +1,47 @@
-import { getEnrollment, getSequence, pauseEnrollment,updateSequence } from '../../../../sequence/store.js';
-import type { ToolContext, ToolExecutionResult } from '../../../../tools/types.js';
-import { err,ok } from './shared.js';
+import {
+  getEnrollment,
+  getSequence,
+  pauseEnrollment,
+  updateSequence,
+} from "../../../../sequence/store.js";
+import type {
+  ToolContext,
+  ToolExecutionResult,
+} from "../../../../tools/types.js";
+import { err, ok } from "./shared.js";
 
-export async function run(input: Record<string, unknown>, _context: ToolContext): Promise<ToolExecutionResult> {
+export async function run(
+  input: Record<string, unknown>,
+  _context: ToolContext,
+): Promise<ToolExecutionResult> {
   const sequenceId = input.sequence_id as string | undefined;
   const enrollmentId = input.enrollment_id as string | undefined;
 
-  if (!sequenceId && !enrollmentId) return err('Either sequence_id or enrollment_id is required.');
+  if (!sequenceId && !enrollmentId)
+    return err("Either sequence_id or enrollment_id is required.");
 
   try {
     if (enrollmentId) {
       const enrollment = getEnrollment(enrollmentId);
       if (!enrollment) return err(`Enrollment not found: ${enrollmentId}`);
-      if (enrollment.status !== 'active') return err(`Enrollment is not active (status: ${enrollment.status}).`);
+      if (enrollment.status !== "active")
+        return err(`Enrollment is not active (status: ${enrollment.status}).`);
       pauseEnrollment(enrollmentId);
-      return ok(`Enrollment ${enrollmentId} paused. Resume it later to continue from step ${enrollment.currentStep + 1}.`);
+      return ok(
+        `Enrollment ${enrollmentId} paused. Resume it later to continue from step ${
+          enrollment.currentStep + 1
+        }.`,
+      );
     }
 
     const seq = getSequence(sequenceId!);
     if (!seq) return err(`Sequence not found: ${sequenceId}`);
-    if (seq.status === 'paused') return ok('Sequence is already paused.');
+    if (seq.status === "paused") return ok("Sequence is already paused.");
 
-    updateSequence(sequenceId!, { status: 'paused' });
-    return ok(`Sequence "${seq.name}" paused. Active enrollments will not be processed until resumed.`);
+    updateSequence(sequenceId!, { status: "paused" });
+    return ok(
+      `Sequence "${seq.name}" paused. Active enrollments will not be processed until resumed.`,
+    );
   } catch (e) {
     return err(e instanceof Error ? e.message : String(e));
   }

package/src/config/bundled-skills/messaging/tools/sequence-resume.ts

@@ -1,18 +1,26 @@
-import { getSequence,updateSequence } from '../../../../sequence/store.js';
-import type { ToolContext, ToolExecutionResult } from '../../../../tools/types.js';
-import { err,ok } from './shared.js';
+import { getSequence, updateSequence } from "../../../../sequence/store.js";
+import type {
+  ToolContext,
+  ToolExecutionResult,
+} from "../../../../tools/types.js";
+import { err, ok } from "./shared.js";
 
-export async function run(input: Record<string, unknown>, _context: ToolContext): Promise<ToolExecutionResult> {
+export async function run(
+  input: Record<string, unknown>,
+  _context: ToolContext,
+): Promise<ToolExecutionResult> {
   const sequenceId = input.sequence_id as string;
-  if (!sequenceId) return err('sequence_id is required.');
+  if (!sequenceId) return err("sequence_id is required.");
 
   try {
     const seq = getSequence(sequenceId);
     if (!seq) return err(`Sequence not found: ${sequenceId}`);
-    if (seq.status === 'active') return ok('Sequence is already active.');
+    if (seq.status === "active") return ok("Sequence is already active.");
 
-    updateSequence(sequenceId, { status: 'active' });
-    return ok(`Sequence "${seq.name}" resumed. Active enrollments will be processed on the next scheduler tick.`);
+    updateSequence(sequenceId, { status: "active" });
+    return ok(
+      `Sequence "${seq.name}" resumed. Active enrollments will be processed on the next scheduler tick.`,
+    );
   } catch (e) {
     return err(e instanceof Error ? e.message : String(e));
   }

package/src/config/bundled-skills/messaging/tools/sequence-update.ts

@@ -1,11 +1,20 @@
-import { updateSequence } from '../../../../sequence/store.js';
-import type { SequenceStatus,SequenceStep } from '../../../../sequence/types.js';
-import type { ToolContext, ToolExecutionResult } from '../../../../tools/types.js';
-import { err,ok } from './shared.js';
+import { updateSequence } from "../../../../sequence/store.js";
+import type {
+  SequenceStatus,
+  SequenceStep,
+} from "../../../../sequence/types.js";
+import type {
+  ToolContext,
+  ToolExecutionResult,
+} from "../../../../tools/types.js";
+import { err, ok } from "./shared.js";
 
-export async function run(input: Record<string, unknown>, _context: ToolContext): Promise<ToolExecutionResult> {
+export async function run(
+  input: Record<string, unknown>,
+  _context: ToolContext,
+): Promise<ToolExecutionResult> {
   const id = input.id as string;
-  if (!id) return err('id is required.');
+  if (!id) return err("id is required.");
 
   const name = input.name as string | undefined;
   const description = input.description as string | undefined;
@@ -14,20 +23,30 @@ export async function run(input: Record<string, unknown>, _context: ToolContext)
   const stepsRaw = input.steps as Array<Record<string, unknown>> | undefined;
 
   try {
-    const steps = stepsRaw?.map((s, i): SequenceStep => ({
-      index: i,
-      delaySeconds: (s.delay_seconds as number) ?? 0,
-      subjectTemplate: (s.subject as string) ?? `Step ${i + 1}`,
-      bodyPrompt: (s.body_prompt as string) ?? '',
-      replyToThread: (s.reply_to_thread as boolean) ?? (i > 0),
-      requireApproval: (s.require_approval as boolean) ?? false,
-    }));
+    const steps = stepsRaw?.map(
+      (s, i): SequenceStep => ({
+        index: i,
+        delaySeconds: (s.delay_seconds as number) ?? 0,
+        subjectTemplate: (s.subject as string) ?? `Step ${i + 1}`,
+        bodyPrompt: (s.body_prompt as string) ?? "",
+        replyToThread: (s.reply_to_thread as boolean) ?? i > 0,
+        requireApproval: (s.require_approval as boolean) ?? false,
+      }),
+    );
 
     if (steps !== undefined && steps.length === 0) {
-      return err('steps must not be empty. A sequence requires at least one step.');
+      return err(
+        "steps must not be empty. A sequence requires at least one step.",
+      );
     }
 
-    const updated = updateSequence(id, { name, description, status, exitOnReply, steps });
+    const updated = updateSequence(id, {
+      name,
+      description,
+      status,
+      exitOnReply,
+      steps,
+    });
     if (!updated) return err(`Sequence not found: ${id}`);
 
     return ok(`Sequence updated: ${updated.name} (${updated.status})`);

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

@@ -2,12 +2,18 @@
  * Shared utilities for messaging skill tools.
  */
 
-import { request as httpsRequest, type RequestOptions as HttpsRequestOptions } from 'node:https';
+import {
+  request as httpsRequest,
+  type RequestOptions as HttpsRequestOptions,
+} from "node:https";
 
-import type { MessagingProvider } from '../../../../messaging/provider.js';
-import { getConnectedProviders,getMessagingProvider } from '../../../../messaging/registry.js';
-import { withValidToken } from '../../../../security/token-manager.js';
-import type { ToolExecutionResult } from '../../../../tools/types.js';
+import type { MessagingProvider } from "../../../../messaging/provider.js";
+import {
+  getConnectedProviders,
+  getMessagingProvider,
+} from "../../../../messaging/registry.js";
+import { withValidToken } from "../../../../security/token-manager.js";
+import type { ToolExecutionResult } from "../../../../tools/types.js";
 
 export function ok(content: string): ToolExecutionResult {
   return { content, isError: false };
@@ -29,11 +35,15 @@ export function resolveProvider(platformInput?: string): MessagingProvider {
   const connected = getConnectedProviders();
   if (connected.length === 1) return connected[0];
   if (connected.length === 0) {
-    throw new Error('No messaging platforms are connected. Use messaging_auth_test to check connection status, then set up a platform.');
+    throw new Error(
+      "No messaging platforms are connected. Use messaging_auth_test to check connection status, then set up a platform.",
+    );
   }
 
-  const names = connected.map((p) => `"${p.id}"`).join(', ');
-  throw new Error(`Multiple platforms connected (${names}). Specify platform parameter.`);
+  const names = connected.map((p) => `"${p.id}"`).join(", ");
+  throw new Error(
+    `Multiple platforms connected (${names}). Specify platform parameter.`,
+  );
 }
 
 /**
@@ -46,7 +56,7 @@ export async function withProviderToken<T>(
   fn: (token: string) => Promise<T>,
 ): Promise<T> {
   if (provider.isConnected?.()) {
-    return fn('');
+    return fn("");
   }
   return withValidToken(provider.credentialService, fn);
 }
@@ -55,11 +65,15 @@ export async function withProviderToken<T>(
 export function pinnedHttpsRequest(
   target: URL,
   resolvedAddress: string,
-  options?: { method?: string; headers?: Record<string, string>; body?: string },
+  options?: {
+    method?: string;
+    headers?: Record<string, string>;
+    body?: string;
+  },
 ): Promise<number> {
   return new Promise((resolve, reject) => {
     const reqOpts: HttpsRequestOptions = {
-      method: options?.method ?? 'GET',
+      method: options?.method ?? "GET",
       hostname: resolvedAddress,
       port: target.port ? Number(target.port) : undefined,
       path: `${target.pathname}${target.search}`,
@@ -70,7 +84,7 @@ export function pinnedHttpsRequest(
       res.resume();
       resolve(res.statusCode ?? 0);
     });
-    req.once('error', reject);
+    req.once("error", reject);
     if (options?.body) req.write(options.body);
     req.end();
   });

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

@@ -1,48 +1,66 @@
-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[]);
+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;
+  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;
+  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') {
+  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 {
+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;
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return INVALID;
   return value as Record<string, unknown>;
 }
 
-function parsePreferredChannels(value: unknown): NotificationChannel[] | undefined | typeof INVALID {
+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)) {
+    if (
+      typeof item !== "string" ||
+      !VALID_CHANNEL_HINTS.has(item as NotificationChannel)
+    ) {
       return INVALID;
     }
     channels.push(item as NotificationChannel);
@@ -50,53 +68,68 @@ function parsePreferredChannels(value: unknown): NotificationChannel[] | undefin
   return [...new Set(channels)];
 }
 
-export async function run(input: Record<string, unknown>, context: ToolContext): Promise<ToolExecutionResult> {
+export async function run(
+  input: Record<string, unknown>,
+  context: ToolContext,
+): Promise<ToolExecutionResult> {
   const message = asNonEmptyString(input.message);
   if (!message) {
-    return err('message is required.');
+    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.');
+  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 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).');
+    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.');
+    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(', ')}.`);
+    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 sourceEventName =
+    asNonEmptyString(input.source_event_name) ?? "user.send_notification";
+  const requestedConversationId =
+    asNonEmptyString(input.conversation_id) ?? context.conversationId;
   const sourceSessionId = requestedConversationId ?? context.sessionId;
   const title = asNonEmptyString(input.title);
   const dedupeKey = asNonEmptyString(input.dedupe_key);
 
   const contextPayload: Record<string, unknown> = {
     requestedMessage: message,
-    requestedByTool: 'send_notification',
+    requestedByTool: "send_notification",
     requestedBySessionId: context.sessionId,
   };
   if (title) contextPayload.requestedTitle = title;
-  if (requestedConversationId) contextPayload.requestedByConversationId = requestedConversationId;
-  if (preferredChannels && preferredChannels.length > 0) contextPayload.preferredChannels = preferredChannels;
+  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',
+      sourceChannel: "assistant_tool",
       sourceSessionId,
       assistantId: context.assistantId,
       attentionHints: {
@@ -111,7 +144,9 @@ export async function run(input: Record<string, unknown>, context: ToolContext):
       throwOnError: true,
     });
 
-    return ok('Notification request queued. Channel selection and delivery are handled by the notification router.');
+    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

@@ -2,7 +2,7 @@
  * Shared utilities for notifications skill tools.
  */
 
-import type { ToolExecutionResult } from '../../../../tools/types.js';
+import type { ToolExecutionResult } from "../../../../tools/types.js";
 
 export function ok(content: string): ToolExecutionResult {
   return { content, isError: false };