spine-framework-cortex 0.2.20 → 0.2.22

package/functions/custom_kb-embeddings.ts

@@ -0,0 +1,579 @@
+import { createHandler } from './_shared/middleware'
+import { adminDb } from './_shared/db'
+import { chunkArticle, htmlToPlainText } from './custom_kb-chunker'
+
+interface KBEmbeddingRequest {
+  item_id: string
+  vector_types: ('semantic' | 'structure' | 'summary' | 'code')[]
+  force_regenerate?: boolean
+}
+
+interface KBEmbeddingResponse {
+  success: boolean
+  embeddings_created: number
+  embeddings_updated: number
+  errors: string[]
+}
+
+// Generate semantic embedding (full content)
+function decodeHtmlContent(html: string): string {
+  return html
+    .replace(/<[^>]+>/g, ' ')
+    .replace(/&lt;/g, '<')
+    .replace(/&gt;/g, '>')
+    .replace(/&amp;/g, '&')
+    .replace(/&quot;/g, '"')
+    .replace(/&#39;/g, "'")
+    .replace(/\s+/g, ' ')
+    .trim()
+}
+
+// Build semantic content from structured code_metadata — developer understanding focus
+function buildSemanticContent(item: any): string {
+  const cm = item.data?.code_metadata || {}
+  const inputs = cm.inputs && Object.keys(cm.inputs).length > 0
+    ? 'Parameters: ' + Object.entries(cm.inputs).map(([k, v]) => `${k} (${v})`).join(', ')
+    : ''
+  const deps = cm.depends_on && cm.depends_on.length > 0
+    ? 'Depends on: ' + cm.depends_on.join(', ')
+    : ''
+  const sideEffects = cm.side_effects && cm.side_effects.length > 0
+    ? 'Side effects: ' + cm.side_effects.join(', ')
+    : ''
+
+  return [
+    cm.identifier || item.title || '',
+    cm.macro || '',
+    cm.micro || '',
+    inputs,
+    cm.outputs ? `Returns: ${cm.outputs}` : '',
+    deps,
+    sideEffects,
+    `Tags: ${(item.data?.tags || []).join(', ')}`,
+    cm.file_path ? `File: ${cm.file_path} lines ${cm.line_start}-${cm.line_end}` : ''
+  ].filter(Boolean).join('\n')
+}
+
+// Build structure content from metadata — for filtering/faceted search
+function buildStructureContent(item: any): string {
+  const cm = item.data?.code_metadata || {}
+  return JSON.stringify({
+    identifier: cm.identifier || '',
+    chunk_type: cm.chunk_type || '',
+    file_path: cm.file_path || '',
+    line_start: cm.line_start,
+    line_end: cm.line_end,
+    version: cm.version || '',
+    tags: item.data?.tags || [],
+    depends_on: cm.depends_on || [],
+    depended_by: cm.depended_by || [],
+    inputs: Object.keys(cm.inputs || {}),
+    has_side_effects: (cm.side_effects || []).length > 0
+  })
+}
+
+// Generate real embedding vector via OpenAI text-embedding-3-small (single input)
+async function generateEmbeddingVector(content: string): Promise<string> {
+  const vectors = await generateEmbeddingBatch([content])
+  return vectors[0]
+}
+
+// Batch-generate embedding vectors — one API call for multiple inputs
+async function generateEmbeddingBatch(inputs: string[]): Promise<string[]> {
+  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 OPENAI_API_KEY configured — cannot generate embeddings')
+  }
+
+  if (inputs.length === 0) return []
+
+  const res = await fetch(`${baseUrl}/embeddings`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${apiKey}` },
+    body: JSON.stringify({
+      model: 'text-embedding-3-small',
+      input: inputs,
+    }),
+  })
+
+  if (!res.ok) {
+    const err = await res.text()
+    throw new Error(`OpenAI embeddings error ${res.status}: ${err.slice(0, 200)}`)
+  }
+
+  const result: any = await res.json()
+  // OpenAI returns embeddings sorted by index
+  const sorted = (result.data || []).sort((a: any, b: any) => a.index - b.index)
+  return sorted.map((d: any) => `[${d.embedding.join(',')}]`)
+}
+
+// Resolve platform account ID at runtime (slug: 'spine-system')
+let _platformAccountId: string | null = null
+async function getPlatformAccountId(): Promise<string | null> {
+  if (_platformAccountId) return _platformAccountId
+  const { data } = await adminDb.from('accounts').select('id').eq('slug', 'spine-system').maybeSingle()
+  _platformAccountId = data?.id ?? null
+  return _platformAccountId
+}
+
+// Insert an embedding record (used during batch writes)
+async function insertEmbedding(
+  itemId: string,
+  vectorType: string,
+  chunkIndex: number,
+  content: string,
+  embedding: string,
+  metadata: any,
+  accountId?: string
+): Promise<void> {
+  const resolvedAccountId = accountId ?? await getPlatformAccountId()
+  await adminDb
+    .from('embeddings')
+    .insert({
+      account_id: resolvedAccountId,
+      model_id: 'text-embedding-3-small',
+      document_id: itemId,
+      chunk_index: chunkIndex,
+      content: content,
+      embedding: embedding,
+      metadata: {
+        vector_type: vectorType,
+        item_type: 'kb_article',
+        ...metadata
+      }
+    })
+}
+
+// Generate a one-paragraph AI summary for top-level retrieval matching
+async function generateArticleSummary(item: any): Promise<string> {
+  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) return `${item.title || ''}: ${(item.description || '').slice(0, 300)}`
+
+  const plainText = (item.description || '')
+    .replace(/<[^>]+>/g, ' ').replace(/\s+/g, ' ').trim().slice(0, 3000)
+
+  const res = await fetch(`${baseUrl}/chat/completions`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${apiKey}` },
+    body: JSON.stringify({
+      model: process.env.LLM_DEFAULT_MODEL || 'gpt-4o-mini',
+      temperature: 0.2,
+      max_tokens: 120,
+      messages: [
+        { role: 'system', content: 'Write a single concise paragraph (max 100 words) summarising this knowledge base article for search indexing. Output only the paragraph.' },
+        { role: 'user', content: `Title: ${item.title}\n\n${plainText}` }
+      ]
+    })
+  })
+  if (!res.ok) return `${item.title}: ${plainText.slice(0, 200)}`
+  const result: any = await res.json()
+  return result.choices?.[0]?.message?.content?.trim() || `${item.title}: ${plainText.slice(0, 200)}`
+}
+
+// Delete all existing embeddings for a document (called before re-embedding)
+async function deleteExistingEmbeddings(itemId: string): Promise<number> {
+  const { data } = await adminDb
+    .from('embeddings')
+    .delete()
+    .eq('document_id', itemId)
+    .eq('metadata->>item_type', 'kb_article')
+    .select('id')
+
+  return data?.length || 0
+}
+
+// Build article-level structure content for non-code articles
+function buildArticleStructureContent(item: any): string {
+  return JSON.stringify({
+    title: item.title || '',
+    kb_type: item.data?.kb_type || '',
+    category: item.data?.category || '',
+    tags: item.data?.tags || [],
+    audience: item.data?.audience || [],
+    security_level: item.data?.security_level || '',
+    priority: item.data?.priority || '',
+  })
+}
+
+// Determine if an item is a code chunk (ingested) vs a manual article
+function isCodeChunk(item: any): boolean {
+  return !!(item.data?.code_metadata?.chunk_id || item.data?.code_metadata?.file_path)
+}
+
+// Main handler for generating KB embeddings
+async function handleGenerateEmbeddings(
+  itemId: string,
+  vectorTypes: string[],
+  forceRegenerate: boolean = false,
+  overrideAccountId?: string
+): Promise<KBEmbeddingResponse> {
+  const response: KBEmbeddingResponse = {
+    success: true,
+    embeddings_created: 0,
+    embeddings_updated: 0,
+    errors: []
+  }
+
+  try {
+    // Get the KB item — allow any type when called from case resolution path
+    const { data: item, error: itemError } = await adminDb
+      .from('items')
+      .select('*')
+      .eq('id', itemId)
+      .single()
+
+    if (itemError || !item) {
+      throw new Error('Item not found for embedding')
+    }
+
+    // Resolve account: caller override > item's own account > platform account
+    const accountId = overrideAccountId || item.account_id || await getPlatformAccountId()
+
+    // Check if embeddings already exist
+    if (!forceRegenerate) {
+      const { data: existing } = await adminDb
+        .from('embeddings')
+        .select('id')
+        .eq('document_id', itemId)
+        .eq('metadata->>item_type', 'kb_article')
+        .limit(1)
+
+      if (existing && existing.length > 0) {
+        response.errors.push('Embeddings already exist (use force_regenerate to override)')
+        response.success = false
+        return response
+      }
+    }
+
+    // Delete existing embeddings before regenerating
+    const deleted = await deleteExistingEmbeddings(itemId)
+    if (deleted > 0) {
+      response.embeddings_updated = deleted
+    }
+
+    // ── Code chunks: legacy path (semantic + structure) ──
+    if (isCodeChunk(item)) {
+      const semanticContent = buildSemanticContent(item)
+      const structureContent = buildStructureContent(item)
+
+      const vectors = await generateEmbeddingBatch([semanticContent, structureContent])
+
+      await Promise.all([
+        insertEmbedding(itemId, 'semantic', 0, semanticContent, vectors[0], {
+          kb_type: item.data?.kb_type,
+          chunk_id: item.data?.code_metadata?.chunk_id,
+          chunk_type: item.data?.code_metadata?.chunk_type,
+          file_path: item.data?.code_metadata?.file_path,
+        }, accountId),
+        insertEmbedding(itemId, 'structure', 0, structureContent, vectors[1], {
+          kb_type: item.data?.kb_type,
+          tags: item.data?.tags,
+          file_path: item.data?.code_metadata?.file_path,
+          depends_on: item.data?.code_metadata?.depends_on,
+        }, accountId),
+      ])
+
+      response.embeddings_created = 2
+      return response
+    }
+
+    // ── Article path: semantic chunks + structure + summary ──
+    const articleContent = item.description || ''
+    const chunks = chunkArticle(articleContent, { articleTitle: item.title || 'Untitled' })
+
+    const structureContent = buildArticleStructureContent(item)
+
+    // Generate AI summary for top-level retrieval matching
+    const summaryContent = await generateArticleSummary(item)
+
+    // Single batched embed: N semantic chunks + 1 structure + 1 summary
+    const allTexts = [...chunks.map(c => c.content), structureContent, summaryContent]
+    const allVectors = await generateEmbeddingBatch(allTexts)
+
+    const writePromises: Promise<void>[] = []
+
+    // Semantic embeddings — one per chunk
+    for (let i = 0; i < chunks.length; i++) {
+      writePromises.push(
+        insertEmbedding(itemId, 'semantic', i, chunks[i].content, allVectors[i], {
+          kb_type: item.data?.kb_type,
+          chunk_index: i,
+          chunk_total: chunks.length,
+          section_path: chunks[i].sectionPath,
+          security_level: item.data?.security_level,
+        }, accountId)
+      )
+    }
+
+    // Structure embedding — facets for filtering
+    writePromises.push(
+      insertEmbedding(itemId, 'structure', 0, structureContent, allVectors[chunks.length], {
+        kb_type: item.data?.kb_type,
+        tags: item.data?.tags,
+        category: item.data?.category,
+        audience: item.data?.audience,
+        security_level: item.data?.security_level,
+      }, accountId)
+    )
+
+    // Summary embedding — one-paragraph AI summary for top-level matching
+    writePromises.push(
+      insertEmbedding(itemId, 'summary', 0, summaryContent, allVectors[chunks.length + 1], {
+        kb_type: item.data?.kb_type,
+        security_level: item.data?.security_level,
+      }, accountId)
+    )
+
+    await Promise.all(writePromises)
+    response.embeddings_created = chunks.length + 2 // +2 for structure + summary
+
+  } catch (error) {
+    response.success = false
+    response.errors = [error instanceof Error ? error.message : String(error)]
+  }
+
+  return response
+}
+
+/**
+ * Embeds a resolved ticket's case data as a knowledge source for future triage RAG.
+ * Called automatically when a ticket is resolved (via case analysis completion).
+ *
+ * Stores two vectors:
+ *   - 'semantic': ca_true_problem + ca_final_solution (the actual answer)
+ *   - 'summary': ca_reported_issue (how the customer described it — improves matching)
+ *
+ * These are stored with item_type: 'resolved_case' so they can be included in
+ * triage agent knowledge_sources without polluting the main KB article pool.
+ */
+export async function embedResolvedCase(ticketId: string, accountId: string): Promise<void> {
+  // Load ticket data fields
+  const { data: ticket } = await adminDb
+    .from('items')
+    .select('id, title, data')
+    .eq('id', ticketId)
+    .single()
+
+  if (!ticket) return
+
+  const trueProb = ticket.data?.ca_true_problem || ''
+  const finalSol = ticket.data?.ca_final_solution || ''
+  const reportedIssue = ticket.data?.ca_reported_issue || ticket.title || ''
+
+  if (!trueProb && !finalSol) return // nothing to embed
+
+  // Delete any pre-existing resolved_case embeddings for this ticket
+  await adminDb
+    .from('embeddings')
+    .delete()
+    .eq('document_id', ticketId)
+    .eq('metadata->>item_type', 'resolved_case')
+
+  const semanticContent = `Problem: ${trueProb}\n\nSolution: ${finalSol}`
+  const summaryContent = `Customer reported: ${reportedIssue}`
+
+  try {
+    const vectors = await generateEmbeddingBatch([semanticContent, summaryContent])
+    await Promise.all([
+      insertEmbedding(ticketId, 'semantic', 0, semanticContent, vectors[0], {
+        item_type: 'resolved_case',
+        security_level: 'internal',
+        kb_candidate: ticket.data?.ca_kb_candidate ?? false,
+        automation_potential: ticket.data?.ca_automation_potential ?? 'unknown',
+      }, accountId),
+      insertEmbedding(ticketId, 'summary', 0, summaryContent, vectors[1], {
+        item_type: 'resolved_case',
+        security_level: 'internal',
+      }, accountId),
+    ])
+  } catch (err) {
+    // Best-effort: don't fail ticket resolution if embedding fails
+    console.error(`embedResolvedCase failed for ticket ${ticketId}:`, err)
+  }
+}
+
+// Generate embedding vector for a query string via OpenAI
+async function generateQueryEmbedding(text: string): Promise<number[]> {
+  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 OPENAI_API_KEY configured — vector search unavailable')
+  }
+
+  const res = await fetch(`${baseUrl}/embeddings`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${apiKey}` },
+    body: JSON.stringify({
+      model: 'text-embedding-3-small',
+      input: text,
+    }),
+  })
+
+  if (!res.ok) {
+    const err = await res.text()
+    throw new Error(`OpenAI embeddings error ${res.status}: ${err.slice(0, 200)}`)
+  }
+
+  const result: any = await res.json()
+  return result.data?.[0]?.embedding || []
+}
+
+// Platform KB account
+const KB_PLATFORM_ACCOUNT_ID = '12acec9b-8451-40e7-80d5-e80c4e2fc0de'
+
+// Search embeddings via vector similarity
+async function handleSearchEmbeddings(
+  query: string,
+  accountId: string | null,
+  vectorType: string = 'semantic',
+  limit: number = 8
+): Promise<any[]> {
+  if (!query || query.trim().length < 2) return []
+
+  // Generate embedding for the search query
+  const queryEmbedding = await generateQueryEmbedding(query.trim())
+
+  // Build account filter: user's account + platform KB
+  const accountIds = accountId
+    ? [accountId, KB_PLATFORM_ACCOUNT_ID]
+    : [KB_PLATFORM_ACCOUNT_ID]
+
+  // Call the match_embeddings RPC — fetch extra to account for chunk deduplication
+  const { data: matches, error } = await adminDb.rpc('match_embeddings', {
+    query_embedding: queryEmbedding,
+    match_count: limit * 3,
+    filter_account_ids: accountIds,
+    filter_vector_type: vectorType,
+    similarity_threshold: 0.15,
+  })
+
+  if (error) throw new Error(`Vector search failed: ${error.message}`)
+
+  // Filter by similarity threshold + restricted cross-account results
+  const SIMILARITY_THRESHOLD = 0.15
+  const filtered = (matches || []).filter((r: any) => {
+    if (r.similarity < SIMILARITY_THRESHOLD) return false
+    if (r.account_id === accountId) return true
+    return r.metadata?.security_level !== 'restricted'
+  })
+
+  // Deduplicate by document_id — keep only the best-matching chunk per article
+  const bestByDoc = new Map<string, any>()
+  for (const r of filtered) {
+    const existing = bestByDoc.get(r.document_id)
+    if (!existing || r.similarity > existing.similarity) {
+      bestByDoc.set(r.document_id, r)
+    }
+  }
+  const deduped = [...bestByDoc.values()]
+    .sort((a, b) => b.similarity - a.similarity)
+    .slice(0, limit)
+
+  // Enrich with item title from the items table
+  const docIds = deduped.map((r: any) => r.document_id)
+  if (docIds.length === 0) return []
+
+  const { data: items } = await adminDb
+    .from('items')
+    .select('id, title, description, status, data')
+    .in('id', docIds)
+
+  const itemMap = new Map((items || []).map((i: any) => [i.id, i]))
+
+  return deduped.map((r: any) => {
+    const item = itemMap.get(r.document_id)
+    return {
+      id: r.document_id,
+      title: item?.title || '',
+      description: item?.description || '',
+      status: item?.status || '',
+      data: item?.data || {},
+      similarity: r.similarity,
+      matched_section: r.metadata?.section_path || null,
+    }
+  })
+}
+
+// Delete embeddings for an item
+async function handleDeleteEmbeddings(itemId: string): Promise<{ deleted: number }> {
+  const { data, error } = await adminDb
+    .from('embeddings')
+    .delete()
+    .eq('document_id', itemId)
+    .eq('metadata->>item_type', 'kb_article')
+
+  if (error) throw error
+
+  return { deleted: data?.length || 0 }
+}
+
+export const handler = createHandler(async (ctx: any, body: any) => {
+  const { action } = ctx.query || {}
+  const method = ctx.query?.method || 'POST'
+
+  switch (action) {
+    case 'generate':
+      if (method === 'POST') {
+        const ids: string[] = body.item_ids || (body.item_id ? [body.item_id] : [])
+        let totalCreated = 0, totalUpdated = 0
+        const allErrors: string[] = []
+        for (const id of ids) {
+          const r = await handleGenerateEmbeddings(id, body.vector_types, body.force_regenerate)
+          totalCreated += r.embeddings_created
+          totalUpdated += r.embeddings_updated
+          allErrors.push(...r.errors)
+        }
+        return {
+          success: allErrors.length === 0 || totalCreated > 0 || totalUpdated > 0,
+          embeddings_created: totalCreated,
+          embeddings_updated: totalUpdated,
+          errors: allErrors
+        }
+      }
+      break
+    
+    case 'search':
+      if (method === 'GET' || method === 'POST') {
+        const q = body.query || ctx.query?.q || ''
+        const acctId = body.account_id || ctx.principal?.account_id || null
+        return await handleSearchEmbeddings(
+          q,
+          acctId,
+          body.vector_type || 'semantic',
+          body.limit || 8
+        )
+      }
+      break
+    
+    case 'delete':
+      if (method === 'DELETE' || method === 'POST') {
+        return await handleDeleteEmbeddings(body.item_id)
+      }
+      break
+    
+    default:
+      if (method === 'POST') {
+        const ids: string[] = body.item_ids || (body.item_id ? [body.item_id] : [])
+        let totalCreated = 0, totalUpdated = 0
+        const allErrors: string[] = []
+        for (const id of ids) {
+          const r = await handleGenerateEmbeddings(id, body.vector_types, body.force_regenerate)
+          totalCreated += r.embeddings_created
+          totalUpdated += r.embeddings_updated
+          allErrors.push(...r.errors)
+        }
+        return {
+          success: allErrors.length === 0 || totalCreated > 0 || totalUpdated > 0,
+          embeddings_created: totalCreated,
+          embeddings_updated: totalUpdated,
+          errors: allErrors
+        }
+      }
+  }
+
+  throw new Error('Invalid action or method')
+})

package/functions/custom_support-redaction.ts

@@ -0,0 +1,115 @@
+import { createHandler } from './_shared/middleware'
+import { adminDb } from './_shared/db'
+import { resolveTypeId, resolveAgentId, resolvePromptConfigId } from './_shared/resolve-ids'
+import { runAgent } from './_shared/index'
+import { create } from './admin-data'
+
+/**
+ * @module custom_support-redaction
+ * @layer custom/cortex
+ * @stability custom
+ *
+ * KB Redaction Analysis — drives the RedactionReview page.
+ * Runs content through the KB Redaction Agent and returns structured
+ * redaction suggestions + a generalised rewrite ready for human review.
+ *
+ * Action: POST ?action=analyze
+ *   body: { ticket_id: string, content: string }
+ *
+ * Response: { analysis: RedactionAnalysis }
+ *   RedactionAnalysis matches the shape expected by RedactionReview.tsx:
+ *   {
+ *     original_content: string
+ *     redacted_content: string
+ *     suggestions: RedactionSuggestion[]
+ *     confidence_score: number
+ *     processing_metadata: { model_used, temperature, tokens_consumed }
+ *   }
+ *
+ * The agent message is saved in an internal analysis thread on the ticket
+ * (thread_purpose: 'redaction_analysis') as an audit trail.
+ */
+
+async function handleAnalyze(ctx: any, body: any) {
+  const { ticket_id, content } = body
+  if (!ticket_id) throw new Error('ticket_id is required')
+  if (!content) throw new Error('content is required')
+
+  const [threadTypeId, agentId, promptConfigId] = await Promise.all([
+    resolveTypeId('thread', 'thread'),
+    resolveAgentId('KB Redaction Agent'),
+    resolvePromptConfigId('kb_generator'),
+  ])
+
+  // Reuse existing redaction thread if one exists (idempotent re-analysis)
+  const { data: existing } = await adminDb
+    .from('threads')
+    .select('id')
+    .eq('target_type', 'items')
+    .eq('target_id', ticket_id)
+    .eq('visibility', 'internal')
+    .eq('data->>thread_purpose', 'redaction_analysis')
+    .maybeSingle()
+
+  let threadId = existing?.id
+
+  if (!threadId) {
+    const thread = await create(ctx, {
+      entity: 'threads',
+      type_id: threadTypeId,
+      target_type: 'items',
+      target_id: ticket_id,
+      visibility: 'internal',
+      status: 'active',
+      data: {
+        thread_purpose: 'redaction_analysis',
+        agent_id: agentId,
+        prompt_config_id: promptConfigId,
+      }
+    })
+    if (!thread?.id) throw new Error('Failed to create redaction thread')
+    threadId = thread.id
+  }
+
+  // Run the KB Redaction Agent — returns structured JSON in message content
+  const agentMsg = await runAgent(threadId, content, ctx)
+
+  // Parse JSON from agent response
+  let analysis: any = null
+  try {
+    const raw = agentMsg?.content || '{}'
+    const cleaned = raw.replace(/^```(?:json)?\s*/i, '').replace(/\s*```$/, '').trim()
+    analysis = JSON.parse(cleaned)
+  } catch {
+    // If the agent didn't return valid JSON, return a minimal analysis
+    // so the UI can still proceed with the original content unredacted
+    analysis = {
+      original_content: content,
+      redacted_content: content,
+      suggestions: [],
+      confidence_score: 0.0,
+      processing_metadata: {
+        model_used: 'unknown',
+        temperature: 0.1,
+        tokens_consumed: 0,
+        error: 'Agent response was not valid JSON',
+      }
+    }
+  }
+
+  // Ensure required fields are present for RedactionReview.tsx
+  if (!analysis.original_content) analysis.original_content = content
+  if (!analysis.suggestions) analysis.suggestions = []
+  if (typeof analysis.confidence_score !== 'number') analysis.confidence_score = 0.5
+  if (!analysis.processing_metadata) analysis.processing_metadata = { model_used: 'unknown', temperature: 0.1, tokens_consumed: 0 }
+
+  return { analysis, analysisThreadId: threadId }
+}
+
+export const handler = createHandler(async (ctx, body) => {
+  const action = (ctx as any).query?.action
+  switch (action) {
+    case 'analyze': return handleAnalyze(ctx, body)
+    default: throw new Error(`Unknown action: ${action}. Use 'analyze'.`)
+  }
+})