@vellumai/assistant 0.3.0

package/src/config/bundled-skills/google-calendar/SKILL.md

@@ -0,0 +1,51 @@
+---
+name: "Google Calendar"
+description: "View, create, and manage Google Calendar events and check availability"
+user-invocable: true
+metadata: {"vellum": {"emoji": "📅"}}
+---
+
+You are a Google Calendar assistant with full access to the user's calendar. Use the Calendar tools to help them view, create, and manage events.
+
+## Connection Setup
+
+Before using any Calendar tool, verify that Google Calendar is connected by attempting a lightweight call (e.g., `calendar_list_events` with a narrow date range). If the call fails with a token/authorization error:
+
+1. **Do NOT call `credential_store oauth2_connect` yourself.** You do not have valid OAuth client credentials, and fabricating a client_id will cause a "401: invalid_client" error from Google.
+2. Instead, install and load the **google-oauth-setup** skill, which walks the user through creating real credentials in Google Cloud Console:
+   - Call `vellum_skills_catalog` with `action: "install"` and `skill_id: "google-oauth-setup"`.
+   - Then call `vellum_skills_catalog` with `action: "load"` and `skill_id: "google-oauth-setup"`.
+3. Tell the user: *"Google Calendar isn't connected yet. I've loaded a setup guide that will walk you through connecting your Google account — it only takes a couple of minutes."*
+
+## Capabilities
+
+- **List Events**: View upcoming events from any calendar within a date range.
+- **Get Event**: Read full details of a specific calendar event.
+- **Create Event**: Create new events with attendees, location, and description.
+- **Check Availability**: Find free/busy times across calendars to identify open slots for scheduling.
+- **RSVP**: Respond to event invitations (accepted, declined, tentative).
+
+## Scheduling Playbook
+
+When the user wants to schedule something:
+
+1. **Always check availability first** before proposing times. Use `calendar_check_availability` to find free slots.
+2. Propose 2-3 available time options to the user.
+3. Once the user picks a time, create the event with `calendar_create_event`.
+4. If adding other attendees, mention that they'll receive an invitation email.
+
+## Date & Time Handling
+
+- Always ask the user for their timezone if it's not already known from context or their profile.
+- Use ISO 8601 format for dates and times (e.g., `2024-01-15T09:00:00-05:00`).
+- For all-day events, use date-only format (e.g., `2024-01-15`).
+- When listing events, display times in the user's local timezone.
+
+## Confidence Scores
+
+Medium-risk tools (create event, RSVP) require a confidence score between 0 and 1. Set this based on how certain you are the action matches the user's intent:
+
+- **0.9-1.0**: User explicitly requested this exact action
+- **0.7-0.8**: Action is strongly implied by context
+- **0.5-0.6**: Reasonable inference but some ambiguity
+- **Below 0.5**: Ask the user to confirm before proceeding

package/src/config/bundled-skills/google-calendar/TOOLS.json

@@ -0,0 +1,108 @@
+{
+  "version": 1,
+  "tools": [
+    {
+      "name": "calendar_list_events",
+      "description": "List upcoming calendar events within a date range. Returns event summaries, times, and metadata.",
+      "category": "calendar",
+      "risk": "low",
+      "input_schema": {
+        "type": "object",
+        "properties": {
+          "calendar_id": { "type": "string", "description": "Calendar ID to query (default \"primary\")" },
+          "time_min": { "type": "string", "description": "Start of time range in ISO 8601 format (e.g. \"2024-01-15T00:00:00Z\"). Defaults to now." },
+          "time_max": { "type": "string", "description": "End of time range in ISO 8601 format (e.g. \"2024-01-22T00:00:00Z\"). Defaults to 7 days from now." },
+          "max_results": { "type": "number", "description": "Maximum number of events to return (default 25, max 250)" },
+          "query": { "type": "string", "description": "Free text search terms to filter events" },
+          "single_events": { "type": "boolean", "description": "Whether to expand recurring events into individual instances (default true)" },
+          "order_by": { "type": "string", "enum": ["startTime", "updated"], "description": "Sort order (default \"startTime\"). Only valid when single_events is true." }
+        }
+      },
+      "executor": "tools/calendar-list-events.ts",
+      "execution_target": "host"
+    },
+    {
+      "name": "calendar_get_event",
+      "description": "Get the full details of a single calendar event by its ID.",
+      "category": "calendar",
+      "risk": "low",
+      "input_schema": {
+        "type": "object",
+        "properties": {
+          "event_id": { "type": "string", "description": "The calendar event ID" },
+          "calendar_id": { "type": "string", "description": "Calendar ID (default \"primary\")" }
+        },
+        "required": ["event_id"]
+      },
+      "executor": "tools/calendar-get-event.ts",
+      "execution_target": "host"
+    },
+    {
+      "name": "calendar_create_event",
+      "description": "Create a new calendar event. Include a confidence score (0-1) indicating how certain you are this action is correct.",
+      "category": "calendar",
+      "risk": "medium",
+      "input_schema": {
+        "type": "object",
+        "properties": {
+          "summary": { "type": "string", "description": "Event title" },
+          "start": { "type": "string", "description": "Start time in ISO 8601 format (e.g. \"2024-01-15T09:00:00-05:00\") or date for all-day events (\"2024-01-15\")" },
+          "end": { "type": "string", "description": "End time in ISO 8601 format or date for all-day events" },
+          "description": { "type": "string", "description": "Event description or notes" },
+          "location": { "type": "string", "description": "Event location" },
+          "attendees": {
+            "type": "array",
+            "items": { "type": "string" },
+            "description": "Email addresses of attendees to invite"
+          },
+          "timezone": { "type": "string", "description": "IANA timezone (e.g. \"America/New_York\"). Required when start/end don't include timezone offset." },
+          "calendar_id": { "type": "string", "description": "Calendar ID (default \"primary\")" },
+          "confidence": { "type": "number", "description": "Confidence score (0-1) for this action" }
+        },
+        "required": ["summary", "start", "end", "confidence"]
+      },
+      "executor": "tools/calendar-create-event.ts",
+      "execution_target": "host"
+    },
+    {
+      "name": "calendar_check_availability",
+      "description": "Check free/busy status across one or more calendars to find available time slots.",
+      "category": "calendar",
+      "risk": "low",
+      "input_schema": {
+        "type": "object",
+        "properties": {
+          "time_min": { "type": "string", "description": "Start of time range in ISO 8601 format" },
+          "time_max": { "type": "string", "description": "End of time range in ISO 8601 format" },
+          "calendar_ids": {
+            "type": "array",
+            "items": { "type": "string" },
+            "description": "Calendar IDs to check (default [\"primary\"])"
+          },
+          "timezone": { "type": "string", "description": "IANA timezone for interpreting results (e.g. \"America/New_York\")" }
+        },
+        "required": ["time_min", "time_max"]
+      },
+      "executor": "tools/calendar-check-availability.ts",
+      "execution_target": "host"
+    },
+    {
+      "name": "calendar_rsvp",
+      "description": "Respond to a calendar event invitation (accept, decline, or tentative). Include a confidence score (0-1).",
+      "category": "calendar",
+      "risk": "medium",
+      "input_schema": {
+        "type": "object",
+        "properties": {
+          "event_id": { "type": "string", "description": "The calendar event ID" },
+          "response": { "type": "string", "enum": ["accepted", "declined", "tentative"], "description": "RSVP response" },
+          "calendar_id": { "type": "string", "description": "Calendar ID (default \"primary\")" },
+          "confidence": { "type": "number", "description": "Confidence score (0-1) for this action" }
+        },
+        "required": ["event_id", "response", "confidence"]
+      },
+      "executor": "tools/calendar-rsvp.ts",
+      "execution_target": "host"
+    }
+  ]
+}

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

@@ -0,0 +1,165 @@
+import type {
+  CalendarEvent,
+  CalendarEventsListResponse,
+  FreeBusyRequest,
+  FreeBusyResponse,
+  CalendarListResponse,
+} from './types.js';
+
+const CALENDAR_API_BASE = 'https://www.googleapis.com/calendar/v3';
+
+export class CalendarApiError extends Error {
+  constructor(
+    public readonly status: number,
+    public readonly statusText: string,
+    message: string,
+  ) {
+    super(message);
+    this.name = 'CalendarApiError';
+  }
+}
+
+async function request<T>(token: string, path: string, options?: RequestInit): Promise<T> {
+  const url = `${CALENDAR_API_BASE}${path}`;
+  const resp = await fetch(url, {
+    ...options,
+    headers: {
+      Authorization: `Bearer ${token}`,
+      'Content-Type': 'application/json',
+      ...options?.headers,
+    },
+  });
+  if (!resp.ok) {
+    const body = await resp.text().catch(() => '');
+    throw new CalendarApiError(resp.status, resp.statusText, `Calendar API ${resp.status}: ${body}`);
+  }
+  const contentLength = resp.headers.get('content-length');
+  if (resp.status === 204 || contentLength === '0') {
+    return undefined as T;
+  }
+  const text = await resp.text();
+  if (!text) return undefined as T;
+  return JSON.parse(text) as T;
+}
+
+/** List events from a calendar. */
+export async function listEvents(
+  token: string,
+  calendarId = 'primary',
+  options?: {
+    timeMin?: string;
+    timeMax?: string;
+    maxResults?: number;
+    query?: string;
+    singleEvents?: boolean;
+    orderBy?: 'startTime' | 'updated';
+    pageToken?: string;
+    syncToken?: string;
+  },
+): Promise<CalendarEventsListResponse> {
+  const params = new URLSearchParams();
+
+  if (options?.timeMin) params.set('timeMin', options.timeMin);
+  if (options?.timeMax) params.set('timeMax', options.timeMax);
+  params.set('maxResults', String(options?.maxResults ?? 25));
+  if (options?.query) params.set('q', options.query);
+
+  // Default to expanding recurring events into instances
+  const singleEvents = options?.singleEvents ?? true;
+  params.set('singleEvents', String(singleEvents));
+
+  if (singleEvents && options?.orderBy) {
+    params.set('orderBy', options.orderBy);
+  } else if (singleEvents) {
+    params.set('orderBy', 'startTime');
+  }
+
+  if (options?.pageToken) params.set('pageToken', options.pageToken);
+  if (options?.syncToken) params.set('syncToken', options.syncToken);
+
+  return request<CalendarEventsListResponse>(
+    token,
+    `/calendars/${encodeURIComponent(calendarId)}/events?${params}`,
+  );
+}
+
+/** Get a single event by ID. */
+export async function getEvent(
+  token: string,
+  eventId: string,
+  calendarId = 'primary',
+): Promise<CalendarEvent> {
+  return request<CalendarEvent>(
+    token,
+    `/calendars/${encodeURIComponent(calendarId)}/events/${encodeURIComponent(eventId)}`,
+  );
+}
+
+/** Create a new event. */
+export async function createEvent(
+  token: string,
+  event: {
+    summary: string;
+    start: { dateTime?: string; date?: string; timeZone?: string };
+    end: { dateTime?: string; date?: string; timeZone?: string };
+    description?: string;
+    location?: string;
+    attendees?: Array<{ email: string }>;
+  },
+  calendarId = 'primary',
+  sendUpdates: 'all' | 'externalOnly' | 'none' = 'all',
+): Promise<CalendarEvent> {
+  const params = new URLSearchParams({ sendUpdates });
+  return request<CalendarEvent>(
+    token,
+    `/calendars/${encodeURIComponent(calendarId)}/events?${params}`,
+    {
+      method: 'POST',
+      body: JSON.stringify(event),
+    },
+  );
+}
+
+/** Update an event (patch). */
+export async function patchEvent(
+  token: string,
+  eventId: string,
+  updates: Partial<{
+    summary: string;
+    description: string;
+    location: string;
+    start: { dateTime?: string; date?: string; timeZone?: string };
+    end: { dateTime?: string; date?: string; timeZone?: string };
+    attendees: Array<{ email: string; responseStatus?: string }>;
+  }>,
+  calendarId = 'primary',
+  sendUpdates: 'all' | 'externalOnly' | 'none' = 'all',
+): Promise<CalendarEvent> {
+  const params = new URLSearchParams({ sendUpdates });
+  return request<CalendarEvent>(
+    token,
+    `/calendars/${encodeURIComponent(calendarId)}/events/${encodeURIComponent(eventId)}?${params}`,
+    {
+      method: 'PATCH',
+      body: JSON.stringify(updates),
+    },
+  );
+}
+
+/** Query free/busy information. */
+export async function freeBusy(
+  token: string,
+  query: FreeBusyRequest,
+): Promise<FreeBusyResponse> {
+  return request<FreeBusyResponse>(token, '/freeBusy', {
+    method: 'POST',
+    body: JSON.stringify(query),
+  });
+}
+
+/** List calendars the user has access to. */
+export async function listCalendars(
+  token: string,
+): Promise<CalendarListResponse> {
+  return request<CalendarListResponse>(token, '/users/me/calendarList');
+}

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

@@ -0,0 +1,21 @@
+import type { ToolContext, ToolExecutionResult } from '../../../../tools/types.js';
+import * as calendar from '../calendar-client.js';
+import { withCalendarToken, ok } from './shared.js';
+
+export async function run(input: Record<string, unknown>, _context: ToolContext): Promise<ToolExecutionResult> {
+  const timeMin = input.time_min as string;
+  const timeMax = input.time_max as string;
+  const calendarIds = (input.calendar_ids as string[]) ?? ['primary'];
+  const timezone = input.timezone as string | undefined;
+
+  return withCalendarToken(async (token) => {
+    const result = await calendar.freeBusy(token, {
+      timeMin,
+      timeMax,
+      timeZone: timezone,
+      items: calendarIds.map((id) => ({ id })),
+    });
+
+    return ok(JSON.stringify(result, null, 2));
+  });
+}

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

@@ -0,0 +1,42 @@
+import type { ToolContext, ToolExecutionResult } from '../../../../tools/types.js';
+import * as calendar from '../calendar-client.js';
+import { withCalendarToken, ok } from './shared.js';
+
+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;
+  const description = input.description as string | undefined;
+  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';
+
+  // Determine if these are all-day events (date-only) or timed events
+  const isAllDay = !startRaw.includes('T');
+
+  const start = isAllDay
+    ? { date: startRaw }
+    : { dateTime: startRaw, timeZone: timezone };
+  const end = isAllDay
+    ? { date: endRaw }
+    : { dateTime: endRaw, timeZone: timezone };
+
+  const eventBody: Parameters<typeof calendar.createEvent>[1] = {
+    summary,
+    start,
+    end,
+  };
+
+  if (description) eventBody.description = description;
+  if (location) eventBody.location = location;
+  if (attendees?.length) {
+    eventBody.attendees = attendees.map((email) => ({ email }));
+  }
+
+  return withCalendarToken(async (token) => {
+    const event = await calendar.createEvent(token, eventBody, calendarId);
+    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

@@ -0,0 +1,13 @@
+import type { ToolContext, ToolExecutionResult } from '../../../../tools/types.js';
+import * as calendar from '../calendar-client.js';
+import { withCalendarToken, ok } from './shared.js';
+
+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';
+
+  return withCalendarToken(async (token) => {
+    const event = await calendar.getEvent(token, eventId, calendarId);
+    return ok(JSON.stringify(event, null, 2));
+  });
+}

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

@@ -0,0 +1,30 @@
+import type { ToolContext, ToolExecutionResult } from '../../../../tools/types.js';
+import * as calendar from '../calendar-client.js';
+import { withCalendarToken, ok } from './shared.js';
+
+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;
+
+  return withCalendarToken(async (token) => {
+    const result = await calendar.listEvents(token, calendarId, {
+      timeMin,
+      timeMax,
+      maxResults,
+      query,
+      singleEvents,
+      orderBy,
+    });
+
+    if (!result.items?.length) {
+      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

@@ -0,0 +1,41 @@
+import type { ToolContext, ToolExecutionResult } from '../../../../tools/types.js';
+import * as calendar from '../calendar-client.js';
+import { withCalendarToken, ok } from './shared.js';
+
+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';
+
+  return withCalendarToken(async (token) => {
+    // First get the event to find the user's attendee entry
+    const event = await calendar.getEvent(token, 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(
+      token,
+      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

@@ -0,0 +1,18 @@
+import { withValidToken } from '../../../../security/token-manager.js';
+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 };
+}
+
+/**
+ * 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);
+}

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

@@ -0,0 +1,97 @@
+/** 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/image-studio/SKILL.md

@@ -0,0 +1,32 @@
+---
+name: "Image Studio"
+description: "Generate and edit images using AI"
+user-invocable: true
+disable-model-invocation: false
+metadata: {"vellum": {"emoji": "🎨"}}
+---
+
+You are an image generation assistant. When the user asks you to create or edit images, use the `media_generate_image` tool.
+
+## Usage
+
+- **Text-to-image**: "Generate an image of a sunset over the ocean"
+- **Image editing**: "Remove the background from this image" (requires attaching an image)
+- **Multiple variants**: "Generate 3 variations of a logo for a coffee shop"
+
+## Modes
+
+- **generate** (default): Create a new image from a text prompt.
+- **edit**: Modify an existing image based on a text prompt. Requires one or more attached source images via `attachment_ids`.
+
+## Models
+
+- `gemini-2.5-flash-image` (default) — fast, good quality
+- `gemini-3-pro-image` — higher quality, slower
+
+## Tips
+
+- Be descriptive in your prompts for better results. Include details about style, composition, lighting, and mood.
+- When editing images, clearly describe what changes you want made to the source image.
+- Use the `variants` parameter (1-4) to generate multiple options and pick the best one.
+- If no Gemini API key is configured, the tool will return an error — ask the user to set one up.

package/src/config/bundled-skills/image-studio/TOOLS.json

@@ -0,0 +1,42 @@
+{
+  "version": 1,
+  "tools": [
+    {
+      "name": "media_generate_image",
+      "description": "Generate or edit images using AI. Supports text-to-image generation and image editing with source images.",
+      "category": "media",
+      "risk": "low",
+      "input_schema": {
+        "type": "object",
+        "properties": {
+          "prompt": {
+            "type": "string",
+            "description": "A text description of the image to generate or the edits to apply"
+          },
+          "mode": {
+            "type": "string",
+            "enum": ["generate", "edit"],
+            "description": "Whether to generate a new image or edit an existing one (default: generate)"
+          },
+          "attachment_ids": {
+            "type": "array",
+            "items": { "type": "string" },
+            "description": "IDs of attached source images to edit (required for edit mode)"
+          },
+          "model": {
+            "type": "string",
+            "enum": ["gemini-2.5-flash-image", "gemini-3-pro-image", "gemini-3-pro-image-preview"],
+            "description": "Which model to use for generation. If omitted, uses the user's configured preference."
+          },
+          "variants": {
+            "type": "number",
+            "description": "Number of image variants to generate (1-4, default: 1)"
+          }
+        },
+        "required": ["prompt"]
+      },
+      "executor": "tools/media-generate-image.ts",
+      "execution_target": "host"
+    }
+  ]
+}