@vellumai/assistant 0.3.4 → 0.3.5

package/src/config/bundled-skills/media-processing/tools/query-media-events.ts

@@ -0,0 +1,300 @@
+/**
+ * Natural language query tool for media events.
+ *
+ * Accepts a free-text query and optional asset_id, parses the query into
+ * structured filters via simple keyword matching, then delegates to the
+ * generic retrieval service. Domain-specific keyword mappings live here;
+ * the retrieval layer remains fully generic.
+ */
+
+import type { ToolContext, ToolExecutionResult } from '../../../../tools/types.js';
+import { retrieveEvents, type RetrievalFilters } from '../services/retrieval-service.js';
+import { getTrackingProfile, type CapabilityTier } from '../../../../memory/media-store.js';
+import { getCapabilitiesByTier, getCapabilityByName } from '../services/capability-registry.js';
+
+// ---------------------------------------------------------------------------
+// NL query parsing
+// ---------------------------------------------------------------------------
+
+/** Maps domain-specific keywords to canonical event type labels. */
+const EVENT_TYPE_KEYWORDS: Record<string, string> = {
+  // Basketball
+  turnover: 'turnover',
+  turnovers: 'turnover',
+  steal: 'turnover',
+  steals: 'turnover',
+  // Soccer / football
+  goal: 'goal',
+  goals: 'goal',
+  score: 'goal',
+  scores: 'goal',
+  // Generic
+  highlight: 'highlight',
+  highlights: 'highlight',
+  scene_change: 'scene_change',
+  'scene change': 'scene_change',
+  'scene changes': 'scene_change',
+  foul: 'foul',
+  fouls: 'foul',
+  shot: 'shot',
+  shots: 'shot',
+  rebound: 'rebound',
+  rebounds: 'rebound',
+  assist: 'assist',
+  assists: 'assist',
+  block: 'block',
+  blocks: 'block',
+  transition: 'transition',
+  transitions: 'transition',
+  fast_break: 'fast_break',
+  'fast break': 'fast_break',
+  'fast breaks': 'fast_break',
+};
+
+/**
+ * Extract a numeric limit from phrases like "top 5", "first 3", "last 10".
+ * Returns undefined if no limit phrase is found.
+ */
+function parseLimit(query: string): number | undefined {
+  const match = query.match(/(?:top|first|last|show|find|get)\s+(\d+)(?!\s*min)/i);
+  if (match) return parseInt(match[1], 10);
+  // Also match trailing "N events/moments"
+  const trailingMatch = query.match(/(\d+)\s+(?:events?|moments?|plays?|clips?)/i);
+  if (trailingMatch) return parseInt(trailingMatch[1], 10);
+  return undefined;
+}
+
+/**
+ * Extract a confidence threshold from the query.
+ */
+function parseConfidence(query: string): number | undefined {
+  const lower = query.toLowerCase();
+  if (lower.includes('high confidence') || lower.includes('very confident') || lower.includes('most confident')) {
+    return 0.8;
+  }
+  if (lower.includes('confident') || lower.includes('medium confidence')) {
+    return 0.5;
+  }
+  // Explicit threshold: "confidence > 0.7" or "confidence above 0.7"
+  const explicitMatch = lower.match(/confidence\s*(?:>|above|over|>=)\s*([\d.]+)/);
+  if (explicitMatch) return parseFloat(explicitMatch[1]);
+  return undefined;
+}
+
+/**
+ * Extract a time range from the query (returns seconds).
+ * Supports phrases like "first half", "second half", "first N minutes",
+ * "last N minutes", "between M and N minutes".
+ */
+function parseTimeRange(query: string): { startTimeMin?: number; startTimeMax?: number } {
+  const lower = query.toLowerCase();
+
+  // "first half" / "second half" — these are relative and require knowing
+  // total duration, which we don't have. Use reasonable game defaults:
+  // assume ~48 min game → 2880s, half = 1440s
+  if (lower.includes('first half')) {
+    return { startTimeMin: 0, startTimeMax: 1440 };
+  }
+  if (lower.includes('second half')) {
+    return { startTimeMin: 1440 };
+  }
+
+  // "first N minutes"
+  const firstNMin = lower.match(/first\s+(\d+)\s*min/);
+  if (firstNMin) {
+    return { startTimeMin: 0, startTimeMax: parseInt(firstNMin[1], 10) * 60 };
+  }
+
+  // "last N minutes"
+  // Without knowing total duration we can't compute this precisely,
+  // so we skip it and let the retrieval return all results.
+
+  // "between M and N minutes"
+  const betweenMatch = lower.match(/between\s+(\d+)\s*(?:and|to|-)\s*(\d+)\s*min/);
+  if (betweenMatch) {
+    return {
+      startTimeMin: parseInt(betweenMatch[1], 10) * 60,
+      startTimeMax: parseInt(betweenMatch[2], 10) * 60,
+    };
+  }
+
+  return {};
+}
+
+/**
+ * Extract the event type from the query by matching known keywords.
+ */
+function parseEventType(query: string): string | undefined {
+  const lower = query.toLowerCase();
+
+  // Check multi-word keywords first (longer matches win)
+  const multiWordKeys = Object.keys(EVENT_TYPE_KEYWORDS)
+    .filter((k) => k.includes(' ') || k.includes('_'))
+    .sort((a, b) => b.length - a.length);
+
+  for (const key of multiWordKeys) {
+    if (lower.includes(key)) return EVENT_TYPE_KEYWORDS[key];
+  }
+
+  // Check single-word keywords
+  const words = lower.replace(/[^\w\s]/g, '').split(/\s+/);
+  for (const word of words) {
+    if (EVENT_TYPE_KEYWORDS[word]) return EVENT_TYPE_KEYWORDS[word];
+  }
+
+  return undefined;
+}
+
+/**
+ * Parse a natural language query into structured retrieval filters.
+ */
+function parseQuery(query: string, assetId?: string): RetrievalFilters {
+  const eventType = parseEventType(query);
+  const limit = parseLimit(query);
+  const minConfidence = parseConfidence(query);
+  const timeRange = parseTimeRange(query);
+
+  return {
+    assetId,
+    eventType,
+    minConfidence,
+    limit: limit ?? 10,
+    sortBy: 'confidence',
+    ...timeRange,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Formatting
+// ---------------------------------------------------------------------------
+
+function formatTimestamp(seconds: number): string {
+  const mins = Math.floor(seconds / 60);
+  const secs = Math.floor(seconds % 60);
+  return `${mins}:${secs.toString().padStart(2, '0')}`;
+}
+
+// ---------------------------------------------------------------------------
+// Tool entry point
+// ---------------------------------------------------------------------------
+
+export async function run(
+  input: Record<string, unknown>,
+  _context: ToolContext,
+): Promise<ToolExecutionResult> {
+  const query = input.query as string | undefined;
+  if (!query) {
+    return { content: 'query is required.', isError: true };
+  }
+
+  const assetId = input.asset_id as string | undefined;
+  if (!assetId) {
+    return { content: 'asset_id is required to scope the query to a specific media asset.', isError: true };
+  }
+
+  const filters = parseQuery(query, assetId);
+
+  // Retrieve without limit so we can apply capability filtering first, then limit
+  const userLimit = filters.limit;
+  const result = retrieveEvents({ ...filters, limit: 0 });
+
+  // Determine which capabilities are allowed based on the tracking profile
+  const profile = getTrackingProfile(assetId);
+
+  let allowedEventTypes: Set<string> | null = null;
+  const tierForEventType = new Map<string, CapabilityTier>();
+
+  if (profile) {
+    // Use the explicit profile: only enabled capabilities pass
+    allowedEventTypes = new Set<string>();
+    for (const [capName, entry] of Object.entries(profile.capabilities)) {
+      if (entry.enabled) {
+        allowedEventTypes.add(capName);
+        tierForEventType.set(capName, entry.tier);
+      }
+    }
+  } else {
+    // No profile: default to 'ready' tier capabilities only
+    const readyCaps = getCapabilitiesByTier('ready');
+    if (readyCaps.length > 0) {
+      allowedEventTypes = new Set(readyCaps.map((c) => c.name));
+      for (const cap of readyCaps) {
+        tierForEventType.set(cap.name, 'ready');
+      }
+    }
+    // If no capabilities are registered at all, allow everything (pass null)
+  }
+
+  // Filter events by allowed capabilities, then apply the user-requested limit
+  let filteredEvents = result.events;
+  if (allowedEventTypes !== null) {
+    filteredEvents = filteredEvents.filter((e) => allowedEventTypes!.has(e.eventType));
+  }
+  if (userLimit && filteredEvents.length > userLimit) {
+    filteredEvents = filteredEvents.slice(0, userLimit);
+  }
+
+  if (filteredEvents.length === 0) {
+    const parts = ['No matching events found'];
+    if (filters.eventType) parts.push(`for event type "${filters.eventType}"`);
+    if (filters.minConfidence) parts.push(`with confidence >= ${filters.minConfidence}`);
+    if (!profile) parts.push('(defaulting to ready-tier capabilities only)');
+    parts.push(`in asset ${assetId}.`);
+    return { content: parts.join(' '), isError: false };
+  }
+
+  const tierLabels: Record<string, string> = {
+    ready: '[Ready]',
+    beta: '[Beta]',
+    experimental: '[Experimental]',
+  };
+
+  const tierDisclaimers: Record<string, string> = {
+    beta: 'Beta results may have accuracy gaps.',
+    experimental: 'Experimental results are early-stage; expect noise.',
+  };
+
+  const eventSummaries = filteredEvents.map((e, i) => {
+    const tier = tierForEventType.get(e.eventType) ?? getCapabilityByName(e.eventType)?.tier;
+    const tierLabel = tier ? tierLabels[tier] ?? `[${tier}]` : '[Ready]';
+    const disclaimer = tier ? tierDisclaimers[tier] : undefined;
+
+    return {
+      rank: i + 1,
+      id: e.id,
+      eventType: e.eventType,
+      tierLabel,
+      ...(disclaimer ? { confidenceDisclaimer: disclaimer } : {}),
+      timeRange: `${formatTimestamp(e.startTime)} – ${formatTimestamp(e.endTime)}`,
+      startTime: e.startTime,
+      endTime: e.endTime,
+      confidence: Math.round(e.confidence * 100) / 100,
+      reasons: e.reasons,
+      metadata: e.metadata,
+    };
+  });
+
+  // Collect disclaimers for any non-ready tiers present in results
+  const activeTiers = new Set(eventSummaries.map((e) => e.tierLabel));
+  const disclaimers: string[] = [];
+  if (activeTiers.has('[Beta]')) disclaimers.push(tierDisclaimers.beta);
+  if (activeTiers.has('[Experimental]')) disclaimers.push(tierDisclaimers.experimental);
+
+  return {
+    content: JSON.stringify({
+      query,
+      parsedFilters: {
+        eventType: filters.eventType ?? null,
+        minConfidence: filters.minConfidence ?? null,
+        limit: filters.limit,
+        startTimeMin: filters.startTimeMin ?? null,
+        startTimeMax: filters.startTimeMax ?? null,
+      },
+      trackingProfile: profile ? 'custom' : 'default (ready tier only)',
+      ...(disclaimers.length > 0 ? { disclaimers } : {}),
+      totalResults: eventSummaries.length,
+      events: eventSummaries,
+    }, null, 2),
+    isError: false,
+  };
+}

package/src/config/bundled-skills/media-processing/tools/recalibrate.ts

@@ -0,0 +1,235 @@
+/**
+ * Recalibration tool for media event detection.
+ *
+ * Reads all feedback for an asset, analyzes correction patterns, and
+ * re-ranks existing events using updated heuristics. Updates confidence
+ * scores in the media_events table.
+ *
+ * All interfaces are generic — works for any event type.
+ */
+
+import type { ToolContext, ToolExecutionResult } from '../../../../tools/types.js';
+import { getFeedbackForAsset, type EventFeedback } from '../services/feedback-store.js';
+import { aggregateFeedback } from '../services/feedback-aggregation.js';
+import { getEventsForAsset, getMediaAssetById } from '../../../../memory/media-store.js';
+import { getDb } from '../../../../memory/db.js';
+import { mediaEvents } from '../../../../memory/schema.js';
+import { eq } from 'drizzle-orm';
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+interface RecalibrationAdjustment {
+  eventType: string;
+  action: string;
+  detail: string;
+}
+
+interface EventUpdate {
+  eventId: string;
+  eventType: string;
+  oldConfidence: number;
+  newConfidence: number;
+}
+
+// ---------------------------------------------------------------------------
+// Tool entry point
+// ---------------------------------------------------------------------------
+
+export async function run(
+  input: Record<string, unknown>,
+  context: ToolContext,
+): Promise<ToolExecutionResult> {
+  const assetId = input.asset_id as string | undefined;
+  if (!assetId) {
+    return { content: 'asset_id is required.', isError: true };
+  }
+
+  const asset = getMediaAssetById(assetId);
+  if (!asset) {
+    return { content: `Asset "${assetId}" not found.`, isError: true };
+  }
+
+  const allFeedback = getFeedbackForAsset(assetId);
+  if (allFeedback.length === 0) {
+    return {
+      content: JSON.stringify({
+        message: 'No feedback found for this asset. Submit feedback first, then recalibrate.',
+        assetId,
+      }, null, 2),
+      isError: false,
+    };
+  }
+
+  const aggregation = aggregateFeedback(assetId);
+  const allEvents = getEventsForAsset(assetId);
+
+  // Build a map of event ID to its feedback entries
+  const feedbackByEventId = new Map<string, EventFeedback[]>();
+  for (const fb of allFeedback) {
+    if (!feedbackByEventId.has(fb.eventId)) {
+      feedbackByEventId.set(fb.eventId, []);
+    }
+    feedbackByEventId.get(fb.eventId)!.push(fb);
+  }
+
+  // Build a map of event ID to event type for filtering feedback by type
+  const eventTypeById = new Map<string, string>();
+  for (const ev of allEvents) {
+    eventTypeById.set(ev.id, ev.eventType);
+  }
+
+  const adjustments: RecalibrationAdjustment[] = [];
+  const eventUpdates: EventUpdate[] = [];
+  const db = getDb();
+
+  // Analyze patterns per event type
+  for (const stats of aggregation.statsByEventType) {
+    const { eventType, correct, incorrect, boundaryEdit, missed } = stats;
+    const totalReviewed = correct + incorrect + boundaryEdit + missed;
+    if (totalReviewed === 0) continue;
+
+    // Pattern 1: High false positive rate — penalize low-confidence events
+    const falsePositiveRate = totalReviewed > 0 ? incorrect / totalReviewed : 0;
+    if (falsePositiveRate > 0.3 && incorrect >= 2) {
+      adjustments.push({
+        eventType,
+        action: 'penalize_low_confidence',
+        detail: `False positive rate ${(falsePositiveRate * 100).toFixed(1)}% (${incorrect}/${totalReviewed}) — reducing confidence on unreviewed events of this type`,
+      });
+    }
+
+    // Pattern 2: Many missed events — note for threshold adjustment
+    if (missed >= 2) {
+      adjustments.push({
+        eventType,
+        action: 'note_missed_events',
+        detail: `${missed} missed events reported — consider lowering detection threshold or adding detection rules for this type`,
+      });
+    }
+
+    // Pattern 3: Boundary edits — compute average adjustment
+    if (boundaryEdit >= 1) {
+      const boundaryFeedback = allFeedback.filter(
+        (fb) => fb.feedbackType === 'boundary_edit' && eventTypeById.get(fb.eventId) === eventType,
+      );
+      let startAdjTotal = 0;
+      let endAdjTotal = 0;
+      let startAdjCount = 0;
+      let endAdjCount = 0;
+
+      for (const fb of boundaryFeedback) {
+        if (fb.originalStartTime !== null && fb.correctedStartTime !== null) {
+          startAdjTotal += fb.correctedStartTime - fb.originalStartTime;
+          startAdjCount++;
+        }
+        if (fb.originalEndTime !== null && fb.correctedEndTime !== null) {
+          endAdjTotal += fb.correctedEndTime - fb.originalEndTime;
+          endAdjCount++;
+        }
+      }
+
+      const avgStartAdj = startAdjCount > 0 ? startAdjTotal / startAdjCount : 0;
+      const avgEndAdj = endAdjCount > 0 ? endAdjTotal / endAdjCount : 0;
+
+      if (startAdjCount > 0 || endAdjCount > 0) {
+        adjustments.push({
+          eventType,
+          action: 'boundary_correction_pattern',
+          detail: `Average boundary adjustment: start ${avgStartAdj >= 0 ? '+' : ''}${avgStartAdj.toFixed(2)}s (n=${startAdjCount}), end ${avgEndAdj >= 0 ? '+' : ''}${avgEndAdj.toFixed(2)}s (n=${endAdjCount})`,
+        });
+      }
+    }
+  }
+
+  // Re-rank events: adjust confidence based on feedback
+  for (const event of allEvents) {
+    const eventFeedback = feedbackByEventId.get(event.id);
+    if (!eventFeedback || eventFeedback.length === 0) {
+      // For events without direct feedback, apply type-level adjustments
+      const stats = aggregation.statsByEventType.find((s) => s.eventType === event.eventType);
+      if (stats) {
+        const totalReviewed = stats.correct + stats.incorrect + stats.boundaryEdit + stats.missed;
+        const falsePositiveRate = totalReviewed > 0 ? stats.incorrect / totalReviewed : 0;
+
+        // If high false positive rate for this type, reduce unreviewed event confidence
+        if (falsePositiveRate > 0.3 && totalReviewed >= 3) {
+          const penalty = Math.min(falsePositiveRate * 0.3, 0.2);
+          const newConfidence = Math.max(0.05, event.confidence - penalty);
+          if (newConfidence !== event.confidence) {
+            db.update(mediaEvents)
+              .set({ confidence: newConfidence })
+              .where(eq(mediaEvents.id, event.id))
+              .run();
+            eventUpdates.push({
+              eventId: event.id,
+              eventType: event.eventType,
+              oldConfidence: event.confidence,
+              newConfidence,
+            });
+          }
+        }
+      }
+      continue;
+    }
+
+    // Direct feedback: adjust confidence based on the latest feedback
+    const latestFeedback = eventFeedback.sort((a, b) => b.createdAt - a.createdAt)[0];
+    let newConfidence = event.confidence;
+
+    switch (latestFeedback.feedbackType) {
+      case 'correct':
+        // Boost confidence toward 1.0
+        newConfidence = Math.min(1.0, event.confidence + (1.0 - event.confidence) * 0.3);
+        break;
+      case 'incorrect':
+        // Sharply reduce confidence
+        newConfidence = Math.max(0.05, event.confidence * 0.3);
+        break;
+      case 'boundary_edit':
+        // Slight confidence boost (event was real but boundaries were off)
+        newConfidence = Math.min(1.0, event.confidence + (1.0 - event.confidence) * 0.15);
+        break;
+      case 'missed':
+        // User-reported events keep their initial confidence
+        break;
+    }
+
+    newConfidence = Math.round(newConfidence * 1000) / 1000;
+
+    if (newConfidence !== event.confidence) {
+      db.update(mediaEvents)
+        .set({ confidence: newConfidence })
+        .where(eq(mediaEvents.id, event.id))
+        .run();
+      eventUpdates.push({
+        eventId: event.id,
+        eventType: event.eventType,
+        oldConfidence: event.confidence,
+        newConfidence,
+      });
+    }
+  }
+
+  context.onOutput?.(`Recalibrated ${eventUpdates.length} events based on ${allFeedback.length} feedback entries.\n`);
+
+  return {
+    content: JSON.stringify({
+      message: `Recalibration complete for asset ${assetId}`,
+      assetId,
+      totalFeedbackEntries: allFeedback.length,
+      adjustments,
+      eventsUpdated: eventUpdates.length,
+      eventUpdates: eventUpdates.map((u) => ({
+        eventId: u.eventId,
+        eventType: u.eventType,
+        oldConfidence: u.oldConfidence,
+        newConfidence: u.newConfidence,
+        delta: Math.round((u.newConfidence - u.oldConfidence) * 1000) / 1000,
+      })),
+      aggregation: aggregation.statsByEventType,
+    }, null, 2),
+    isError: false,
+  };
+}

package/src/config/bundled-skills/media-processing/tools/select-tracking-profile.ts

@@ -0,0 +1,142 @@
+/**
+ * Select and persist a tracking profile for a media asset.
+ *
+ * When called without capabilities, returns the available capabilities
+ * organized by tier so the user can choose. When called with capabilities,
+ * validates them against the registry and stores the profile.
+ */
+
+import type { ToolContext, ToolExecutionResult } from '../../../../tools/types.js';
+import { getMediaAssetById, setTrackingProfile, getTrackingProfile, type CapabilityProfile } from '../../../../memory/media-store.js';
+import {
+  getCapabilities,
+  getCapabilityByName,
+  getRegisteredDomains,
+  type Capability,
+} from '../services/capability-registry.js';
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function groupByTier(caps: Capability[]): Record<string, Capability[]> {
+  const groups: Record<string, Capability[]> = { ready: [], beta: [], experimental: [] };
+  for (const cap of caps) {
+    if (!groups[cap.tier]) groups[cap.tier] = [];
+    groups[cap.tier].push(cap);
+  }
+  return groups;
+}
+
+// ---------------------------------------------------------------------------
+// Tool entry point
+// ---------------------------------------------------------------------------
+
+export async function run(
+  input: Record<string, unknown>,
+  _context: ToolContext,
+): Promise<ToolExecutionResult> {
+  const assetId = input.asset_id as string | undefined;
+  if (!assetId) {
+    return { content: 'asset_id is required.', isError: true };
+  }
+
+  const asset = getMediaAssetById(assetId);
+  if (!asset) {
+    return { content: `No media asset found with id "${assetId}".`, isError: true };
+  }
+
+  const requestedCapabilities = input.capabilities as string[] | undefined;
+
+  // If no capabilities provided, return available options for the user to choose
+  if (!requestedCapabilities || requestedCapabilities.length === 0) {
+    const allCaps = getCapabilities();
+    const domains = getRegisteredDomains();
+    const byTier = groupByTier(allCaps);
+
+    const currentProfile = getTrackingProfile(assetId);
+
+    return {
+      content: JSON.stringify({
+        message: 'No capabilities specified. Here are the available capabilities organized by tier. Call again with a capabilities array to enable specific ones.',
+        domains,
+        availableCapabilities: {
+          ready: byTier.ready.map((c) => ({
+            name: c.name,
+            description: c.description,
+            domain: c.domain,
+            granularity: c.granularity ?? null,
+          })),
+          beta: byTier.beta.map((c) => ({
+            name: c.name,
+            description: c.description,
+            domain: c.domain,
+            granularity: c.granularity ?? null,
+            note: 'Beta: functional but may have accuracy gaps',
+          })),
+          experimental: byTier.experimental.map((c) => ({
+            name: c.name,
+            description: c.description,
+            domain: c.domain,
+            granularity: c.granularity ?? null,
+            note: 'Experimental: early-stage, expect noise in results',
+          })),
+        },
+        currentProfile: currentProfile ? currentProfile.capabilities : null,
+      }, null, 2),
+      isError: false,
+    };
+  }
+
+  // Validate requested capabilities exist in the registry
+  const capabilities: CapabilityProfile = {};
+  const unknownCaps: string[] = [];
+
+  for (const capName of requestedCapabilities) {
+    const registered = getCapabilityByName(capName);
+    if (!registered) {
+      unknownCaps.push(capName);
+      continue;
+    }
+    capabilities[capName] = { enabled: true, tier: registered.tier };
+  }
+
+  if (unknownCaps.length > 0) {
+    const allCaps = getCapabilities();
+    return {
+      content: JSON.stringify({
+        error: `Unknown capabilities: ${unknownCaps.join(', ')}`,
+        availableCapabilities: allCaps.map((c) => c.name),
+      }, null, 2),
+      isError: true,
+    };
+  }
+
+  // Store the profile
+  const profile = setTrackingProfile(assetId, capabilities);
+
+  // Build response with tier labels
+  const profileSummary: Record<string, { enabled: boolean; tier: string; tierLabel: string }> = {};
+  for (const [name, entry] of Object.entries(profile.capabilities)) {
+    const tierLabels: Record<string, string> = {
+      ready: '[Ready]',
+      beta: '[Beta]',
+      experimental: '[Experimental]',
+    };
+    profileSummary[name] = {
+      enabled: entry.enabled,
+      tier: entry.tier,
+      tierLabel: tierLabels[entry.tier] ?? `[${entry.tier}]`,
+    };
+  }
+
+  return {
+    content: JSON.stringify({
+      message: 'Tracking profile saved.',
+      assetId: profile.assetId,
+      profileId: profile.id,
+      capabilities: profileSummary,
+    }, null, 2),
+    isError: false,
+  };
+}