Replace external LLM dependency with fully embedded AI triage engine

Add src/lib/triageAI.js: self-contained rule-based intelligence engine with medical knowledge, drug interaction/toxicity detection, rejection sign analysis, risk assessment, and patient communication generation. Update appClient.js to route all InvokeLLM calls through the embedded engine. Rewrite Settings page to show built-in AI engine status. Simplify ImportRulesDialog to use direct offline file parsing. All 42 tests pass, zero lint errors.

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: NeuroKoder3

src/api/appClient.js

@@ -243,58 +243,15 @@ class LocalAuth {
   redirectToLogin() {}
 }
 
-// --- Integrations ---
+// --- Integrations (Built-in AI Engine) ---
 class LocalIntegrations {
   constructor() {
+    this._engine = null;
+    this._enginePromise = null;
     this.Core = {
       InvokeLLM: async (params) => {
-        const endpoint = ipc ? await ipc.settings.get('llm_endpoint') : localStorage.getItem(`${DB_PREFIX}llm_endpoint`) || '';
-        const apiKey = ipc ? await ipc.settings.get('llm_api_key') : localStorage.getItem(`${DB_PREFIX}llm_api_key`) || '';
-        const model = ipc ? await ipc.settings.get('llm_model') : localStorage.getItem(`${DB_PREFIX}llm_model`) || 'gpt-4';
-
-        if (endpoint) {
-          try {
-            const response = await fetch(endpoint, {
-              method: 'POST',
-              headers: { 'Content-Type': 'application/json', ...(apiKey ? { Authorization: `Bearer ${apiKey}` } : {}) },
-              body: JSON.stringify({
-                model: model || 'gpt-4',
-                messages: [
-                  ...(params.system_prompt ? [{ role: 'system', content: params.system_prompt }] : []),
-                  { role: 'user', content: params.prompt || params.user_prompt || '' },
-                ],
-                ...(params.response_json_schema ? { response_format: { type: 'json_object' } } : {}),
-              }),
-            });
-            const data = await response.json();
-            let content = data.choices?.[0]?.message?.content || JSON.stringify(data);
-            if (params.response_json_schema) {
-              const cleaned = content.replace(/^```(?:json)?\s*\n?/i, '').replace(/\n?```\s*$/i, '').trim();
-              try { return JSON.parse(cleaned); } catch {
-                try { return JSON.parse(content); } catch { return content; }
-              }
-            }
-            return content;
-          } catch (error) {
-            console.warn('[TriageLink] LLM call failed:', error.message);
-          }
-        }
-
-        if (params.response_json_schema) {
-          return {
-            urgency_level: 'non-urgent',
-            matched_rule_id: 'GENERAL_PROTOCOL',
-            complaint_category: 'General Triage Protocol',
-            action_required: 'Offline mode — configure an LLM endpoint in Settings to enable AI-powered analysis.',
-            reasoning: 'No LLM endpoint configured. Connect a local LLM (e.g. Ollama) or set an OpenAI-compatible API key in Settings.',
-            confidence_score: 0,
-            ai_summary: 'Offline Mode | No AI analysis available — please configure an LLM endpoint in Settings.',
-            patient_condition_summary: 'AI analysis unavailable in offline mode. Please review the complaint manually and apply hospital protocols.',
-            needs_clarification: false,
-            follow_up_actions: ['Configure an LLM endpoint in Settings to enable AI-powered triage analysis.'],
-          };
-        }
-        return 'Offline mode — configure an LLM endpoint in Settings for AI-powered analysis.';
+        const engine = await this._getEngine();
+        return engine.routeInvokeLLM(params);
       },
       SendEmail: async (params) => { console.log('[TriageLink] Email queued:', params); return { success: true, message: 'Email logged locally' }; },
       SendSMS: async (params) => { console.log('[TriageLink] SMS queued:', params); return { success: true, message: 'SMS logged locally' }; },
@@ -303,6 +260,17 @@ class LocalIntegrations {
       ExtractDataFromUploadedFile: async (params) => { console.log('[TriageLink] Data extraction:', params); return { data: {}, success: true }; },
     };
   }
+
+  async _getEngine() {
+    if (this._engine) return this._engine;
+    if (!this._enginePromise) {
+      this._enginePromise = import('@/lib/triageAI.js').then(mod => {
+        this._engine = mod;
+        return mod;
+      });
+    }
+    return this._enginePromise;
+  }
 }
 
 // --- Audit helper (renderer-side) ---
@@ -395,21 +363,8 @@ class AppClient {
     if (ipc) {
       await migrateLocalStorageIfNeeded();
       if (this.auth.init) await this.auth.init();
-      await this._ensureLLMDefaults();
     }
   }
-
-  async _ensureLLMDefaults() {
-    try {
-      const existing = await this.settings.get('llm_endpoint');
-      if (!existing) {
-        await this.settings.set('llm_endpoint', 'http://localhost:11434/v1/chat/completions');
-        await this.settings.set('llm_model', 'llama3.1:8b');
-        await this.settings.set('llm_api_key', '');
-        console.log('[TriageLink] Ollama defaults configured');
-      }
-    } catch {}
-  }
 }
 
 export const appClient = new AppClient();

src/components/rules/ImportRulesDialog.jsx

@@ -1,6 +1,6 @@
 import React, { useState, useRef, useCallback } from "react";
 import { appClient } from "@/api/appClient";
-import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { useQueryClient } from "@tanstack/react-query";
 import {
   Dialog,
   DialogContent,
@@ -29,44 +29,7 @@ import {
 } from "lucide-react";
 import { parseFile, ACCEPTED_FILE_TYPES, FILE_TYPE_LABELS, extractRulesFromStructuredData, extractRulesFromText } from "@/lib/fileParser";
 
-const EXTRACTION_PROMPT = `You are an expert medical triage data extraction AI. Your task is to analyze a document containing transplant hospital criteria, paging rules, and triage protocols, then extract structured rules from it.
-
-DOCUMENT CONTENT:
-{DOCUMENT_TEXT}
-
-INSTRUCTIONS:
-1. Carefully read the entire document content above
-2. Identify ALL triage rules, paging criteria, alert thresholds, escalation paths, and contact routing instructions
-3. For each rule found, extract the structured fields listed below
-4. If a field is not explicitly stated, infer it from context or mark it as empty
-5. Pay special attention to: complaint categories, trigger criteria, paging numbers, escalation paths, urgency levels, organ types, patient types
-
-Extract each rule as a JSON object. Return a JSON object with this exact structure:
-{
-  "rules": [
-    {
-      "complaint_category": "The complaint or condition category (e.g., Fever, Pain, Bleeding, Medication Issue)",
-      "trigger_criteria": "Specific threshold or criteria that triggers this rule (e.g., Fever >100.5°F, Creatinine >2.0)",
-      "action_required": "What action to take / who to page / routing instructions",
-      "contact_method": "phone | secure_page | email | urgent_page",
-      "contact_info": "Phone/pager number if mentioned",
-      "escalation_path": "Who to escalate to if no response",
-      "priority": "routine | urgent | emergency",
-      "patient_type": "pre-transplant | post-transplant | non-transplant (if specified)",
-      "organ_type": "kidney | liver | kidney-pancreas (if specified)",
-      "documentation_notes": "Any required documentation or special instructions"
-    }
-  ],
-  "hospital_name": "Name of the hospital if mentioned in the document",
-  "summary": "Brief 2-3 sentence summary of what the document contains"
-}
-
-IMPORTANT:
-- Extract EVERY rule you can find, even partial ones
-- Use exact paging numbers and contact info from the document
-- Preserve medical terminology exactly as written
-- If the document has tabular data, treat each row as a potential rule
-- Return valid JSON only`;
+// No external prompt needed — extraction is handled by the built-in file parser
 
 function getFileIcon(fileName) {
   const ext = fileName.split('.').pop().toLowerCase();
@@ -203,41 +166,10 @@ export default function ImportRulesDialog({ open, onOpenChange, hospitals }) {
     setParseError(null);
 
     try {
-      const docText = parsedContent.text.substring(0, 15000);
-      const prompt = EXTRACTION_PROMPT.replace('{DOCUMENT_TEXT}', docText);
-
-      const result = await appClient.integrations.Core.InvokeLLM({
-        prompt,
-        response_json_schema: {
-          type: "object",
-          properties: {
-            rules: { type: "array" },
-            hospital_name: { type: "string" },
-            summary: { type: "string" },
-          },
-        },
-      });
-
-      let parsed;
-      try {
-        parsed = typeof result === 'string' ? JSON.parse(result) : result;
-      } catch {
-        parsed = { rules: [] };
-      }
-
-      if (parsed.rules && parsed.rules.length > 0) {
-        applyExtractionResult(parsed);
-      } else {
-        const offlineResult = extractOffline();
-        applyExtractionResult(offlineResult);
-      }
-    } catch {
-      try {
-        const offlineResult = extractOffline();
-        applyExtractionResult(offlineResult);
-      } catch (offlineErr) {
-        setParseError(`Extraction failed: ${offlineErr.message}`);
-      }
+      const result = extractOffline();
+      applyExtractionResult(result);
+    } catch (err) {
+      setParseError(`Extraction failed: ${err.message}`);
     } finally {
       setIsExtracting(false);
     }