@vellumai/assistant 0.4.26 → 0.4.29

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

@@ -1,8 +1,14 @@
-import type { ToolContext, ToolExecutionResult } from '../../../../tools/types.js';
-import * as calendar from '../calendar-client.js';
-import { ok,withCalendarToken } from './shared.js';
+import type {
+  ToolContext,
+  ToolExecutionResult,
+} from "../../../../tools/types.js";
+import * as calendar from "../calendar-client.js";
+import { ok, withCalendarToken } 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 summary = input.summary as string;
   const startRaw = input.start as string;
   const endRaw = input.end as string;
@@ -10,10 +16,10 @@ export async function run(input: Record<string, unknown>, _context: ToolContext)
   const location = input.location as string | undefined;
   const attendees = input.attendees as string[] | undefined;
   const timezone = input.timezone as string | undefined;
-  const calendarId = (input.calendar_id as string) ?? 'primary';
+  const calendarId = (input.calendar_id as string) ?? "primary";
 
   // Determine if these are all-day events (date-only) or timed events
-  const isAllDay = !startRaw.includes('T');
+  const isAllDay = !startRaw.includes("T");
 
   const start = isAllDay
     ? { date: startRaw }
@@ -36,7 +42,7 @@ export async function run(input: Record<string, unknown>, _context: ToolContext)
 
   return withCalendarToken(async (token) => {
     const event = await calendar.createEvent(token, eventBody, calendarId);
-    const link = event.htmlLink ? ` View it here: ${event.htmlLink}` : '';
+    const link = event.htmlLink ? ` View it here: ${event.htmlLink}` : "";
     return ok(`Event created (ID: ${event.id}).${link}`);
   });
 }

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

@@ -1,10 +1,16 @@
-import type { ToolContext, ToolExecutionResult } from '../../../../tools/types.js';
-import * as calendar from '../calendar-client.js';
-import { ok,withCalendarToken } from './shared.js';
+import type {
+  ToolContext,
+  ToolExecutionResult,
+} from "../../../../tools/types.js";
+import * as calendar from "../calendar-client.js";
+import { ok, withCalendarToken } 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 eventId = input.event_id as string;
-  const calendarId = (input.calendar_id as string) ?? 'primary';
+  const calendarId = (input.calendar_id as string) ?? "primary";
 
   return withCalendarToken(async (token) => {
     const event = await calendar.getEvent(token, eventId, calendarId);

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

@@ -1,15 +1,21 @@
-import type { ToolContext, ToolExecutionResult } from '../../../../tools/types.js';
-import * as calendar from '../calendar-client.js';
-import { ok,withCalendarToken } from './shared.js';
+import type {
+  ToolContext,
+  ToolExecutionResult,
+} from "../../../../tools/types.js";
+import * as calendar from "../calendar-client.js";
+import { ok, withCalendarToken } from "./shared.js";
 
-export async function run(input: Record<string, unknown>, _context: ToolContext): Promise<ToolExecutionResult> {
-  const calendarId = (input.calendar_id as string) ?? 'primary';
+export async function run(
+  input: Record<string, unknown>,
+  _context: ToolContext,
+): Promise<ToolExecutionResult> {
+  const calendarId = (input.calendar_id as string) ?? "primary";
   const timeMin = (input.time_min as string) ?? new Date().toISOString();
   const timeMax = input.time_max as string | undefined;
   const maxResults = Math.min((input.max_results as number) ?? 25, 250);
   const query = input.query as string | undefined;
   const singleEvents = (input.single_events as boolean) ?? true;
-  const orderBy = input.order_by as 'startTime' | 'updated' | undefined;
+  const orderBy = input.order_by as "startTime" | "updated" | undefined;
 
   return withCalendarToken(async (token) => {
     const result = await calendar.listEvents(token, calendarId, {
@@ -22,7 +28,7 @@ export async function run(input: Record<string, unknown>, _context: ToolContext)
     });
 
     if (!result.items?.length) {
-      return ok('No events found in the specified time range.');
+      return ok("No events found in the specified time range.");
     }
 
     return ok(JSON.stringify(result, null, 2));

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

@@ -1,11 +1,17 @@
-import type { ToolContext, ToolExecutionResult } from '../../../../tools/types.js';
-import * as calendar from '../calendar-client.js';
-import { ok,withCalendarToken } from './shared.js';
+import type {
+  ToolContext,
+  ToolExecutionResult,
+} from "../../../../tools/types.js";
+import * as calendar from "../calendar-client.js";
+import { ok, withCalendarToken } 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 eventId = input.event_id as string;
-  const response = input.response as 'accepted' | 'declined' | 'tentative';
-  const calendarId = (input.calendar_id as string) ?? 'primary';
+  const response = input.response as "accepted" | "declined" | "tentative";
+  const calendarId = (input.calendar_id as string) ?? "primary";
 
   return withCalendarToken(async (token) => {
     // First get the event to find the user's attendee entry
@@ -16,9 +22,11 @@ export async function run(input: Record<string, unknown>, _context: ToolContext)
       // 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("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.');
+      return ok(
+        "Could not find your attendee entry for this event. You may not be invited.",
+      );
     }
 
     // Update the attendee's response status
@@ -29,13 +37,21 @@ export async function run(input: Record<string, unknown>, _context: ToolContext)
     await calendar.patchEvent(
       token,
       eventId,
-      { attendees: updatedAttendees as Array<{ email: string; responseStatus?: string }> },
+      {
+        attendees: updatedAttendees as Array<{
+          email: string;
+          responseStatus?: string;
+        }>,
+      },
       calendarId,
     );
 
-    const responseLabel = response === 'accepted' ? 'Accepted'
-      : response === 'declined' ? 'Declined'
-      : 'Tentatively accepted';
+    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,5 +1,5 @@
-import { withValidToken } from '../../../../security/token-manager.js';
-import type { ToolExecutionResult } from '../../../../tools/types.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 };
@@ -13,6 +13,8 @@ export function err(message: string): ToolExecutionResult {
  * Calendar uses the same OAuth credential service as Gmail since both
  * scopes are granted in a single OAuth consent flow.
  */
-export async function withCalendarToken<T>(fn: (token: string) => Promise<T>): Promise<T> {
-  return withValidToken('integration:gmail', fn);
+export async function withCalendarToken<T>(
+  fn: (token: string) => Promise<T>,
+): Promise<T> {
+  return withValidToken("integration:gmail", fn);
 }

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

@@ -9,7 +9,7 @@ export interface EventDateTime {
 export interface EventAttendee {
   email: string;
   displayName?: string;
-  responseStatus?: 'needsAction' | 'declined' | 'tentative' | 'accepted';
+  responseStatus?: "needsAction" | "declined" | "tentative" | "accepted";
   self?: boolean;
   organizer?: boolean;
   optional?: boolean;
@@ -25,7 +25,7 @@ export interface EventOrganizer {
 /** A single Google Calendar event. */
 export interface CalendarEvent {
   id: string;
-  status?: 'confirmed' | 'tentative' | 'cancelled';
+  status?: "confirmed" | "tentative" | "cancelled";
   summary?: string;
   description?: string;
   location?: string;
@@ -87,7 +87,7 @@ export interface CalendarListEntry {
   description?: string;
   timeZone?: string;
   primary?: boolean;
-  accessRole?: 'freeBusyReader' | 'reader' | 'writer' | 'owner';
+  accessRole?: "freeBusyReader" | "reader" | "writer" | "owner";
 }
 
 /** Calendar list response. */

package/src/config/bundled-skills/guardian-verify-setup/SKILL.md

@@ -2,17 +2,17 @@
 name: "Guardian Verify Setup"
 description: "Set up guardian verification for voice or Telegram channels via outbound verification flow"
 user-invocable: true
-metadata: {"vellum": {"emoji": "\ud83d\udd10"}}
+metadata: { "vellum": { "emoji": "\ud83d\udd10" } }
 ---
 
-You are helping your user set up guardian verification for a messaging channel (voice or Telegram). This links their identity as the trusted guardian for the chosen channel. All API calls go through the gateway HTTP API using `curl` with bearer auth.
+You are helping your user set up guardian verification for a messaging channel (voice or Telegram). This links their identity as the trusted guardian for the chosen channel. Use gateway control-plane APIs for outbound actions, and use `vellum integrations guardian status` for status reads.
 
 ## Prerequisites
 
 - Use the injected `INTERNAL_GATEWAY_BASE_URL` for gateway API calls.
-- Never call the daemon runtime port directly; always call the gateway URL.
-- The bearer token is available as the `$GATEWAY_AUTH_TOKEN` environment variable.
-- Run shell commands for this skill with `host_bash` (not sandbox `bash`) so host auth/token and gateway routing are reliable.
+- Never call the assistant runtime port directly; always call the gateway URL.
+- The bearer token is available as the `$GATEWAY_AUTH_TOKEN` environment variable for control-plane `curl` requests.
+- Run shell commands for this skill with `bash`.
 - Keep narration minimal: execute required calls first, then provide a concise status update. Do not narrate internal install/check/load chatter unless something fails.
 
 ## Step 1: Confirm Channel
@@ -60,14 +60,14 @@ After reporting the bootstrap URL for Telegram handle flows, wait for the user t
 
 Handle each error code:
 
-| Error code | Action |
-|---|---|
-| `missing_destination` | Ask the user to provide their phone number or Telegram destination. |
-| `invalid_destination` | Tell the user the format is invalid. For phone: suggest E.164 format (+15551234567). For Telegram: explain that group chat IDs (negative numbers) are not supported. |
-| `already_bound` | Tell the user a guardian is already bound for this channel. Ask if they want to replace it. If yes, re-run the start request with `"rebind": true` added to the JSON body. |
-| `rate_limited` | Tell the user they have sent too many verification attempts to this destination. Ask them to wait and try again later. |
-| `unsupported_channel` | Tell the user the channel is not supported. Only voice and telegram are valid. |
-| `no_bot_username` | Telegram bot is not configured. Load and run the `telegram-setup` skill first. |
+| Error code            | Action                                                                                                                                                                     |
+| --------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `missing_destination` | Ask the user to provide their phone number or Telegram destination.                                                                                                        |
+| `invalid_destination` | Tell the user the format is invalid. For phone: suggest E.164 format (+15551234567). For Telegram: explain that group chat IDs (negative numbers) are not supported.       |
+| `already_bound`       | Tell the user a guardian is already bound for this channel. Ask if they want to replace it. If yes, re-run the start request with `"rebind": true` added to the JSON body. |
+| `rate_limited`        | Tell the user they have sent too many verification attempts to this destination. Ask them to wait and try again later.                                                     |
+| `unsupported_channel` | Tell the user the channel is not supported. Only voice and telegram are valid.                                                                                             |
+| `no_bot_username`     | Telegram bot is not configured. Load and run the `telegram-setup` skill first.                                                                                             |
 
 ## Step 4: Handle Resend
 
@@ -89,13 +89,13 @@ On success, report the next action based on the channel:
 
 Handle each error code from the resend endpoint:
 
-| Error code | Action |
-|---|---|
-| `rate_limited` | Tell the user to wait before trying again (the cooldown is 15 seconds between resends). |
+| Error code           | Action                                                                                                                                                                                            |
+| -------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `rate_limited`       | Tell the user to wait before trying again (the cooldown is 15 seconds between resends).                                                                                                           |
 | `max_sends_exceeded` | Tell the user they have reached the maximum number of resends for this session (5 sends per session). Suggest canceling the current session (Step 5) and starting a new verification from Step 3. |
-| `no_destination` | This should not normally occur during resend. Tell the user to cancel (Step 5) and restart verification from scratch at Step 3. |
-| `pending_bootstrap` | Remind the user to click the Telegram deep-link first before a code can be sent. |
-| `no_active_session` | No session is active. Start a new one from Step 3. |
+| `no_destination`     | This should not normally occur during resend. Tell the user to cancel (Step 5) and restart verification from scratch at Step 3.                                                                   |
+| `pending_bootstrap`  | Remind the user to click the Telegram deep-link first before a code can be sent.                                                                                                                  |
+| `no_active_session`  | No session is active. Start a new one from Step 3.                                                                                                                                                |
 
 ## Step 5: Handle Cancel
 
@@ -117,11 +117,10 @@ For **voice** verification only: after telling the user their code and instructi
 **Polling procedure:**
 
 1. Wait ~15 seconds after delivering the code (to give the user time to answer the call and enter the code).
-2. Check the binding status:
+2. Check the binding status via Vellum CLI:
 
 ```bash
-curl -s "$INTERNAL_GATEWAY_BASE_URL/v1/integrations/guardian/status?channel=voice" \
-  -H "Authorization: Bearer $GATEWAY_AUTH_TOKEN"
+vellum integrations guardian status --channel voice --json
 ```
 
 3. If the response shows `bound: true`: immediately send a proactive success message in the current chat — "Voice verification complete! Your phone number is now the trusted guardian." Stop polling.
@@ -131,12 +130,14 @@ curl -s "$INTERNAL_GATEWAY_BASE_URL/v1/integrations/guardian/status?channel=voic
 
 **Rebind guard:**
 When in a **rebind flow** (i.e., the `start_outbound` request included `"rebind": true` because a binding already existed), do NOT treat the first `bound: true` poll result as success. The pre-existing binding will already show `bound: true` before the user has entered the new code, which would be a false positive. To guard against this:
+
 - Note the `bound_at` timestamp from the **first** poll response as a baseline.
 - Only report success when a subsequent poll shows `bound: true` with a `bound_at` timestamp **strictly newer** than the baseline. This proves the new outbound session was consumed.
 - If the status endpoint does not include `bound_at`, fall back to skipping the first poll result entirely and only start evaluating `bound: true` from the **second poll onward** (giving the user time to enter the new code).
 - Non-rebind flows (fresh verification with no prior binding) are unaffected — the first `bound: true` is trustworthy.
 
 **Important polling rules:**
+
 - This polling loop is voice-only. Do NOT poll for Telegram channels (Telegram has its own bot-driven flow).
 - Do NOT require the user to ask "did it work?" — the whole point is proactive confirmation.
 - If the user sends a message while polling is in progress, handle their message normally. If their message is about verification status, the next poll iteration will provide the answer.
@@ -146,14 +147,34 @@ When in a **rebind flow** (i.e., the `start_outbound` request included `"rebind"
 After the user reports entering the code, verify the binding was created:
 
 ```bash
-curl -s "$INTERNAL_GATEWAY_BASE_URL/v1/integrations/guardian/status?channel=<channel>" \
-  -H "Authorization: Bearer $GATEWAY_AUTH_TOKEN"
+CHANNEL="<channel>"
+vellum integrations guardian status --channel "$CHANNEL" --json
 ```
 
 If the response shows the guardian is bound, confirm success: "Guardian verified! Your [channel] identity is now the trusted guardian."
 
 If not yet bound, offer to resend (Step 4) or generate a new session (Step 3).
 
+## Step 7: Revoke Guardian Binding
+
+If the user wants to remove themselves (or the current guardian) from a channel, use the revoke endpoint:
+
+```bash
+curl -s -X POST "$INTERNAL_GATEWAY_BASE_URL/v1/integrations/guardian/revoke" \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer $GATEWAY_AUTH_TOKEN" \
+  -d '{"channel": "<channel>"}'
+```
+
+Replace `<channel>` with the channel to unbind from (e.g. `voice`, `telegram`).
+
+### On success (`success: true`)
+
+The response includes `bound: false` after the operation completes. Check the previous binding state to tailor the message:
+
+- If a binding was previously active (i.e., the user explicitly asked to revoke their guardian): "Guardian binding revoked for [channel]. The previous guardian no longer has access to this channel."
+- If no binding existed (`bound: false` and there was nothing to revoke): "There is no active guardian binding for [channel] — nothing to revoke. Any pending verification challenges have been cleared."
+
 ## Important Notes
 
 - Verification codes expire after 10 minutes. If the session expires, start a new one.
@@ -161,3 +182,4 @@ If not yet bound, offer to resend (Step 4) or generate a new session (Step 3).
 - Per-destination rate limiting allows up to 10 sends within a 1-hour rolling window.
 - Guardian verification is identity-bound: the code can only be consumed by the identity matching the destination provided at start time.
 - **Missing `secret` guardrail**: For voice and Telegram chat-ID flows, the API response MUST include a `secret` field. If `secret` is unexpectedly absent from a start or resend response that otherwise indicates success, treat this as a control-plane error. Do NOT fabricate a code or tell the user to proceed without one. Instead, tell the user something went wrong and ask them to retry the start (Step 3) or resend (Step 4).
+- **Revoking a guardian**: To remove the current guardian from a channel, use the revoke API (Step 7). This revokes the binding AND revokes the guardian's contact record, so they lose access to the channel. A new guardian can then be verified for that channel.

package/src/config/bundled-skills/image-studio/tools/media-generate-image.ts

@@ -1,28 +1,43 @@
-import { getConfig } from '../../../../config/loader.js';
-import { type AttachmentContext,isAttachmentVisible } from '../../../../daemon/media-visibility-policy.js';
-import { generateImage, mapGeminiError } from '../../../../media/gemini-image-service.js';
-import { getAttachmentsByIds } from '../../../../memory/attachments-store.js';
-import { getConversationThreadType } from '../../../../memory/conversation-store.js';
-import type { ImageContent } from '../../../../providers/types.js';
-import { getAttachmentSourceConversations } from '../../../../tools/assets/search.js';
-import type { ToolContext, ToolExecutionResult } from '../../../../tools/types.js';
+import { getConfig } from "../../../../config/loader.js";
+import {
+  type AttachmentContext,
+  isAttachmentVisible,
+} from "../../../../daemon/media-visibility-policy.js";
+import {
+  generateImage,
+  mapGeminiError,
+} from "../../../../media/gemini-image-service.js";
+import { getAttachmentsByIds } from "../../../../memory/attachments-store.js";
+import { getConversationThreadType } from "../../../../memory/conversation-store.js";
+import type { ImageContent } from "../../../../providers/types.js";
+import { getAttachmentSourceConversations } from "../../../../tools/assets/search.js";
+import type {
+  ToolContext,
+  ToolExecutionResult,
+} from "../../../../tools/types.js";
 
 /**
  * Check whether an attachment is visible from the given context.
  * Mirrors the logic in tools/assets/search.ts:isAttachmentVisibleFromContext.
  */
-function isAttachmentAccessible(attachmentId: string, currentContext: AttachmentContext): boolean {
+function isAttachmentAccessible(
+  attachmentId: string,
+  currentContext: AttachmentContext,
+): boolean {
   const sources = getAttachmentSourceConversations(attachmentId);
   if (sources.length === 0) {
     return true; // orphan attachments are universally visible
   }
-  const hasStandard = sources.some((s) => s.threadType !== 'private');
+  const hasStandard = sources.some((s) => s.threadType !== "private");
   if (hasStandard) {
     return true;
   }
   // All sources are private — visible only if the caller is in one of those threads
-  return sources.some(
-    (s) => isAttachmentVisible({ conversationId: s.conversationId, isPrivate: true }, currentContext),
+  return sources.some((s) =>
+    isAttachmentVisible(
+      { conversationId: s.conversationId, isPrivate: true },
+      currentContext,
+    ),
   );
 }
 
@@ -35,13 +50,14 @@ export async function run(
 
   if (!apiKey) {
     return {
-      content: 'No Gemini API key configured. Please set your Gemini API key to use image generation.',
+      content:
+        "No Gemini API key configured. Please set your Gemini API key to use image generation.",
       isError: true,
     };
   }
 
   const prompt = input.prompt as string;
-  const mode = (input.mode as 'generate' | 'edit') ?? 'generate';
+  const mode = (input.mode as "generate" | "edit") ?? "generate";
   const attachmentIds = input.attachment_ids as string[] | undefined;
   const model = (input.model as string | undefined) ?? config.imageGenModel;
   const variants = input.variants as number | undefined;
@@ -56,7 +72,7 @@ export async function run(
     const threadType = getConversationThreadType(context.conversationId);
     const currentContext: AttachmentContext = {
       conversationId: context.conversationId,
-      isPrivate: threadType === 'private',
+      isPrivate: threadType === "private",
     };
 
     // Filter to only visible attachments using their originating context
@@ -66,7 +82,8 @@ export async function run(
 
     if (visibleAttachments.length === 0 && attachmentIds.length > 0) {
       return {
-        content: 'None of the specified attachments could be found or are accessible.',
+        content:
+          "None of the specified attachments could be found or are accessible.",
         isError: true,
       };
     }
@@ -87,15 +104,15 @@ export async function run(
     });
 
     const imageCount = result.images.length;
-    let content = `Generated ${imageCount} image${imageCount !== 1 ? 's' : ''} using ${result.resolvedModel}.`;
+    let content = `Generated ${imageCount} image${imageCount !== 1 ? "s" : ""} using ${result.resolvedModel}.`;
     if (result.text) {
       content += `\n\n${result.text}`;
     }
 
     const contentBlocks: ImageContent[] = result.images.map((img) => ({
-      type: 'image' as const,
+      type: "image" as const,
       source: {
-        type: 'base64' as const,
+        type: "base64" as const,
         media_type: img.mimeType,
         data: img.dataBase64,
       },

package/src/config/bundled-skills/knowledge-graph/tools/graph-query.ts

@@ -1,14 +1,25 @@
-import { inArray } from 'drizzle-orm';
-
-import { getDb,initializeDb } from '../../../../memory/db.js';
-import type { EntityRelationType, EntityType } from '../../../../memory/entity-extractor.js';
-import { memoryEntities } from '../../../../memory/schema.js';
-import { collectTypedNeighbors,findMatchedEntities, findNeighborEntities, getEntityLinkedItemCandidates } from '../../../../memory/search/entity.js';
-import type { TraversalStep } from '../../../../memory/search/types.js';
-import type { ToolContext, ToolExecutionResult } from '../../../../tools/types.js';
+import { inArray } from "drizzle-orm";
+
+import { getDb, initializeDb } from "../../../../memory/db.js";
+import type {
+  EntityRelationType,
+  EntityType,
+} from "../../../../memory/entity-extractor.js";
+import { memoryEntities } from "../../../../memory/schema.js";
+import {
+  collectTypedNeighbors,
+  findMatchedEntities,
+  findNeighborEntities,
+  getEntityLinkedItemCandidates,
+} from "../../../../memory/search/entity.js";
+import type { TraversalStep } from "../../../../memory/search/types.js";
+import type {
+  ToolContext,
+  ToolExecutionResult,
+} from "../../../../tools/types.js";
 
 interface GraphQueryInput {
-  query_type: 'neighbors' | 'typed_traversal' | 'intersection';
+  query_type: "neighbors" | "typed_traversal" | "intersection";
   seeds: string[];
   steps?: Array<{
     relation_types?: string[];
@@ -51,7 +62,7 @@ export async function run(
   if (seedEntityIds.length === 0) {
     return {
       content: JSON.stringify({
-        error: 'No matching entities found for the provided seed names',
+        error: "No matching entities found for the provided seed names",
         seeds: params.seeds,
       }),
       isError: true,
@@ -60,13 +71,17 @@ export async function run(
 
   // For intersection queries, all seeds must resolve — dropping any seed silently
   // changes semantics from "reachable from ALL seeds" to "reachable from resolved seeds"
-  if (params.query_type === 'intersection' && seedEntityIds.length < params.seeds.length) {
+  if (
+    params.query_type === "intersection" &&
+    seedEntityIds.length < params.seeds.length
+  ) {
     const unresolvedSeeds = params.seeds.filter(
-      name => !resolvedSeeds.some(s => s.name === name),
+      (name) => !resolvedSeeds.some((s) => s.name === name),
     );
     return {
       content: JSON.stringify({
-        error: 'Some seed entities could not be resolved. Intersection requires all seeds to match.',
+        error:
+          "Some seed entities could not be resolved. Intersection requires all seeds to match.",
         unresolved_seeds: unresolvedSeeds,
         resolved_seeds: resolvedSeeds,
       }),
@@ -77,21 +92,23 @@ export async function run(
   let resultEntityIds: string[];
 
   switch (params.query_type) {
-    case 'neighbors': {
+    case "neighbors": {
       const steps = params.steps?.[0];
       const result = findNeighborEntities(seedEntityIds, {
         maxEdges: 40,
         maxNeighborEntities: maxResults,
         maxDepth: 1,
-        relationTypes: steps?.relation_types as EntityRelationType[] | undefined,
+        relationTypes: steps?.relation_types as
+          | EntityRelationType[]
+          | undefined,
         entityTypes: steps?.entity_types as EntityType[] | undefined,
       });
       resultEntityIds = result.neighborEntityIds;
       break;
     }
 
-    case 'typed_traversal': {
-      const traversalSteps: TraversalStep[] = (params.steps ?? []).map(s => ({
+    case "typed_traversal": {
+      const traversalSteps: TraversalStep[] = (params.steps ?? []).map((s) => ({
         relationTypes: s.relation_types as EntityRelationType[] | undefined,
         entityTypes: s.entity_types as EntityType[] | undefined,
       }));
@@ -102,9 +119,9 @@ export async function run(
       break;
     }
 
-    case 'intersection': {
+    case "intersection": {
       // Run typed traversal from each seed independently, then intersect
-      const traversalSteps: TraversalStep[] = (params.steps ?? []).map(s => ({
+      const traversalSteps: TraversalStep[] = (params.steps ?? []).map((s) => ({
         relationTypes: s.relation_types as EntityRelationType[] | undefined,
         entityTypes: s.entity_types as EntityType[] | undefined,
       }));
@@ -122,8 +139,8 @@ export async function run(
         resultEntityIds = [];
       } else {
         // Intersect all sets
-        const intersection = [...resultSets[0]].filter(id =>
-          resultSets.every(set => set.has(id))
+        const intersection = [...resultSets[0]].filter((id) =>
+          resultSets.every((set) => set.has(id)),
         );
         resultEntityIds = intersection;
       }
@@ -132,7 +149,9 @@ export async function run(
 
     default:
       return {
-        content: JSON.stringify({ error: `Unknown query_type: ${params.query_type}` }),
+        content: JSON.stringify({
+          error: `Unknown query_type: ${params.query_type}`,
+        }),
         isError: true,
       };
   }
@@ -153,19 +172,21 @@ export async function run(
         id: row.id,
         name: row.name,
         type: row.type,
-        aliases: row.aliases ? JSON.parse(row.aliases) as string[] : [],
+        aliases: row.aliases ? (JSON.parse(row.aliases) as string[]) : [],
       };
 
       if (includeItems) {
         const candidates = getEntityLinkedItemCandidates([row.id], {
-          source: 'entity_direct',
-          scopeIds: _context.memoryScopeId ? [_context.memoryScopeId] : undefined,
+          source: "entity_direct",
+          scopeIds: _context.memoryScopeId
+            ? [_context.memoryScopeId]
+            : undefined,
         });
-        entity.items = candidates.slice(0, 5).map(c => {
-          const parts = c.text.split(': ');
+        entity.items = candidates.slice(0, 5).map((c) => {
+          const parts = c.text.split(": ");
           return {
-            subject: parts[0] ?? '',
-            statement: parts.slice(1).join(': ') || c.text,
+            subject: parts[0] ?? "",
+            statement: parts.slice(1).join(": ") || c.text,
           };
         });
       }
@@ -175,12 +196,16 @@ export async function run(
   }
 
   return {
-    content: JSON.stringify({
-      query_type: params.query_type,
-      resolved_seeds: resolvedSeeds,
-      result_count: entities.length,
-      entities,
-    }, null, 2),
+    content: JSON.stringify(
+      {
+        query_type: params.query_type,
+        resolved_seeds: resolvedSeeds,
+        result_count: entities.length,
+        entities,
+      },
+      null,
+      2,
+    ),
     isError: false,
   };
 }