spine-framework 0.3.108 → 0.3.109

package/.framework/functions/_shared/agent-runner.ts

@@ -184,16 +184,26 @@ export async function runAgent(
       )
     }
 
-    // 5. Save agent response
+    // 5. Save agent response — include retrieved_sources + retrieval_confidence
+    //    so the feedback capture pipeline and the Portal UI can access them.
     const agentMsg = await saveMessage(
       threadId,
       agentResponse.content,
       'agent',
       {
         confidence: agentResponse.confidence,
+        retrieval_confidence: agentResponse.retrievalConfidence,
+        retrieved_sources: (agentResponse.retrievedSources || []).map((s: any) => ({
+          document_id: s.document_id,
+          title: s.title,
+          similarity: s.similarity,
+          item_type: s.item_type,
+          vector_type: s.vector_type,
+        })),
         tool_calls: agentResponse.tool_calls,
         agent_id: agent.id,
-        prompt_config_id: promptConfig.id
+        prompt_config_id: promptConfig.id,
+        sender_type: 'agent',
       },
       ctx,
       replyTypeSlug
@@ -208,6 +218,8 @@ export async function runAgent(
       thread_id: threadId,
       agent_id: agent.id,
       confidence: agentResponse.confidence,
+      retrieval_confidence: agentResponse.retrievalConfidence,
+      sources_count: agentResponse.retrievedSources?.length || 0,
       has_tool_calls: !!agentResponse.tool_calls?.length,
       duration_ms: Date.now() - startTime
     })
@@ -347,36 +359,49 @@ async function executeAgentInference(
   userMessage: string,
   ctx: CoreContext,
   maxToolIterations: number = 5
-): Promise<InferenceResult> {
-  const { agent, promptConfig, thread } = config
+): Promise<InferenceResult & { retrievedSources: any[]; retrievalConfidence: number }> {
+  const { agent, promptConfig } = config
 
-  // Build initial context
-  let context = await buildContext(config, userMessage, [], ctx)
+  // Build initial context — captures retrieved sources for feedback capture
+  let { context, retrievedSources, meanSimilarity } = await buildContext(config, userMessage, [], ctx)
 
   for (let iteration = 0; iteration < maxToolIterations; iteration++) {
-    // Call inference
     const inferenceResult = await callInference(context, agent, promptConfig, ctx)
 
-    // If no tool calls, return immediately
     if (!inferenceResult.tool_calls || inferenceResult.tool_calls.length === 0) {
-      return inferenceResult
+      // Composite confidence: 60% LLM logprobs + 40% retrieval similarity
+      // If mean retrieval similarity < 0.40, cap composite at 0.60
+      const llmConf = inferenceResult.confidence ?? 0.85
+      let compositeConf: number
+      if (meanSimilarity < 0.40 && meanSimilarity > 0) {
+        compositeConf = Math.min(llmConf * 0.6 + meanSimilarity * 0.4, 0.60)
+      } else {
+        compositeConf = llmConf * 0.6 + Math.min(meanSimilarity, 1) * 0.4
+      }
+
+      return {
+        ...inferenceResult,
+        confidence: Math.min(Math.max(compositeConf, 0), 1),
+        retrievedSources,
+        retrievalConfidence: meanSimilarity,
+      }
     }
 
-    // Execute tools
     const toolResults = await dispatchTools(inferenceResult.tool_calls, ctx)
+    const rebuilt = await buildContext(config, userMessage, toolResults, ctx)
+    context = rebuilt.context
+    if (rebuilt.retrievedSources.length) {
+      retrievedSources = rebuilt.retrievedSources
+      meanSimilarity = rebuilt.meanSimilarity
+    }
 
-    // Add tool results to context and re-inference
-    context = await buildContext(config, userMessage, toolResults, ctx)
-
-    // Check if any tool failed - if so, return with error info
     const hasErrors = toolResults.some(r => r.error)
     if (hasErrors && iteration === maxToolIterations - 1) {
       inferenceResult.content += '\n\n[Note: Some tools failed to execute.]'
-      return inferenceResult
+      return { ...inferenceResult, retrievedSources, retrievalConfidence: meanSimilarity }
     }
   }
 
-  // Max iterations reached
   throw new Error('Max tool iterations reached')
 }
 
@@ -407,7 +432,7 @@ async function buildContext(
   userMessage: string,
   toolResults: ToolResult[],
   ctx: CoreContext
-): Promise<string> {
+): Promise<{ context: string; retrievedSources: any[]; meanSimilarity: number }> {
   const { agent, promptConfig, thread } = config
 
   // 1. System prompt (from agent)
@@ -419,19 +444,30 @@ async function buildContext(
   }
 
   // 3. Retrieved knowledge (RAG)
-  if (promptConfig.knowledge_sources && promptConfig.knowledge_sources.length > 0) {
-    const retrievedDocs = await retrieveKnowledge(
+  // Always attempt retrieval — even with empty knowledge_sources (full scope search)
+  let retrievedSources: any[] = []
+  let meanSimilarity = 0
+  const retrievalPolicy = promptConfig.metadata?.retrieval_policy || {}
+
+  try {
+    const { docs, meanSimilarity: ms } = await retrieveKnowledge(
       userMessage,
-      promptConfig.knowledge_sources,
-      ctx.accountId!
+      promptConfig.knowledge_sources || [],
+      ctx.accountId!,
+      retrievalPolicy
     )
-    if (retrievedDocs.length > 0) {
+    retrievedSources = docs
+    meanSimilarity = ms
+
+    if (docs.length > 0) {
       context += '## Relevant Information\n'
-      retrievedDocs.forEach((doc, i) => {
-        context += `[${i + 1}] ${doc.content}\n`
+      docs.forEach((doc, i) => {
+        const sourceLabel = doc.title ? `[${i + 1}] ${doc.title}` : `[${i + 1}]`
+        context += `${sourceLabel}\n${doc.content}\n\n`
       })
-      context += '\n'
     }
+  } catch (err) {
+    console.warn('retrieveKnowledge failed — proceeding without context:', err)
   }
 
   // 4. Conversation history
@@ -470,7 +506,7 @@ async function buildContext(
   // 7. Current user message
   context += `## Current Message\nUser: ${userMessage}\n\nAssistant: `
 
-  return context
+  return { context, retrievedSources, meanSimilarity }
 }
 
 // ─── KNOWLEDGE & HISTORY ───────────────────────────────────────────────────────────
@@ -505,29 +541,35 @@ async function buildContext(
 async function retrieveKnowledge(
   query: string,
   knowledgeSources: string[],
-  accountId: string
-): Promise<any[]> {
+  accountId: string,
+  retrievalPolicy?: {
+    item_types?: string[]
+    vector_types?: string[]
+    max_security_level?: 'external' | 'internal' | 'restricted'
+    require_approved?: boolean
+  }
+): Promise<{ docs: any[]; meanSimilarity: number }> {
   const SIMILARITY_THRESHOLD = 0.15
   const MATCH_COUNT = 8
+  const policy = retrievalPolicy || {}
+  const vectorTypesToSearch = policy.vector_types?.length ? policy.vector_types : ['semantic']
+  const maxSecurityLevel = policy.max_security_level || 'internal'
+
+  // Security level ordering: external < internal < restricted
+  const SECURITY_ORDER: Record<string, number> = { external: 0, internal: 1, restricted: 2 }
+  const maxSecurityRank = SECURITY_ORDER[maxSecurityLevel] ?? 1
 
   // ── Tier 1: vector similarity via match_embeddings RPC ──────────────────
   try {
     const apiKey = process.env.OPENAI_API_KEY || process.env.LLM_API_KEY
     const baseUrl = process.env.OPENAI_BASE_URL || 'https://api.openai.com/v1'
-
     if (!apiKey) throw new Error('no_api_key')
 
-    // Resolve platform account ID at runtime — no hardcoded UUIDs
+    // Resolve platform account — always include spine-system KB
     const { data: platformAccount } = await adminDb
-      .from('accounts')
-      .select('id')
-      .eq('slug', 'spine-system')
-      .maybeSingle()
-
+      .from('accounts').select('id').eq('slug', 'spine-system').maybeSingle()
     const accountIds: string[] = [accountId]
-    if (platformAccount?.id && platformAccount.id !== accountId) {
-      accountIds.push(platformAccount.id)
-    }
+    if (platformAccount?.id && platformAccount.id !== accountId) accountIds.push(platformAccount.id)
 
     // Generate query embedding
     const embedRes = await fetch(`${baseUrl}/embeddings`, {
@@ -540,29 +582,37 @@ async function retrieveKnowledge(
     const queryEmbedding: number[] = embedJson.data?.[0]?.embedding || []
     if (!queryEmbedding.length) throw new Error('empty_embedding')
 
-    // Call vector RPC
-    const { data: matches, error: rpcError } = await adminDb.rpc('match_embeddings', {
-      query_embedding: `[${queryEmbedding.join(',')}]`,
-      match_count: MATCH_COUNT * 3,
-      filter_account_ids: accountIds,
-      filter_vector_type: 'semantic',
-      similarity_threshold: SIMILARITY_THRESHOLD,
-    })
-    if (rpcError) throw new Error(`rpc_${rpcError.message}`)
+    // Multi-vector search: run all declared vector types and merge
+    const allMatches: any[] = []
+    for (const vt of vectorTypesToSearch) {
+      const { data: matches, error: rpcError } = await adminDb.rpc('match_embeddings', {
+        query_embedding: `[${queryEmbedding.join(',')}]`,
+        match_count: MATCH_COUNT * 3,
+        filter_account_ids: accountIds,
+        filter_vector_type: vt,
+        similarity_threshold: SIMILARITY_THRESHOLD,
+        filter_item_types: policy.item_types?.length ? policy.item_types : null,
+      })
+      if (rpcError) throw new Error(`rpc_${rpcError.message}`)
+      allMatches.push(...(matches || []))
+    }
 
-    // Filter: security_level restriction for cross-account results
-    const filtered = (matches || []).filter((r: any) => {
+    // Hard security filter
+    const filtered = allMatches.filter((r: any) => {
       if (r.similarity < SIMILARITY_THRESHOLD) return false
-      if (r.account_id === accountId) return true
-      return r.metadata?.security_level !== 'restricted'
+      const secLevel = r.metadata?.security_level || 'internal'
+      const rank = SECURITY_ORDER[secLevel] ?? 1
+      if (rank > maxSecurityRank) return false
+      if (r.account_id !== accountId && secLevel === 'restricted') return false
+      return true
     })
 
-    // Optionally narrow to knowledgeSources doc IDs
+    // Narrow to knowledgeSources if specified
     const scoped = knowledgeSources.length > 0
       ? filtered.filter((r: any) => knowledgeSources.includes(r.document_id))
       : filtered
 
-    // Deduplicate — best chunk per document
+    // Deduplicate — best chunk per document across all vector types
     const bestByDoc = new Map<string, any>()
     for (const r of scoped) {
       const existing = bestByDoc.get(r.document_id)
@@ -572,47 +622,66 @@ async function retrieveKnowledge(
       .sort((a, b) => b.similarity - a.similarity)
       .slice(0, MATCH_COUNT)
 
-    if (deduped.length === 0) return []
+    if (!deduped.length) return { docs: [], meanSimilarity: 0 }
+
+    // If top result < 0.50 and summary not already included, try summary fallback
+    if (deduped[0]?.similarity < 0.50 && !vectorTypesToSearch.includes('summary')) {
+      const { data: summaryMatches } = await adminDb.rpc('match_embeddings', {
+        query_embedding: `[${queryEmbedding.join(',')}]`,
+        match_count: MATCH_COUNT,
+        filter_account_ids: accountIds,
+        filter_vector_type: 'summary',
+        similarity_threshold: SIMILARITY_THRESHOLD,
+        filter_item_types: policy.item_types?.length ? policy.item_types : null,
+      })
+      for (const r of summaryMatches || []) {
+        if (!bestByDoc.has(r.document_id) && r.similarity >= SIMILARITY_THRESHOLD) {
+          bestByDoc.set(r.document_id, r)
+        }
+      }
+    }
+    const finalDocs = [...bestByDoc.values()]
+      .sort((a, b) => b.similarity - a.similarity)
+      .slice(0, MATCH_COUNT)
 
     // Enrich with item titles
     const { data: items } = await adminDb
-      .from('items')
-      .select('id, title, description')
-      .in('id', deduped.map((r: any) => r.document_id))
-
+      .from('items').select('id, title').in('id', finalDocs.map((r: any) => r.document_id))
     const itemMap = new Map((items || []).map((i: any) => [i.id, i]))
-    return deduped.map((r: any) => ({
+
+    const docs = finalDocs.map((r: any) => ({
       document_id: r.document_id,
       content: r.content,
       metadata: r.metadata,
       similarity: r.similarity,
       title: itemMap.get(r.document_id)?.title || '',
+      item_type: r.metadata?.item_type || '',
+      vector_type: r.metadata?.vector_type || '',
     }))
 
+    const meanSimilarity = docs.length
+      ? docs.reduce((sum: number, d: any) => sum + d.similarity, 0) / docs.length
+      : 0
+
+    return { docs, meanSimilarity }
+
   } catch (vectorErr: any) {
     // ── Tier 2: full-text fallback ──────────────────────────────────────
     if (vectorErr.message !== 'no_api_key') {
       console.warn('retrieveKnowledge vector search failed, falling back to text search:', vectorErr.message)
     }
-
     const baseQuery = adminDb
       .from('embeddings')
       .select('document_id, content, metadata, account_id')
       .eq('account_id', accountId)
       .eq('metadata->>vector_type', 'semantic')
+      .not('revoked_at', 'is', null)
       .textSearch('content', query, { type: 'websearch', config: 'english' })
       .limit(5)
-
-    const q = knowledgeSources.length > 0
-      ? baseQuery.in('document_id', knowledgeSources)
-      : baseQuery
-
+    const q = knowledgeSources.length > 0 ? baseQuery.in('document_id', knowledgeSources) : baseQuery
     const { data: docs, error } = await q
-    if (error) {
-      console.error('Knowledge retrieval fallback failed:', error)
-      return []
-    }
-    return docs || []
+    if (error) { console.error('Knowledge retrieval fallback failed:', error); return { docs: [], meanSimilarity: 0 } }
+    return { docs: docs || [], meanSimilarity: 0 }
   }
 }
 

package/.framework/functions/_shared/pipeline-runner.ts

@@ -626,7 +626,37 @@ const stageHandlers: Record<string, Function> = {
       metadata: { mock: true },
       model: model || 'gpt-4o'
     }
-  }
+  },
+
+  // ── generate_embeddings ─────────────────────────────────────────────────────
+  // Generates embeddings for an item using the core embeddings.generate action.
+  // Supports {{trigger.entity_id}} template interpolation in config.item_id.
+  //
+  // Config: item_id (required — supports {{trigger.entity_id}}),
+  //         force_regenerate (bool, default false)
+  //
+  // Called by the auto_embed_on_publish and auto_revoke_on_unpublish pipelines.
+  'generate_embeddings': async (ctx: CoreContext, config: any) => {
+    const triggerData = config._triggerData || {}
+    let itemId = config.item_id
+    if (!itemId) throw new Error('item_id is required for generate_embeddings')
+
+    // Template interpolation: {{trigger.entity_id}} or {{entity_id}}
+    if (typeof itemId === 'string' && itemId.includes('{{')) {
+      itemId = itemId
+        .replace(/\{\{trigger\.entity_id\}\}/g, triggerData?.entity_id || '')
+        .replace(/\{\{entity_id\}\}/g, triggerData?.entity_id || '')
+    }
+
+    if (!itemId) throw new Error('generate_embeddings: could not resolve item_id from trigger data')
+
+    const { generate } = await import('../embeddings')
+    const genCtx = { ...ctx, query: { ...(ctx.query || {}), action: 'generate' } }
+    return await generate(genCtx, {
+      item_id: itemId,
+      force_regenerate: config.force_regenerate ?? false,
+    })
+  },
 }
 
 // ─── MODULE DISPATCHERS ────────────────────────────────────────────────────────────

package/.framework/functions/ai-interactions.ts

@@ -0,0 +1,240 @@
+/**
+ * @module ai-interactions
+ * @audience both
+ * @layer api-handler
+ * @stability stable
+ *
+ * Feedback capture and training data API for the AI-first support loop.
+ * Every AI↔human exchange produces a structured interaction record so the
+ * platform can measure loop health, drive KB creation, and accumulate a
+ * proprietary training dataset.
+ *
+ * **Routed by:** `GET/POST/PATCH /.netlify/functions/ai-interactions`
+ *
+ * **Actions:**
+ * | method | ?action                  | handler                  |
+ * |--------|--------------------------|--------------------------|
+ * | POST   | submit_feedback          | submitFeedback           |
+ * | POST   | create_interaction       | createInteraction        |
+ * | PATCH  | update_interaction       | updateInteraction        |
+ * | GET    | list                     | list                     |
+ * | GET    | metrics                  | metrics                  |
+ *
+ * INVARIANT: All writes go through admin-data — no direct DB writes here.
+ * INVARIANT: `submit_feedback` not_helpful triggers ticket escalation
+ *   by updating ticket status to human_assigned.
+ *
+ * @seeAlso agent-runner.ts (populates messages.data.retrieved_sources)
+ * @seeAlso custom/portal/hooks/useTickets.ts (calls submit_feedback)
+ * @seeAlso custom/cortex/functions/custom_case_analysis.ts (calls create_interaction)
+ */
+
+import { createHandler } from './_shared/middleware'
+import { adminDb } from './_shared/db'
+import { resolveTypeId } from './_shared/resolve-ids'
+import { create, update } from './admin-data'
+import { emitLog } from './_shared/audit'
+
+// ─── SUBMIT FEEDBACK ─────────────────────────────────────────────────────────
+/**
+ * Records customer helpful / not_helpful feedback on an AI message.
+ *
+ * - Stamps messages.data.feedback
+ * - If not_helpful: updates ticket to human_assigned + stamps escalation reason
+ * - Updates the matching ai_feedback_record if one exists for this message
+ *
+ * Body: message_id (required), ticket_id (required), feedback ('helpful' | 'not_helpful')
+ */
+export const submitFeedback = createHandler(async (ctx, body) => {
+  const { message_id, ticket_id, feedback } = body || {}
+  if (!message_id) throw new Error('message_id is required')
+  if (!ticket_id)  throw new Error('ticket_id is required')
+  if (!['helpful', 'not_helpful'].includes(feedback)) {
+    throw new Error('feedback must be "helpful" or "not_helpful"')
+  }
+
+  // Stamp feedback on the message — load existing data to merge safely
+  const { data: msg } = await adminDb
+    .from('messages').select('data').eq('id', message_id).single()
+  if (msg) {
+    await adminDb
+      .from('messages')
+      .update({ data: { ...(msg.data || {}), feedback } })
+      .eq('id', message_id)
+  }
+
+  // If not_helpful: escalate the ticket to human support
+  if (feedback === 'not_helpful' && ticket_id) {
+    const { data: ticket } = await adminDb
+      .from('items').select('status, data').eq('id', ticket_id).single()
+    if (ticket && ticket.status !== 'human_assigned' && ticket.status !== 'resolved') {
+      await adminDb
+        .from('items')
+        .update({
+          status: 'human_assigned',
+          data: { ...(ticket.data || {}), aim_escalation_reason: 'thumbs_down' },
+          updated_at: new Date().toISOString(),
+        })
+        .eq('id', ticket_id)
+    }
+  }
+
+  // Best-effort: update matching ai_feedback_record customer_feedback field
+  const { data: interactionRows } = await adminDb
+    .from('items')
+    .select('id, data')
+    .contains('data', { ai_message_id: message_id })
+    .limit(1)
+  if (interactionRows?.length) {
+    const interaction = interactionRows[0]
+    await adminDb
+      .from('items')
+      .update({ data: { ...(interaction.data || {}), customer_feedback: feedback } })
+      .eq('id', interaction.id)
+  }
+
+  await emitLog(ctx, 'ai_interaction.feedback_submitted',
+    { type: 'message', id: message_id },
+    { after: { feedback, ticket_id, escalated: feedback === 'not_helpful' } }
+  )
+
+  return { message_id, ticket_id, feedback, escalated: feedback === 'not_helpful' }
+})
+
+// ─── CREATE INTERACTION ───────────────────────────────────────────────────────
+/**
+ * Creates an ai_feedback_record item capturing a full AI↔human exchange.
+ * Called by the capture_ai_interaction pipeline after each agent message.
+ *
+ * Body: thread_id, ai_message_id, retrieved_sources, ai_confidence,
+ *       retrieval_confidence, kb_candidate (optional)
+ */
+export const createInteraction = createHandler(async (ctx, body) => {
+  const {
+    thread_id, ai_message_id, retrieved_sources = [],
+    ai_confidence, retrieval_confidence, kb_candidate
+  } = body || {}
+
+  if (!thread_id && !ai_message_id) {
+    throw new Error('thread_id or ai_message_id is required')
+  }
+
+  // Resolve the ai_feedback_record type — it lives in the cortex/portal app seeds
+  let typeId: string | null = null
+  try {
+    typeId = await resolveTypeId('item', 'ai_feedback_record')
+  } catch {
+    // Type not yet seeded — skip creation gracefully
+    return { skipped: true, reason: 'ai_feedback_record type not found' }
+  }
+  if (!typeId) return { skipped: true, reason: 'ai_feedback_record type not found' }
+
+  const record = await create(ctx, {
+    entity: 'items',
+    type_id: typeId,
+    title: `AI Interaction — ${new Date().toISOString().slice(0, 10)}`,
+    status: 'active',
+    data: {
+      thread_id:            thread_id || null,
+      ai_message_id:        ai_message_id || null,
+      human_message_id:     null,
+      retrieved_sources:    retrieved_sources,
+      ai_confidence:        ai_confidence ?? null,
+      retrieval_confidence: retrieval_confidence ?? null,
+      human_edits_made:     false,
+      customer_feedback:    null,
+      kb_candidate:         kb_candidate ?? null,
+      kb_article_id:        null,
+      reuse_count:          0,
+    },
+  })
+
+  return record
+})
+
+// ─── UPDATE INTERACTION ───────────────────────────────────────────────────────
+/**
+ * Patches an existing ai_feedback_record.
+ * Used to:
+ * - Link the KB article once a feedback record's question is promoted
+ * - Increment reuse_count when a similar question is AI-answered
+ * - Record human_message_id and human_edits_made after resolution
+ *
+ * Body: id (required), plus any of: kb_article_id, reuse_count,
+ *       human_message_id, human_edits_made, customer_feedback
+ */
+export const updateInteraction = createHandler(async (ctx, body) => {
+  const { id, ...fields } = body || {}
+  if (!id) throw new Error('id is required')
+
+  const allowed = ['kb_article_id', 'human_message_id', 'human_edits_made',
+                   'customer_feedback', 'kb_candidate', 'reuse_count']
+  const patch: Record<string, any> = {}
+  for (const key of allowed) {
+    if (fields[key] !== undefined) patch[key] = fields[key]
+  }
+
+  if (!Object.keys(patch).length) throw new Error('No updatable fields provided')
+
+  // Load existing data then merge
+  const { data: existing } = await adminDb
+    .from('items').select('data').eq('id', id).single()
+  if (!existing) throw new Error('Interaction record not found')
+
+  return update(
+    { ...ctx, query: { ...(ctx.query || {}), entity: 'items', id } } as any,
+    { data: { ...(existing.data || {}), ...patch } }
+  )
+})
+
+// ─── LIST ─────────────────────────────────────────────────────────────────────
+/**
+ * Lists ai_feedback_record items for the current account.
+ * Supports filtering by: feedback, kb_candidate, date_from, date_to
+ */
+export const list = createHandler(async (ctx, _body) => {
+  const { feedback, kb_candidate, limit = '50', offset = '0' } = ctx.query || {}
+
+  let q = ctx.db
+    .from('items')
+    .select('*')
+    .eq('account_id', ctx.accountId)
+    .order('created_at', { ascending: false })
+    .range(Number(offset), Number(offset) + Number(limit) - 1)
+
+  if (feedback) q = q.eq('data->>customer_feedback', feedback)
+  if (kb_candidate !== undefined) q = q.eq('data->>kb_candidate', kb_candidate)
+
+  // Filter to ai_feedback_record type only
+  const { data: typeRow } = await adminDb
+    .from('types').select('id').eq('slug', 'ai_feedback_record').eq('kind', 'item').maybeSingle()
+  if (typeRow?.id) q = q.eq('type_id', typeRow.id)
+
+  const { data, error } = await q
+  if (error) throw error
+  return data || []
+})
+
+// ─── HANDLER ─────────────────────────────────────────────────────────────────
+
+export const handler = createHandler(async (ctx, body) => {
+  const { action } = ctx.query || {}
+  const method = ctx.query?.method || 'GET'
+
+  switch (action) {
+    case 'submit_feedback':
+      if (method === 'POST') return await submitFeedback(ctx, body)
+      break
+    case 'create_interaction':
+      if (method === 'POST') return await createInteraction(ctx, body)
+      break
+    case 'update_interaction':
+      if (method === 'PATCH' || method === 'POST') return await updateInteraction(ctx, body)
+      break
+    case 'list':
+    default:
+      if (method === 'GET') return await list(ctx, body)
+  }
+
+  throw new Error('Invalid action or method')
+})