feat(dentaquest) - implement DentaQuest eligibility check with Selenium integration; added routes, services, and frontend components for OTP handling and eligibility status retrieval

.gitignore

@@ -38,3 +38,4 @@ dist/
 # env
 *.env
 *chrome_profile_ddma*
+*chrome_profile_dentaquest*

apps/Backend/src/routes/index.ts

@@ -9,6 +9,7 @@ import insuranceCredsRoutes from "./insuranceCreds";
 import documentsRoutes from "./documents";
 import insuranceStatusRoutes from "./insuranceStatus";
 import insuranceStatusDdmaRoutes from "./insuranceStatusDDMA";
+import insuranceStatusDentaQuestRoutes from "./insuranceStatusDentaQuest";
 import paymentsRoutes from "./payments";
 import databaseManagementRoutes from "./database-management";
 import notificationsRoutes from "./notifications";
@@ -29,6 +30,7 @@ router.use("/insuranceCreds", insuranceCredsRoutes);
 router.use("/documents", documentsRoutes);
 router.use("/insurance-status", insuranceStatusRoutes);
 router.use("/insurance-status-ddma", insuranceStatusDdmaRoutes);
+router.use("/insurance-status-dentaquest", insuranceStatusDentaQuestRoutes);
 router.use("/payments", paymentsRoutes);
 router.use("/database-management", databaseManagementRoutes);
 router.use("/notifications", notificationsRoutes);

apps/Backend/src/routes/insuranceStatusDentaQuest.ts

@@ -0,0 +1,700 @@
+import { Router, Request, Response } from "express";
+import { storage } from "../storage";
+import {
+  forwardToSeleniumDentaQuestEligibilityAgent,
+  forwardOtpToSeleniumDentaQuestAgent,
+  getSeleniumDentaQuestSessionStatus,
+} from "../services/seleniumDentaQuestInsuranceEligibilityClient";
+import fs from "fs/promises";
+import fsSync from "fs";
+import path from "path";
+import PDFDocument from "pdfkit";
+import { emptyFolderContainingFile } from "../utils/emptyTempFolder";
+import {
+  InsertPatient,
+  insertPatientSchema,
+} from "../../../../packages/db/types/patient-types";
+import { io } from "../socket";
+
+const router = Router();
+
+/** Job context stored in memory by sessionId */
+interface DentaQuestJobContext {
+  userId: number;
+  insuranceEligibilityData: any; // parsed, enriched (includes username/password)
+  socketId?: string;
+}
+
+const dentaquestJobs: Record<string, DentaQuestJobContext> = {};
+
+/** Utility: naive name splitter */
+function splitName(fullName?: string | null) {
+  if (!fullName) return { firstName: "", lastName: "" };
+  const parts = fullName.trim().split(/\s+/).filter(Boolean);
+  const firstName = parts.shift() ?? "";
+  const lastName = parts.join(" ") ?? "";
+  return { firstName, lastName };
+}
+
+async function imageToPdfBuffer(imagePath: string): Promise<Buffer> {
+  return new Promise<Buffer>((resolve, reject) => {
+    try {
+      const doc = new PDFDocument({ autoFirstPage: false });
+      const chunks: Uint8Array[] = [];
+
+      doc.on("data", (chunk: any) => chunks.push(chunk));
+      doc.on("end", () => resolve(Buffer.concat(chunks)));
+      doc.on("error", (err: any) => reject(err));
+
+      const A4_WIDTH = 595.28; // points
+      const A4_HEIGHT = 841.89; // points
+
+      doc.addPage({ size: [A4_WIDTH, A4_HEIGHT] });
+
+      doc.image(imagePath, 0, 0, {
+        fit: [A4_WIDTH, A4_HEIGHT],
+        align: "center",
+        valign: "center",
+      });
+
+      doc.end();
+    } catch (err) {
+      reject(err);
+    }
+  });
+}
+
+/**
+ * Ensure patient exists for given insuranceId.
+ */
+async function createOrUpdatePatientByInsuranceId(options: {
+  insuranceId: string;
+  firstName?: string | null;
+  lastName?: string | null;
+  dob?: string | Date | null;
+  userId: number;
+}) {
+  const { insuranceId, firstName, lastName, dob, userId } = options;
+  if (!insuranceId) throw new Error("Missing insuranceId");
+
+  const incomingFirst = (firstName || "").trim();
+  const incomingLast = (lastName || "").trim();
+
+  let patient = await storage.getPatientByInsuranceId(insuranceId);
+
+  if (patient && patient.id) {
+    const updates: any = {};
+    if (
+      incomingFirst &&
+      String(patient.firstName ?? "").trim() !== incomingFirst
+    ) {
+      updates.firstName = incomingFirst;
+    }
+    if (
+      incomingLast &&
+      String(patient.lastName ?? "").trim() !== incomingLast
+    ) {
+      updates.lastName = incomingLast;
+    }
+    if (Object.keys(updates).length > 0) {
+      await storage.updatePatient(patient.id, updates);
+    }
+    return;
+  } else {
+    const createPayload: any = {
+      firstName: incomingFirst,
+      lastName: incomingLast,
+      dateOfBirth: dob,
+      gender: "",
+      phone: "",
+      userId,
+      insuranceId,
+    };
+    let patientData: InsertPatient;
+    try {
+      patientData = insertPatientSchema.parse(createPayload);
+    } catch (err) {
+      const safePayload = { ...createPayload };
+      delete (safePayload as any).dateOfBirth;
+      patientData = insertPatientSchema.parse(safePayload);
+    }
+    await storage.createPatient(patientData);
+  }
+}
+
+/**
+ * When Selenium finishes for a given sessionId, run your patient + PDF pipeline,
+ * and return the final API response shape.
+ */
+async function handleDentaQuestCompletedJob(
+  sessionId: string,
+  job: DentaQuestJobContext,
+  seleniumResult: any
+) {
+  let createdPdfFileId: number | null = null;
+  const outputResult: any = {};
+
+  // We'll wrap the processing in try/catch/finally so cleanup always runs
+  try {
+    // 1) ensuring memberid.
+    const insuranceEligibilityData = job.insuranceEligibilityData;
+    const insuranceId = String(insuranceEligibilityData.memberId ?? "").trim();
+    if (!insuranceId) {
+      throw new Error("Missing memberId for DentaQuest job");
+    }
+
+    // 2) Create or update patient (with name from selenium result if available)
+    const patientNameFromResult =
+      typeof seleniumResult?.patientName === "string"
+        ? seleniumResult.patientName.trim()
+        : null;
+
+    const { firstName, lastName } = splitName(patientNameFromResult);
+
+    await createOrUpdatePatientByInsuranceId({
+      insuranceId,
+      firstName,
+      lastName,
+      dob: insuranceEligibilityData.dateOfBirth,
+      userId: job.userId,
+    });
+
+    // 3) Update patient status + PDF upload
+    const patient = await storage.getPatientByInsuranceId(
+      insuranceEligibilityData.memberId
+    );
+    if (!patient?.id) {
+      outputResult.patientUpdateStatus =
+        "Patient not found; no update performed";
+      return {
+        patientUpdateStatus: outputResult.patientUpdateStatus,
+        pdfUploadStatus: "none",
+        pdfFileId: null,
+      };
+    }
+
+    // update patient status.
+    const newStatus =
+      seleniumResult.eligibility === "active" ? "ACTIVE" : "INACTIVE";
+    await storage.updatePatient(patient.id, { status: newStatus });
+    outputResult.patientUpdateStatus = `Patient status updated to ${newStatus}`;
+
+    // convert screenshot -> pdf if available
+    let pdfBuffer: Buffer | null = null;
+    let generatedPdfPath: string | null = null;
+
+    if (
+      seleniumResult &&
+      seleniumResult.ss_path &&
+      typeof seleniumResult.ss_path === "string" &&
+      (seleniumResult.ss_path.endsWith(".png") ||
+        seleniumResult.ss_path.endsWith(".jpg") ||
+        seleniumResult.ss_path.endsWith(".jpeg"))
+    ) {
+      try {
+        if (!fsSync.existsSync(seleniumResult.ss_path)) {
+          throw new Error(
+            `Screenshot file not found: ${seleniumResult.ss_path}`
+          );
+        }
+
+        pdfBuffer = await imageToPdfBuffer(seleniumResult.ss_path);
+
+        const pdfFileName = `dentaquest_eligibility_${insuranceEligibilityData.memberId}_${Date.now()}.pdf`;
+        generatedPdfPath = path.join(
+          path.dirname(seleniumResult.ss_path),
+          pdfFileName
+        );
+        await fs.writeFile(generatedPdfPath, pdfBuffer);
+
+        // ensure cleanup uses this
+        seleniumResult.pdf_path = generatedPdfPath;
+      } catch (err: any) {
+        console.error("Failed to convert screenshot to PDF:", err);
+        outputResult.pdfUploadStatus = `Failed to convert screenshot to PDF: ${String(err)}`;
+      }
+    } else {
+      outputResult.pdfUploadStatus =
+        "No valid screenshot (ss_path) provided by Selenium; nothing to upload.";
+    }
+
+    if (pdfBuffer && generatedPdfPath) {
+      const groupTitle = "Eligibility Status";
+      const groupTitleKey = "ELIGIBILITY_STATUS";
+
+      let group = await storage.findPdfGroupByPatientTitleKey(
+        patient.id,
+        groupTitleKey
+      );
+      if (!group) {
+        group = await storage.createPdfGroup(
+          patient.id,
+          groupTitle,
+          groupTitleKey
+        );
+      }
+      if (!group?.id) {
+        throw new Error("PDF group creation failed: missing group ID");
+      }
+
+      const created = await storage.createPdfFile(
+        group.id,
+        path.basename(generatedPdfPath),
+        pdfBuffer
+      );
+      if (created && typeof created === "object" && "id" in created) {
+        createdPdfFileId = Number(created.id);
+      }
+      outputResult.pdfUploadStatus = `PDF saved to group: ${group.title}`;
+    } else {
+      outputResult.pdfUploadStatus =
+        "No valid PDF path provided by Selenium, Couldn't upload pdf to server.";
+    }
+
+    return {
+      patientUpdateStatus: outputResult.patientUpdateStatus,
+      pdfUploadStatus: outputResult.pdfUploadStatus,
+      pdfFileId: createdPdfFileId,
+    };
+  } catch (err: any) {
+    return {
+      patientUpdateStatus: outputResult.patientUpdateStatus,
+      pdfUploadStatus:
+        outputResult.pdfUploadStatus ??
+        `Failed to process DentaQuest job: ${err?.message ?? String(err)}`,
+      pdfFileId: createdPdfFileId,
+      error: err?.message ?? String(err),
+    };
+  } finally {
+    // ALWAYS attempt cleanup of temp files
+    try {
+      if (seleniumResult && seleniumResult.pdf_path) {
+        await emptyFolderContainingFile(seleniumResult.pdf_path);
+      } else if (seleniumResult && seleniumResult.ss_path) {
+        await emptyFolderContainingFile(seleniumResult.ss_path);
+      } else {
+        console.log(
+          `[dentaquest-eligibility] no pdf_path or ss_path available to cleanup`
+        );
+      }
+    } catch (cleanupErr) {
+      console.error(
+        `[dentaquest-eligibility cleanup failed for ${seleniumResult?.pdf_path ?? seleniumResult?.ss_path}]`,
+        cleanupErr
+      );
+    }
+  }
+}
+
+// --- top of file, alongside dentaquestJobs ---
+let currentFinalSessionId: string | null = null;
+let currentFinalResult: any = null;
+
+function now() {
+  return new Date().toISOString();
+}
+function log(tag: string, msg: string, ctx?: any) {
+  console.log(`${now()} [${tag}] ${msg}`, ctx ?? "");
+}
+
+function emitSafe(socketId: string | undefined, event: string, payload: any) {
+  if (!socketId) {
+    log("socket", "no socketId for emit", { event });
+    return;
+  }
+  try {
+    const socket = io?.sockets.sockets.get(socketId);
+    if (!socket) {
+      log("socket", "socket not found (maybe disconnected)", {
+        socketId,
+        event,
+      });
+      return;
+    }
+    socket.emit(event, payload);
+    log("socket", "emitted", { socketId, event });
+  } catch (err: any) {
+    log("socket", "emit failed", { socketId, event, err: err?.message });
+  }
+}
+
+/**
+ * Polls Python agent for session status and emits socket events:
+ *  - 'selenium:otp_required' when waiting_for_otp
+ *  - 'selenium:session_update' when completed/error
+ *  - absolute timeout + transient error handling.
+ *  - pollTimeoutMs default = 2 minutes (adjust where invoked)
+ */
+async function pollAgentSessionAndProcess(
+  sessionId: string,
+  socketId?: string,
+  pollTimeoutMs = 2 * 60 * 1000
+) {
+  const maxAttempts = 300;
+  const baseDelayMs = 1000;
+  const maxTransientErrors = 12;
+
+  // NEW: give up if same non-terminal status repeats this many times
+  const noProgressLimit = 100;
+
+  const job = dentaquestJobs[sessionId];
+  let transientErrorCount = 0;
+  let consecutiveNoProgress = 0;
+  let lastStatus: string | null = null;
+  const deadline = Date.now() + pollTimeoutMs;
+
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    // absolute deadline check
+    if (Date.now() > deadline) {
+      emitSafe(socketId, "selenium:session_update", {
+        session_id: sessionId,
+        status: "error",
+        message: `Polling timeout reached (${Math.round(pollTimeoutMs / 1000)}s).`,
+      });
+      delete dentaquestJobs[sessionId];
+      return;
+    }
+
+    log(
+      "poller",
+      `attempt=${attempt} session=${sessionId} transientErrCount=${transientErrorCount}`
+    );
+
+    try {
+      const st = await getSeleniumDentaQuestSessionStatus(sessionId);
+      const status = st?.status ?? null;
+      log("poller", "got status", {
+        sessionId,
+        status,
+        message: st?.message,
+        resultKeys: st?.result ? Object.keys(st.result) : null,
+      });
+
+      // reset transient errors on success
+      transientErrorCount = 0;
+
+      // if status unchanged and non-terminal, increment no-progress counter
+      const isTerminalLike =
+        status === "completed" || status === "error" || status === "not_found";
+      if (status === lastStatus && !isTerminalLike) {
+        consecutiveNoProgress++;
+      } else {
+        consecutiveNoProgress = 0;
+      }
+      lastStatus = status;
+
+      // if no progress for too many consecutive polls -> abort
+      if (consecutiveNoProgress >= noProgressLimit) {
+        emitSafe(socketId, "selenium:session_update", {
+          session_id: sessionId,
+          status: "error",
+          message: `No progress from selenium agent (status="${status}") after ${consecutiveNoProgress} polls; aborting.`,
+        });
+        emitSafe(socketId, "selenium:session_error", {
+          session_id: sessionId,
+          status: "error",
+          message: "No progress from selenium agent",
+        });
+        delete dentaquestJobs[sessionId];
+        return;
+      }
+
+      // always emit debug to client if socket exists
+      emitSafe(socketId, "selenium:debug", {
+        session_id: sessionId,
+        attempt,
+        status,
+        serverTime: new Date().toISOString(),
+      });
+
+      // If agent is waiting for OTP, inform client but keep polling (do not return)
+      if (status === "waiting_for_otp") {
+        emitSafe(socketId, "selenium:otp_required", {
+          session_id: sessionId,
+          message: "OTP required. Please enter the OTP.",
+        });
+        // do not return — keep polling (allows same poller to pick up completion)
+        await new Promise((r) => setTimeout(r, baseDelayMs));
+        continue;
+      }
+
+      // Completed path
+      if (status === "completed") {
+        log("poller", "agent completed; processing result", {
+          sessionId,
+          resultKeys: st.result ? Object.keys(st.result) : null,
+        });
+
+        // Persist raw result so frontend can fetch if socket disconnects
+        currentFinalSessionId = sessionId;
+        currentFinalResult = {
+          rawSelenium: st.result,
+          processedAt: null,
+          final: null,
+        };
+
+        let finalResult: any = null;
+        if (job && st.result) {
+          try {
+            finalResult = await handleDentaQuestCompletedJob(
+              sessionId,
+              job,
+              st.result
+            );
+            currentFinalResult.final = finalResult;
+            currentFinalResult.processedAt = Date.now();
+          } catch (err: any) {
+            currentFinalResult.final = {
+              error: "processing_failed",
+              detail: err?.message ?? String(err),
+            };
+            currentFinalResult.processedAt = Date.now();
+            log("poller", "handleDentaQuestCompletedJob failed", {
+              sessionId,
+              err: err?.message ?? err,
+            });
+          }
+        } else {
+          currentFinalResult.final = {
+            error: "no_job_or_no_result",
+          };
+          currentFinalResult.processedAt = Date.now();
+        }
+
+        // Emit final update (if socket present)
+        emitSafe(socketId, "selenium:session_update", {
+          session_id: sessionId,
+          status: "completed",
+          rawSelenium: st.result,
+          final: currentFinalResult.final,
+        });
+
+        // cleanup job context
+        delete dentaquestJobs[sessionId];
+        return;
+      }
+
+      // Terminal error / not_found
+      if (status === "error" || status === "not_found") {
+        const emitPayload = {
+          session_id: sessionId,
+          status,
+          message: st?.message || "Selenium session error",
+        };
+        emitSafe(socketId, "selenium:session_update", emitPayload);
+        emitSafe(socketId, "selenium:session_error", emitPayload);
+        delete dentaquestJobs[sessionId];
+        return;
+      }
+    } catch (err: any) {
+      const axiosStatus =
+        err?.response?.status ?? (err?.status ? Number(err.status) : undefined);
+      const errCode = err?.code ?? err?.errno;
+      const errMsg = err?.message ?? String(err);
+      const errData = err?.response?.data ?? null;
+
+      // If agent explicitly returned 404 -> terminal (session gone)
+      if (
+        axiosStatus === 404 ||
+        (typeof errMsg === "string" && errMsg.includes("not_found"))
+      ) {
+        console.warn(
+          `${new Date().toISOString()} [poller] terminal 404/not_found for ${sessionId}: data=${JSON.stringify(errData)}`
+        );
+
+        // Emit not_found to client
+        const emitPayload = {
+          session_id: sessionId,
+          status: "not_found",
+          message:
+            errData?.detail || "Selenium session not found (agent cleaned up).",
+        };
+        emitSafe(socketId, "selenium:session_update", emitPayload);
+        emitSafe(socketId, "selenium:session_error", emitPayload);
+
+        // Remove job context and stop polling
+        delete dentaquestJobs[sessionId];
+        return;
+      }
+
+      // Detailed transient error logging
+      transientErrorCount++;
+      if (transientErrorCount > maxTransientErrors) {
+        const emitPayload = {
+          session_id: sessionId,
+          status: "error",
+          message:
+            "Repeated network errors while polling selenium agent; giving up.",
+        };
+        emitSafe(socketId, "selenium:session_update", emitPayload);
+        emitSafe(socketId, "selenium:session_error", emitPayload);
+        delete dentaquestJobs[sessionId];
+        return;
+      }
+
+      const backoffMs = Math.min(
+        30_000,
+        baseDelayMs * Math.pow(2, transientErrorCount - 1)
+      );
+      console.warn(
+        `${new Date().toISOString()} [poller] transient error (#${transientErrorCount}) for ${sessionId}: code=${errCode} status=${axiosStatus} msg=${errMsg} data=${JSON.stringify(errData)}`
+      );
+      console.warn(
+        `${new Date().toISOString()} [poller] backing off ${backoffMs}ms before next attempt`
+      );
+
+      await new Promise((r) => setTimeout(r, backoffMs));
+      continue;
+    }
+
+    // normal poll interval
+    await new Promise((r) => setTimeout(r, baseDelayMs));
+  }
+
+  // overall timeout fallback
+  emitSafe(socketId, "selenium:session_update", {
+    session_id: sessionId,
+    status: "error",
+    message: "Polling timeout while waiting for selenium session",
+  });
+  delete dentaquestJobs[sessionId];
+}
+
+/**
+ * POST /dentaquest-eligibility
+ * Starts DentaQuest eligibility Selenium job.
+ * Expects:
+ *  - req.body.data: stringified JSON like your existing /eligibility-check
+ *  - req.body.socketId: socket.io client id
+ */
+router.post(
+  "/dentaquest-eligibility",
+  async (req: Request, res: Response): Promise<any> => {
+    if (!req.body.data) {
+      return res
+        .status(400)
+        .json({ error: "Missing Insurance Eligibility data for selenium" });
+    }
+
+    if (!req.user || !req.user.id) {
+      return res.status(401).json({ error: "Unauthorized: user info missing" });
+    }
+
+    try {
+      const rawData =
+        typeof req.body.data === "string"
+          ? JSON.parse(req.body.data)
+          : req.body.data;
+
+      const credentials = await storage.getInsuranceCredentialByUserAndSiteKey(
+        req.user.id,
+        rawData.insuranceSiteKey
+      );
+      if (!credentials) {
+        return res.status(404).json({
+          error:
+            "No insurance credentials found for this provider, Kindly Update this at Settings Page.",
+        });
+      }
+
+      const enrichedData = {
+        ...rawData,
+        dentaquestUsername: credentials.username,
+        dentaquestPassword: credentials.password,
+      };
+
+      const socketId: string | undefined = req.body.socketId;
+
+      const agentResp =
+        await forwardToSeleniumDentaQuestEligibilityAgent(enrichedData);
+
+      if (
+        !agentResp ||
+        agentResp.status !== "started" ||
+        !agentResp.session_id
+      ) {
+        return res.status(502).json({
+          error: "Selenium agent did not return a started session",
+          detail: agentResp,
+        });
+      }
+
+      const sessionId = agentResp.session_id as string;
+
+      // Save job context
+      dentaquestJobs[sessionId] = {
+        userId: req.user.id,
+        insuranceEligibilityData: enrichedData,
+        socketId,
+      };
+
+      // start polling in background to notify client via socket and process job
+      pollAgentSessionAndProcess(sessionId, socketId).catch((e) =>
+        console.warn("pollAgentSessionAndProcess failed", e)
+      );
+
+      // reply immediately with started status
+      return res.json({ status: "started", session_id: sessionId });
+    } catch (err: any) {
+      console.error(err);
+      return res.status(500).json({
+        error: err.message || "Failed to start DentaQuest selenium agent",
+      });
+    }
+  }
+);
+
+/**
+ * POST /selenium/submit-otp
+ * Body: { session_id, otp, socketId? }
+ * Forwards OTP to Python agent and optionally notifies client socket.
+ */
+router.post(
+  "/selenium/submit-otp",
+  async (req: Request, res: Response): Promise<any> => {
+    const { session_id: sessionId, otp, socketId } = req.body;
+    if (!sessionId || !otp) {
+      return res.status(400).json({ error: "session_id and otp are required" });
+    }
+
+    try {
+      const r = await forwardOtpToSeleniumDentaQuestAgent(sessionId, otp);
+
+      // emit OTP accepted (if socket present)
+      emitSafe(socketId, "selenium:otp_submitted", {
+        session_id: sessionId,
+        result: r,
+      });
+
+      return res.json(r);
+    } catch (err: any) {
+      console.error(
+        "Failed to forward OTP:",
+        err?.response?.data || err?.message || err
+      );
+      return res.status(500).json({
+        error: "Failed to forward otp to selenium agent",
+        detail: err?.message || err,
+      });
+    }
+  }
+);
+
+// GET /selenium/session/:sid/final
+router.get(
+  "/selenium/session/:sid/final",
+  async (req: Request, res: Response) => {
+    const sid = req.params.sid;
+    if (!sid) return res.status(400).json({ error: "session id required" });
+
+    // Only the current in-memory result is available
+    if (currentFinalSessionId !== sid || !currentFinalResult) {
+      return res.status(404).json({ error: "final result not found" });
+    }
+
+    return res.json(currentFinalResult);
+  }
+);
+
+export default router;
+

apps/Backend/src/services/seleniumDentaQuestInsuranceEligibilityClient.ts

@@ -0,0 +1,123 @@
+import axios from "axios";
+import http from "http";
+import https from "https";
+import dotenv from "dotenv";
+dotenv.config();
+
+export interface SeleniumPayload {
+  data: any;
+  url?: string;
+}
+
+const SELENIUM_AGENT_BASE = process.env.SELENIUM_AGENT_BASE_URL;
+
+const httpAgent = new http.Agent({ keepAlive: true, keepAliveMsecs: 60_000 });
+const httpsAgent = new https.Agent({ keepAlive: true, keepAliveMsecs: 60_000 });
+
+const client = axios.create({
+  baseURL: SELENIUM_AGENT_BASE,
+  timeout: 5 * 60 * 1000,
+  httpAgent,
+  httpsAgent,
+  validateStatus: (s) => s >= 200 && s < 600,
+});
+
+async function requestWithRetries(
+  config: any,
+  retries = 4,
+  baseBackoffMs = 300
+) {
+  for (let attempt = 1; attempt <= retries; attempt++) {
+    try {
+      const r = await client.request(config);
+      if (![502, 503, 504].includes(r.status)) return r;
+      console.warn(
+        `[selenium-dentaquest-client] retryable HTTP status ${r.status} (attempt ${attempt})`
+      );
+    } catch (err: any) {
+      const code = err?.code;
+      const isTransient =
+        code === "ECONNRESET" ||
+        code === "ECONNREFUSED" ||
+        code === "EPIPE" ||
+        code === "ETIMEDOUT";
+      if (!isTransient) throw err;
+      console.warn(
+        `[selenium-dentaquest-client] transient network error ${code} (attempt ${attempt})`
+      );
+    }
+    await new Promise((r) => setTimeout(r, baseBackoffMs * attempt));
+  }
+  // final attempt (let exception bubble if it fails)
+  return client.request(config);
+}
+
+function now() {
+  return new Date().toISOString();
+}
+function log(tag: string, msg: string, ctx?: any) {
+  console.log(`${now()} [${tag}] ${msg}`, ctx ?? "");
+}
+
+export async function forwardToSeleniumDentaQuestEligibilityAgent(
+  insuranceEligibilityData: any
+): Promise<any> {
+  const payload = { data: insuranceEligibilityData };
+  const url = `/dentaquest-eligibility`;
+  log("selenium-dentaquest-client", "POST dentaquest-eligibility", {
+    url: SELENIUM_AGENT_BASE + url,
+    keys: Object.keys(payload),
+  });
+  const r = await requestWithRetries({ url, method: "POST", data: payload }, 4);
+  log("selenium-dentaquest-client", "agent response", {
+    status: r.status,
+    dataKeys: r.data ? Object.keys(r.data) : null,
+  });
+  if (r.status >= 500)
+    throw new Error(`Selenium agent server error: ${r.status}`);
+  return r.data;
+}
+
+export async function forwardOtpToSeleniumDentaQuestAgent(
+  sessionId: string,
+  otp: string
+): Promise<any> {
+  const url = `/dentaquest-submit-otp`;
+  log("selenium-dentaquest-client", "POST dentaquest-submit-otp", {
+    url: SELENIUM_AGENT_BASE + url,
+    sessionId,
+  });
+  const r = await requestWithRetries(
+    { url, method: "POST", data: { session_id: sessionId, otp } },
+    4
+  );
+  log("selenium-dentaquest-client", "submit-otp response", {
+    status: r.status,
+    data: r.data,
+  });
+  if (r.status >= 500)
+    throw new Error(`Selenium agent server error on submit-otp: ${r.status}`);
+  return r.data;
+}
+
+export async function getSeleniumDentaQuestSessionStatus(
+  sessionId: string
+): Promise<any> {
+  const url = `/dentaquest-session/${sessionId}/status`;
+  log("selenium-dentaquest-client", "GET session status", {
+    url: SELENIUM_AGENT_BASE + url,
+    sessionId,
+  });
+  const r = await requestWithRetries({ url, method: "GET" }, 4);
+  log("selenium-dentaquest-client", "session status response", {
+    status: r.status,
+    dataKeys: r.data ? Object.keys(r.data) : null,
+  });
+  if (r.status === 404) {
+    const e: any = new Error("not_found");
+    e.response = { status: 404, data: r.data };
+    throw e;
+  }
+  return r.data;
+}
+

apps/Frontend/src/components/insurance-status/dentaquest-button-modal.tsx

@@ -0,0 +1,566 @@
+import { useEffect, useRef, useState } from "react";
+import { io as ioClient, Socket } from "socket.io-client";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { Label } from "@/components/ui/label";
+import { CheckCircle, LoaderCircleIcon, X } from "lucide-react";
+import { useToast } from "@/hooks/use-toast";
+import { apiRequest, queryClient } from "@/lib/queryClient";
+import { useAppDispatch } from "@/redux/hooks";
+import { setTaskStatus } from "@/redux/slices/seleniumEligibilityCheckTaskSlice";
+import { formatLocalDate } from "@/utils/dateUtils";
+import { QK_PATIENTS_BASE } from "@/components/patients/patient-table";
+
+const SOCKET_URL =
+  import.meta.env.VITE_API_BASE_URL_BACKEND ||
+  (typeof window !== "undefined" ? window.location.origin : "");
+
+// ---------- OTP Modal component ----------
+interface DentaQuestOtpModalProps {
+  open: boolean;
+  onClose: () => void;
+  onSubmit: (otp: string) => Promise<void> | void;
+  isSubmitting: boolean;
+}
+
+function DentaQuestOtpModal({
+  open,
+  onClose,
+  onSubmit,
+  isSubmitting,
+}: DentaQuestOtpModalProps) {
+  const [otp, setOtp] = useState("");
+
+  useEffect(() => {
+    if (!open) setOtp("");
+  }, [open]);
+
+  if (!open) return null;
+
+  const handleSubmit = async (e: React.FormEvent) => {
+    e.preventDefault();
+    if (!otp.trim()) return;
+    await onSubmit(otp.trim());
+  };
+
+  return (
+    <div className="fixed inset-0 z-50 flex items-center justify-center bg-black/40">
+      <div className="bg-white dark:bg-slate-900 rounded-xl shadow-lg w-full max-w-md p-6">
+        <div className="flex items-center justify-between mb-4">
+          <h2 className="text-lg font-semibold">Enter OTP</h2>
+          <button
+            type="button"
+            onClick={onClose}
+            className="text-slate-500 hover:text-slate-800"
+          >
+            <X className="w-4 h-4" />
+          </button>
+        </div>
+        <p className="text-sm text-slate-500 mb-4">
+          We need the one-time password (OTP) sent by the DentaQuest portal
+          to complete this eligibility check.
+        </p>
+        <form onSubmit={handleSubmit} className="space-y-4">
+          <div className="space-y-2">
+            <Label htmlFor="dentaquest-otp">OTP</Label>
+            <Input
+              id="dentaquest-otp"
+              placeholder="Enter OTP code"
+              value={otp}
+              onChange={(e) => setOtp(e.target.value)}
+              autoFocus
+            />
+          </div>
+          <div className="flex justify-end gap-3">
+            <Button
+              type="button"
+              variant="outline"
+              onClick={onClose}
+              disabled={isSubmitting}
+            >
+              Cancel
+            </Button>
+            <Button type="submit" disabled={isSubmitting || !otp.trim()}>
+              {isSubmitting ? (
+                <>
+                  <LoaderCircleIcon className="w-4 h-4 mr-2 animate-spin" />
+                  Submitting...
+                </>
+              ) : (
+                "Submit OTP"
+              )}
+            </Button>
+          </div>
+        </form>
+      </div>
+    </div>
+  );
+}
+
+// ---------- Main DentaQuest Eligibility button component ----------
+interface DentaQuestEligibilityButtonProps {
+  memberId: string;
+  dateOfBirth: Date | null;
+  firstName?: string;
+  lastName?: string;
+  isFormIncomplete: boolean;
+  /** Called when backend has finished and PDF is ready */
+  onPdfReady: (pdfId: number, fallbackFilename: string | null) => void;
+}
+
+export function DentaQuestEligibilityButton({
+  memberId,
+  dateOfBirth,
+  firstName,
+  lastName,
+  isFormIncomplete,
+  onPdfReady,
+}: DentaQuestEligibilityButtonProps) {
+  const { toast } = useToast();
+  const dispatch = useAppDispatch();
+
+  const socketRef = useRef<Socket | null>(null);
+  const connectingRef = useRef<Promise<void> | null>(null);
+
+  const [sessionId, setSessionId] = useState<string | null>(null);
+  const [otpModalOpen, setOtpModalOpen] = useState(false);
+  const [isStarting, setIsStarting] = useState(false);
+  const [isSubmittingOtp, setIsSubmittingOtp] = useState(false);
+
+  // Clean up socket on unmount
+  useEffect(() => {
+    return () => {
+      if (socketRef.current) {
+        socketRef.current.removeAllListeners();
+        socketRef.current.disconnect();
+        socketRef.current = null;
+      }
+      connectingRef.current = null;
+    };
+  }, []);
+
+  const closeSocket = () => {
+    try {
+      socketRef.current?.removeAllListeners();
+      socketRef.current?.disconnect();
+    } catch (e) {
+      // ignore
+    } finally {
+      socketRef.current = null;
+    }
+  };
+
+  // Lazy socket setup: called only when we actually need it (first click)
+  const ensureSocketConnected = async () => {
+    // If already connected, nothing to do
+    if (socketRef.current && socketRef.current.connected) {
+      return;
+    }
+
+    // If a connection is in progress, reuse that promise
+    if (connectingRef.current) {
+      return connectingRef.current;
+    }
+
+    const promise = new Promise<void>((resolve, reject) => {
+      const socket = ioClient(SOCKET_URL, {
+        withCredentials: true,
+      });
+
+      socketRef.current = socket;
+
+      socket.on("connect", () => {
+        resolve();
+      });
+
+      // connection error when first connecting (or later)
+      socket.on("connect_error", (err: any) => {
+        dispatch(
+          setTaskStatus({
+            status: "error",
+            message: "Connection failed",
+          })
+        );
+        toast({
+          title: "Realtime connection failed",
+          description:
+            "Could not connect to realtime server. Retrying automatically...",
+          variant: "destructive",
+        });
+        // do not reject here because socket.io will attempt reconnection
+      });
+
+      // socket.io will emit 'reconnect_attempt' for retries
+      socket.on("reconnect_attempt", (attempt: number) => {
+        dispatch(
+          setTaskStatus({
+            status: "pending",
+            message: `Realtime reconnect attempt #${attempt}`,
+          })
+        );
+      });
+
+      // when reconnection failed after configured attempts
+      socket.on("reconnect_failed", () => {
+        dispatch(
+          setTaskStatus({
+            status: "error",
+            message: "Reconnect failed",
+          })
+        );
+        toast({
+          title: "Realtime reconnect failed",
+          description:
+            "Connection to realtime server could not be re-established. Please try again later.",
+          variant: "destructive",
+        });
+        // terminal failure — cleanup and reject so caller can stop start flow
+        closeSocket();
+        reject(new Error("Realtime reconnect failed"));
+      });
+
+      socket.on("disconnect", (reason: any) => {
+        dispatch(
+          setTaskStatus({
+            status: "error",
+            message: "Connection disconnected",
+          })
+        );
+        toast({
+          title: "Connection Disconnected",
+          description:
+            "Connection to the server was lost. If a DentaQuest job was running it may have failed.",
+          variant: "destructive",
+        });
+        // clear sessionId/OTP modal
+        setSessionId(null);
+        setOtpModalOpen(false);
+      });
+
+      // OTP required
+      socket.on("selenium:otp_required", (payload: any) => {
+        if (!payload?.session_id) return;
+        setSessionId(payload.session_id);
+        setOtpModalOpen(true);
+        dispatch(
+          setTaskStatus({
+            status: "pending",
+            message: "OTP required for DentaQuest eligibility. Please enter the OTP.",
+          })
+        );
+      });
+
+      // OTP submitted (optional UX)
+      socket.on("selenium:otp_submitted", (payload: any) => {
+        if (!payload?.session_id) return;
+        dispatch(
+          setTaskStatus({
+            status: "pending",
+            message: "OTP submitted. Finishing DentaQuest eligibility check...",
+          })
+        );
+      });
+
+      // Session update
+      socket.on("selenium:session_update", (payload: any) => {
+        const { session_id, status, final } = payload || {};
+        if (!session_id) return;
+
+        if (status === "completed") {
+          dispatch(
+            setTaskStatus({
+              status: "success",
+              message:
+                "DentaQuest eligibility updated and PDF attached to patient documents.",
+            })
+          );
+          toast({
+            title: "DentaQuest eligibility complete",
+            description:
+              "Patient status was updated and the eligibility PDF was saved.",
+            variant: "default",
+          });
+
+          const pdfId = final?.pdfFileId;
+          if (pdfId) {
+            const filename =
+              final?.pdfFilename ?? `eligibility_dentaquest_${memberId}.pdf`;
+            onPdfReady(Number(pdfId), filename);
+          }
+
+          setSessionId(null);
+          setOtpModalOpen(false);
+        } else if (status === "error") {
+          const msg =
+            payload?.message ||
+            final?.error ||
+            "DentaQuest eligibility session failed.";
+          dispatch(
+            setTaskStatus({
+              status: "error",
+              message: msg,
+            })
+          );
+          toast({
+            title: "DentaQuest selenium error",
+            description: msg,
+            variant: "destructive",
+          });
+
+          // Ensure socket is torn down for this session (stop receiving stale events)
+          try {
+            closeSocket();
+          } catch (e) {}
+          setSessionId(null);
+          setOtpModalOpen(false);
+        }
+
+        queryClient.invalidateQueries({ queryKey: QK_PATIENTS_BASE });
+      });
+
+      // explicit session error event (helpful)
+      socket.on("selenium:session_error", (payload: any) => {
+        const msg = payload?.message || "Selenium session error";
+
+        dispatch(
+          setTaskStatus({
+            status: "error",
+            message: msg,
+          })
+        );
+
+        toast({
+          title: "Selenium session error",
+          description: msg,
+          variant: "destructive",
+        });
+
+        // tear down socket to avoid stale updates
+        try {
+          closeSocket();
+        } catch (e) {}
+        setSessionId(null);
+        setOtpModalOpen(false);
+      });
+
+      // If socket.io initial connection fails permanently (very rare: client-level)
+      // set a longer timeout to reject the first attempt to connect.
+      const initialConnectTimeout = setTimeout(() => {
+        if (!socket.connected) {
+          // if still not connected after 8s, treat as failure and reject so caller can handle it
+          closeSocket();
+          reject(new Error("Realtime initial connection timeout"));
+        }
+      }, 8000);
+
+      // When the connect resolves we should clear this timer
+      socket.once("connect", () => {
+        clearTimeout(initialConnectTimeout);
+      });
+    });
+
+    // store promise to prevent multiple concurrent connections
+    connectingRef.current = promise;
+
+    try {
+      await promise;
+    } finally {
+      connectingRef.current = null;
+    }
+  };
+
+  const startDentaQuestEligibility = async () => {
+    if (!memberId || !dateOfBirth) {
+      toast({
+        title: "Missing fields",
+        description: "Member ID and Date of Birth are required.",
+        variant: "destructive",
+      });
+      return;
+    }
+
+    const formattedDob = dateOfBirth ? formatLocalDate(dateOfBirth) : "";
+
+    const payload = {
+      memberId,
+      dateOfBirth: formattedDob,
+      firstName,
+      lastName,
+      insuranceSiteKey: "DENTAQUEST", // make sure this matches backend credential key
+    };
+
+    try {
+      setIsStarting(true);
+
+      // 1) Ensure socket is connected (lazy)
+      dispatch(
+        setTaskStatus({
+          status: "pending",
+          message: "Opening realtime channel for DentaQuest eligibility...",
+        })
+      );
+      await ensureSocketConnected();
+
+      const socket = socketRef.current;
+      if (!socket || !socket.connected) {
+        throw new Error("Socket connection failed");
+      }
+
+      const socketId = socket.id;
+
+      // 2) Start the selenium job via backend
+      dispatch(
+        setTaskStatus({
+          status: "pending",
+          message: "Starting DentaQuest eligibility check via selenium...",
+        })
+      );
+
+      const response = await apiRequest(
+        "POST",
+        "/api/insurance-status-dentaquest/dentaquest-eligibility",
+        {
+          data: JSON.stringify(payload),
+          socketId,
+        }
+      );
+
+      // If apiRequest threw, we would have caught above; but just in case it returns.
+      let result: any = null;
+      let backendError: string | null = null;
+
+      try {
+        // attempt JSON first
+        result = await response.clone().json();
+        backendError =
+          result?.error || result?.message || result?.detail || null;
+      } catch {
+        // fallback to text response
+        try {
+          const text = await response.clone().text();
+          backendError = text?.trim() || null;
+        } catch {
+          backendError = null;
+        }
+      }
+
+      if (!response.ok) {
+        throw new Error(
+          backendError ||
+            `DentaQuest selenium start failed (status ${response.status})`
+        );
+      }
+
+      // Normal success path: optional: if backend returns non-error shape still check for result.error
+      if (result?.error) {
+        throw new Error(result.error);
+      }
+
+      if (result.status === "started" && result.session_id) {
+        setSessionId(result.session_id as string);
+        dispatch(
+          setTaskStatus({
+            status: "pending",
+            message:
+              "DentaQuest eligibility job started. Waiting for OTP or final result...",
+          })
+        );
+      } else {
+        // fallback if backend returns immediate result
+        dispatch(
+          setTaskStatus({
+            status: "success",
+            message: "DentaQuest eligibility completed.",
+          })
+        );
+      }
+    } catch (err: any) {
+      console.error("startDentaQuestEligibility error:", err);
+      dispatch(
+        setTaskStatus({
+          status: "error",
+          message: err?.message || "Failed to start DentaQuest eligibility",
+        })
+      );
+      toast({
+        title: "DentaQuest selenium error",
+        description: err?.message || "Failed to start DentaQuest eligibility",
+        variant: "destructive",
+      });
+    } finally {
+      setIsStarting(false);
+    }
+  };
+
+  const handleSubmitOtp = async (otp: string) => {
+    if (!sessionId || !socketRef.current || !socketRef.current.connected) {
+      toast({
+        title: "Session not ready",
+        description:
+          "Could not submit OTP because the DentaQuest session or socket is not ready.",
+        variant: "destructive",
+      });
+      return;
+    }
+
+    try {
+      setIsSubmittingOtp(true);
+      const resp = await apiRequest(
+        "POST",
+        "/api/insurance-status-dentaquest/selenium/submit-otp",
+        {
+          session_id: sessionId,
+          otp,
+          socketId: socketRef.current.id,
+        }
+      );
+      const data = await resp.json();
+      if (!resp.ok || data.error) {
+        throw new Error(data.error || "Failed to submit OTP");
+      }
+
+      // from here we rely on websocket events (otp_submitted + session_update)
+      setOtpModalOpen(false);
+    } catch (err: any) {
+      console.error("handleSubmitOtp error:", err);
+      toast({
+        title: "Failed to submit OTP",
+        description: err?.message || "Error forwarding OTP to selenium agent",
+        variant: "destructive",
+      });
+    } finally {
+      setIsSubmittingOtp(false);
+    }
+  };
+
+  return (
+    <>
+      <Button
+        className="w-full"
+        variant="outline"
+        disabled={isFormIncomplete || isStarting}
+        onClick={startDentaQuestEligibility}
+      >
+        {isStarting ? (
+          <>
+            <LoaderCircleIcon className="h-4 w-4 mr-2 animate-spin" />
+            Processing...
+          </>
+        ) : (
+          <>
+            <CheckCircle className="h-4 w-4 mr-2" />
+            Tufts SCO/SWH/Navi/Mass Gen
+          </>
+        )}
+      </Button>
+
+      <DentaQuestOtpModal
+        open={otpModalOpen}
+        onClose={() => setOtpModalOpen(false)}
+        onSubmit={handleSubmitOtp}
+        isSubmitting={isSubmittingOtp}
+      />
+    </>
+  );
+}
+

apps/Frontend/src/pages/insurance-status-page.tsx

@@ -28,6 +28,7 @@ import { QK_PATIENTS_BASE } from "@/components/patients/patient-table";
 import { PdfPreviewModal } from "@/components/insurance-status/pdf-preview-modal";
 import { useLocation } from "wouter";
 import { DdmaEligibilityButton } from "@/components/insurance-status/ddma-buton-modal";
+import { DentaQuestEligibilityButton } from "@/components/insurance-status/dentaquest-button-modal";
 
 export default function InsuranceStatusPage() {
   const { user } = useAuth();
@@ -616,14 +617,20 @@ export default function InsuranceStatusPage() {
 
               {/* Row 2 */}
               <div className="grid grid-cols-1 md:grid-cols-3 gap-4">
-                <Button
+                <DentaQuestEligibilityButton
-                  className="w-full"
+                  memberId={memberId}
-                  variant="outline"
+                  dateOfBirth={dateOfBirth}
-                  disabled={isFormIncomplete}
+                  firstName={firstName}
-                >
+                  lastName={lastName}
-                  <CheckCircle className="h-4 w-4 mr-2" />
+                  isFormIncomplete={isFormIncomplete}
-                  Tufts SCO/SWH/Navi/Mass Gen
+                  onPdfReady={(pdfId, fallbackFilename) => {
-                </Button>
+                    setPreviewPdfId(pdfId);
+                    setPreviewFallbackFilename(
+                      fallbackFilename ?? `eligibility_dentaquest_${memberId}.pdf`
+                    );
+                    setPreviewOpen(true);
+                  }}
+                />
 
                 <Button
                   className="w-full"

apps/SeleniumService/agent.py

@@ -9,10 +9,26 @@ from selenium_preAuthWorker import AutomationMassHealthPreAuth
 import os
 import time
 import helpers_ddma_eligibility as hddma
+import helpers_dentaquest_eligibility as hdentaquest
+
+# Import session clear functions for startup
+from ddma_browser_manager import clear_ddma_session_on_startup
+from dentaquest_browser_manager import clear_dentaquest_session_on_startup
 
 from dotenv import load_dotenv
 load_dotenv() 
 
+# Clear all sessions on startup (after PC restart)
+# This ensures users must login again after PC restart
+print("=" * 50)
+print("SELENIUM AGENT STARTING - CLEARING ALL SESSIONS")
+print("=" * 50)
+clear_ddma_session_on_startup()
+clear_dentaquest_session_on_startup()
+print("=" * 50)
+print("SESSION CLEAR COMPLETE - FRESH LOGINS REQUIRED")
+print("=" * 50)
+
 app = FastAPI()
 # Allow 1 selenium session at a time
 semaphore = asyncio.Semaphore(1)
@@ -186,6 +202,79 @@ async def ddma_eligibility(request: Request):
     return {"status": "started", "session_id": sid}
 
 
+# Endpoint:6 - DentaQuest eligibility (background, OTP)
+
+async def _dentaquest_worker_wrapper(sid: str, data: dict, url: str):
+    """
+    Background worker that:
+      - acquires semaphore (to keep 1 selenium at a time),
+      - updates active/queued counters,
+      - runs the DentaQuest flow via helpers.start_dentaquest_run.
+    """
+    global active_jobs, waiting_jobs
+    async with semaphore:
+        async with lock:
+            waiting_jobs -= 1
+            active_jobs += 1
+        try:
+            await hdentaquest.start_dentaquest_run(sid, data, url)
+        finally:
+            async with lock:
+                active_jobs -= 1
+
+
+@app.post("/dentaquest-eligibility")
+async def dentaquest_eligibility(request: Request):
+    """
+    Starts a DentaQuest eligibility session in the background.
+    Body: { "data": { ... }, "url"?: string }
+    Returns: { status: "started", session_id: "<uuid>" }
+    """
+    global waiting_jobs
+
+    body = await request.json()
+    data = body.get("data", {})
+
+    # create session
+    sid = hdentaquest.make_session_entry()
+    hdentaquest.sessions[sid]["type"] = "dentaquest_eligibility"
+    hdentaquest.sessions[sid]["last_activity"] = time.time()
+
+    async with lock:
+        waiting_jobs += 1
+
+    # run in background (queued under semaphore)
+    asyncio.create_task(_dentaquest_worker_wrapper(sid, data, url="https://providers.dentaquest.com/onboarding/start/"))
+
+    return {"status": "started", "session_id": sid}
+
+
+@app.post("/dentaquest-submit-otp")
+async def dentaquest_submit_otp(request: Request):
+    """
+    Body: { "session_id": "<sid>", "otp": "123456" }
+    Node / frontend call this when user provides OTP for DentaQuest.
+    """
+    body = await request.json()
+    sid = body.get("session_id")
+    otp = body.get("otp")
+    if not sid or not otp:
+        raise HTTPException(status_code=400, detail="session_id and otp required")
+
+    res = hdentaquest.submit_otp(sid, otp)
+    if res.get("status") == "error":
+        raise HTTPException(status_code=400, detail=res.get("message"))
+    return res
+
+
+@app.get("/dentaquest-session/{sid}/status")
+async def dentaquest_session_status(sid: str):
+    s = hdentaquest.get_session_status(sid)
+    if s.get("status") == "not_found":
+        raise HTTPException(status_code=404, detail="session not found")
+    return s
+
+
 @app.post("/submit-otp")
 async def submit_otp(request: Request):
     """

apps/SeleniumService/ddma_browser_manager.py

@@ -1,19 +1,28 @@
 """
 Minimal browser manager for DDMA - only handles persistent profile and keeping browser alive.
-Does NOT modify any login/OTP logic.
+Clears session cookies on startup (after PC restart) to force fresh login.
+Tracks credentials to detect changes mid-session.
 """
 import os
+import glob
+import shutil
+import hashlib
 import threading
 from selenium import webdriver
 from selenium.webdriver.chrome.service import Service
 from webdriver_manager.chrome import ChromeDriverManager
 
+# Ensure DISPLAY is set for Chrome to work (needed when running from SSH/background)
+if not os.environ.get("DISPLAY"):
+    os.environ["DISPLAY"] = ":0"
+
 
 class DDMABrowserManager:
     """
     Singleton that manages a persistent Chrome browser instance.
-    - Uses --user-data-dir for persistent profile (device trust tokens, cookies)
+    - Uses --user-data-dir for persistent profile (device trust tokens)
-    - Keeps browser alive between patient runs
+    - Clears session cookies on startup (after PC restart)
+    - Tracks credentials to detect changes mid-session
     """
     _instance = None
     _lock = threading.Lock()
@@ -25,31 +34,188 @@ class DDMABrowserManager:
                 cls._instance._driver = None
                 cls._instance.profile_dir = os.path.abspath("chrome_profile_ddma")
                 cls._instance.download_dir = os.path.abspath("seleniumDownloads")
+                cls._instance._credentials_file = os.path.join(cls._instance.profile_dir, ".last_credentials")
+                cls._instance._needs_session_clear = False  # Flag to clear session on next driver creation
                 os.makedirs(cls._instance.profile_dir, exist_ok=True)
                 os.makedirs(cls._instance.download_dir, exist_ok=True)
         return cls._instance
     
+    def clear_session_on_startup(self):
+        """
+        Clear session cookies from Chrome profile on startup.
+        This forces a fresh login after PC restart.
+        Preserves device trust tokens (LocalStorage, IndexedDB) to avoid OTPs.
+        """
+        print("[DDMA BrowserManager] Clearing session on startup...")
+        
+        try:
+            # Clear the credentials tracking file
+            if os.path.exists(self._credentials_file):
+                os.remove(self._credentials_file)
+                print("[DDMA BrowserManager] Cleared credentials tracking file")
+            
+            # Clear session-related files from Chrome profile
+            # These are the files that store login session cookies
+            session_files = [
+                "Cookies",
+                "Cookies-journal",
+                "Login Data",
+                "Login Data-journal",
+                "Web Data",
+                "Web Data-journal",
+            ]
+            
+            for filename in session_files:
+                filepath = os.path.join(self.profile_dir, "Default", filename)
+                if os.path.exists(filepath):
+                    try:
+                        os.remove(filepath)
+                        print(f"[DDMA BrowserManager] Removed {filename}")
+                    except Exception as e:
+                        print(f"[DDMA BrowserManager] Could not remove {filename}: {e}")
+            
+            # Also try root level (some Chrome versions)
+            for filename in session_files:
+                filepath = os.path.join(self.profile_dir, filename)
+                if os.path.exists(filepath):
+                    try:
+                        os.remove(filepath)
+                        print(f"[DDMA BrowserManager] Removed root {filename}")
+                    except Exception as e:
+                        print(f"[DDMA BrowserManager] Could not remove root {filename}: {e}")
+            
+            # Clear Session Storage (contains login state)
+            session_storage_dir = os.path.join(self.profile_dir, "Default", "Session Storage")
+            if os.path.exists(session_storage_dir):
+                try:
+                    shutil.rmtree(session_storage_dir)
+                    print("[DDMA BrowserManager] Cleared Session Storage")
+                except Exception as e:
+                    print(f"[DDMA BrowserManager] Could not clear Session Storage: {e}")
+            
+            # Clear Local Storage (may contain auth tokens)
+            local_storage_dir = os.path.join(self.profile_dir, "Default", "Local Storage")
+            if os.path.exists(local_storage_dir):
+                try:
+                    shutil.rmtree(local_storage_dir)
+                    print("[DDMA BrowserManager] Cleared Local Storage")
+                except Exception as e:
+                    print(f"[DDMA BrowserManager] Could not clear Local Storage: {e}")
+            
+            # Clear IndexedDB (may contain auth tokens)
+            indexeddb_dir = os.path.join(self.profile_dir, "Default", "IndexedDB")
+            if os.path.exists(indexeddb_dir):
+                try:
+                    shutil.rmtree(indexeddb_dir)
+                    print("[DDMA BrowserManager] Cleared IndexedDB")
+                except Exception as e:
+                    print(f"[DDMA BrowserManager] Could not clear IndexedDB: {e}")
+            
+            # Set flag to clear session via JavaScript after browser opens
+            self._needs_session_clear = True
+            
+            print("[DDMA BrowserManager] Session cleared - will require fresh login")
+            
+        except Exception as e:
+            print(f"[DDMA BrowserManager] Error clearing session: {e}")
+    
+    def _hash_credentials(self, username: str) -> str:
+        """Create a hash of the username to track credential changes."""
+        return hashlib.sha256(username.encode()).hexdigest()[:16]
+    
+    def get_last_credentials_hash(self) -> str | None:
+        """Get the hash of the last-used credentials."""
+        try:
+            if os.path.exists(self._credentials_file):
+                with open(self._credentials_file, 'r') as f:
+                    return f.read().strip()
+        except Exception:
+            pass
+        return None
+    
+    def save_credentials_hash(self, username: str):
+        """Save the hash of the current credentials."""
+        try:
+            cred_hash = self._hash_credentials(username)
+            with open(self._credentials_file, 'w') as f:
+                f.write(cred_hash)
+        except Exception as e:
+            print(f"[DDMA BrowserManager] Failed to save credentials hash: {e}")
+    
+    def credentials_changed(self, username: str) -> bool:
+        """Check if the credentials have changed since last login."""
+        last_hash = self.get_last_credentials_hash()
+        if last_hash is None:
+            return False  # No previous credentials, not a change
+        current_hash = self._hash_credentials(username)
+        changed = last_hash != current_hash
+        if changed:
+            print(f"[DDMA BrowserManager] Credentials changed - logout required")
+        return changed
+    
+    def clear_credentials_hash(self):
+        """Clear the saved credentials hash (used after logout)."""
+        try:
+            if os.path.exists(self._credentials_file):
+                os.remove(self._credentials_file)
+        except Exception as e:
+            print(f"[DDMA BrowserManager] Failed to clear credentials hash: {e}")
+
+    def _kill_existing_chrome_for_profile(self):
+        """Kill any existing Chrome processes using this profile and clean up locks."""
+        import subprocess
+        import time as time_module
+        try:
+            # Find and kill Chrome processes using this profile
+            result = subprocess.run(
+                ["pgrep", "-f", f"user-data-dir={self.profile_dir}"],
+                capture_output=True, text=True
+            )
+            if result.stdout.strip():
+                pids = result.stdout.strip().split('\n')
+                for pid in pids:
+                    try:
+                        subprocess.run(["kill", "-9", pid], check=False)
+                    except:
+                        pass
+                time_module.sleep(1)
+        except Exception:
+            pass
+        
+        # Remove lock files if they exist
+        for lock_file in ["SingletonLock", "SingletonSocket", "SingletonCookie"]:
+            lock_path = os.path.join(self.profile_dir, lock_file)
+            try:
+                if os.path.islink(lock_path) or os.path.exists(lock_path):
+                    os.remove(lock_path)
+            except:
+                pass
+
     def get_driver(self, headless=False):
         """Get or create the persistent browser instance."""
         with self._lock:
             if self._driver is None:
-                print("[BrowserManager] Driver is None, creating new driver")
+                print("[DDMA BrowserManager] Driver is None, creating new driver")
+                self._kill_existing_chrome_for_profile()
                 self._create_driver(headless)
             elif not self._is_alive():
-                print("[BrowserManager] Driver not alive, recreating")
+                print("[DDMA BrowserManager] Driver not alive, recreating")
+                self._kill_existing_chrome_for_profile()
                 self._create_driver(headless)
             else:
-                print("[BrowserManager] Reusing existing driver")
+                print("[DDMA BrowserManager] Reusing existing driver")
             return self._driver
 
     def _is_alive(self):
         """Check if browser is still responsive."""
         try:
+            if self._driver is None:
+                return False
             url = self._driver.current_url
-            print(f"[BrowserManager] Driver alive, current URL: {url[:50]}...")
+            print(f"[DDMA BrowserManager] Driver alive, current URL: {url[:50]}...")
             return True
         except Exception as e:
-            print(f"[BrowserManager] Driver not alive: {e}")
+            print(f"[DDMA BrowserManager] Driver not alive: {e}")
             return False
 
     def _create_driver(self, headless=False):
@@ -81,6 +247,9 @@ class DDMABrowserManager:
         self._driver = webdriver.Chrome(service=service, options=options)
         self._driver.maximize_window()
         
+        # Reset the session clear flag (file-based clearing is done on startup)
+        self._needs_session_clear = False
+
     def quit_driver(self):
         """Quit browser (only call on shutdown)."""
         with self._lock:
@@ -100,3 +269,9 @@ def get_browser_manager():
     if _manager is None:
         _manager = DDMABrowserManager()
     return _manager
+
+
+def clear_ddma_session_on_startup():
+    """Called by agent.py on startup to clear session."""
+    manager = get_browser_manager()
+    manager.clear_session_on_startup()

apps/SeleniumService/dentaquest_browser_manager.py

@@ -0,0 +1,277 @@
+"""
+Minimal browser manager for DentaQuest - only handles persistent profile and keeping browser alive.
+Clears session cookies on startup (after PC restart) to force fresh login.
+Tracks credentials to detect changes mid-session.
+"""
+import os
+import shutil
+import hashlib
+import threading
+import subprocess
+import time
+from selenium import webdriver
+from selenium.webdriver.chrome.service import Service
+from webdriver_manager.chrome import ChromeDriverManager
+
+# Ensure DISPLAY is set for Chrome to work (needed when running from SSH/background)
+if not os.environ.get("DISPLAY"):
+    os.environ["DISPLAY"] = ":0"
+
+
+class DentaQuestBrowserManager:
+    """
+    Singleton that manages a persistent Chrome browser instance for DentaQuest.
+    - Uses --user-data-dir for persistent profile (device trust tokens)
+    - Clears session cookies on startup (after PC restart)
+    - Tracks credentials to detect changes mid-session
+    """
+    _instance = None
+    _lock = threading.Lock()
+
+    def __new__(cls):
+        with cls._lock:
+            if cls._instance is None:
+                cls._instance = super().__new__(cls)
+                cls._instance._driver = None
+                cls._instance.profile_dir = os.path.abspath("chrome_profile_dentaquest")
+                cls._instance.download_dir = os.path.abspath("seleniumDownloads")
+                cls._instance._credentials_file = os.path.join(cls._instance.profile_dir, ".last_credentials")
+                cls._instance._needs_session_clear = False  # Flag to clear session on next driver creation
+                os.makedirs(cls._instance.profile_dir, exist_ok=True)
+                os.makedirs(cls._instance.download_dir, exist_ok=True)
+        return cls._instance
+
+    def clear_session_on_startup(self):
+        """
+        Clear session cookies from Chrome profile on startup.
+        This forces a fresh login after PC restart.
+        Preserves device trust tokens (LocalStorage, IndexedDB) to avoid OTPs.
+        """
+        print("[DentaQuest BrowserManager] Clearing session on startup...")
+        
+        try:
+            # Clear the credentials tracking file
+            if os.path.exists(self._credentials_file):
+                os.remove(self._credentials_file)
+                print("[DentaQuest BrowserManager] Cleared credentials tracking file")
+            
+            # Clear session-related files from Chrome profile
+            # These are the files that store login session cookies
+            session_files = [
+                "Cookies",
+                "Cookies-journal",
+                "Login Data",
+                "Login Data-journal",
+                "Web Data",
+                "Web Data-journal",
+            ]
+            
+            for filename in session_files:
+                filepath = os.path.join(self.profile_dir, "Default", filename)
+                if os.path.exists(filepath):
+                    try:
+                        os.remove(filepath)
+                        print(f"[DentaQuest BrowserManager] Removed {filename}")
+                    except Exception as e:
+                        print(f"[DentaQuest BrowserManager] Could not remove {filename}: {e}")
+            
+            # Also try root level (some Chrome versions)
+            for filename in session_files:
+                filepath = os.path.join(self.profile_dir, filename)
+                if os.path.exists(filepath):
+                    try:
+                        os.remove(filepath)
+                        print(f"[DentaQuest BrowserManager] Removed root {filename}")
+                    except Exception as e:
+                        print(f"[DentaQuest BrowserManager] Could not remove root {filename}: {e}")
+            
+            # Clear Session Storage (contains login state)
+            session_storage_dir = os.path.join(self.profile_dir, "Default", "Session Storage")
+            if os.path.exists(session_storage_dir):
+                try:
+                    shutil.rmtree(session_storage_dir)
+                    print("[DentaQuest BrowserManager] Cleared Session Storage")
+                except Exception as e:
+                    print(f"[DentaQuest BrowserManager] Could not clear Session Storage: {e}")
+            
+            # Clear Local Storage (may contain auth tokens)
+            local_storage_dir = os.path.join(self.profile_dir, "Default", "Local Storage")
+            if os.path.exists(local_storage_dir):
+                try:
+                    shutil.rmtree(local_storage_dir)
+                    print("[DentaQuest BrowserManager] Cleared Local Storage")
+                except Exception as e:
+                    print(f"[DentaQuest BrowserManager] Could not clear Local Storage: {e}")
+            
+            # Clear IndexedDB (may contain auth tokens)
+            indexeddb_dir = os.path.join(self.profile_dir, "Default", "IndexedDB")
+            if os.path.exists(indexeddb_dir):
+                try:
+                    shutil.rmtree(indexeddb_dir)
+                    print("[DentaQuest BrowserManager] Cleared IndexedDB")
+                except Exception as e:
+                    print(f"[DentaQuest BrowserManager] Could not clear IndexedDB: {e}")
+            
+            # Set flag to clear session via JavaScript after browser opens
+            self._needs_session_clear = True
+            
+            print("[DentaQuest BrowserManager] Session cleared - will require fresh login")
+            
+        except Exception as e:
+            print(f"[DentaQuest BrowserManager] Error clearing session: {e}")
+
+    def _hash_credentials(self, username: str) -> str:
+        """Create a hash of the username to track credential changes."""
+        return hashlib.sha256(username.encode()).hexdigest()[:16]
+    
+    def get_last_credentials_hash(self) -> str | None:
+        """Get the hash of the last-used credentials."""
+        try:
+            if os.path.exists(self._credentials_file):
+                with open(self._credentials_file, 'r') as f:
+                    return f.read().strip()
+        except Exception:
+            pass
+        return None
+    
+    def save_credentials_hash(self, username: str):
+        """Save the hash of the current credentials."""
+        try:
+            cred_hash = self._hash_credentials(username)
+            with open(self._credentials_file, 'w') as f:
+                f.write(cred_hash)
+        except Exception as e:
+            print(f"[DentaQuest BrowserManager] Failed to save credentials hash: {e}")
+    
+    def credentials_changed(self, username: str) -> bool:
+        """Check if the credentials have changed since last login."""
+        last_hash = self.get_last_credentials_hash()
+        if last_hash is None:
+            return False  # No previous credentials, not a change
+        current_hash = self._hash_credentials(username)
+        changed = last_hash != current_hash
+        if changed:
+            print(f"[DentaQuest BrowserManager] Credentials changed - logout required")
+        return changed
+    
+    def clear_credentials_hash(self):
+        """Clear the saved credentials hash (used after logout)."""
+        try:
+            if os.path.exists(self._credentials_file):
+                os.remove(self._credentials_file)
+        except Exception as e:
+            print(f"[DentaQuest BrowserManager] Failed to clear credentials hash: {e}")
+
+    def _kill_existing_chrome_for_profile(self):
+        """Kill any existing Chrome processes using this profile."""
+        try:
+            # Find and kill Chrome processes using this profile
+            result = subprocess.run(
+                ["pgrep", "-f", f"user-data-dir={self.profile_dir}"],
+                capture_output=True, text=True
+            )
+            if result.stdout.strip():
+                pids = result.stdout.strip().split('\n')
+                for pid in pids:
+                    try:
+                        subprocess.run(["kill", "-9", pid], check=False)
+                    except:
+                        pass
+                time.sleep(1)
+        except Exception as e:
+            pass
+        
+        # Remove SingletonLock if exists
+        lock_file = os.path.join(self.profile_dir, "SingletonLock")
+        try:
+            if os.path.islink(lock_file) or os.path.exists(lock_file):
+                os.remove(lock_file)
+        except:
+            pass
+
+    def get_driver(self, headless=False):
+        """Get or create the persistent browser instance."""
+        with self._lock:
+            if self._driver is None:
+                print("[DentaQuest BrowserManager] Driver is None, creating new driver")
+                self._kill_existing_chrome_for_profile()
+                self._create_driver(headless)
+            elif not self._is_alive():
+                print("[DentaQuest BrowserManager] Driver not alive, recreating")
+                self._kill_existing_chrome_for_profile()
+                self._create_driver(headless)
+            else:
+                print("[DentaQuest BrowserManager] Reusing existing driver")
+            return self._driver
+
+    def _is_alive(self):
+        """Check if browser is still responsive."""
+        try:
+            if self._driver is None:
+                return False
+            url = self._driver.current_url
+            return True
+        except Exception as e:
+            return False
+
+    def _create_driver(self, headless=False):
+        """Create browser with persistent profile."""
+        if self._driver:
+            try:
+                self._driver.quit()
+            except:
+                pass
+            self._driver = None
+            time.sleep(1)
+
+        options = webdriver.ChromeOptions()
+        if headless:
+            options.add_argument("--headless")
+        
+        # Persistent profile - THIS IS THE KEY for device trust
+        options.add_argument(f"--user-data-dir={self.profile_dir}")
+        options.add_argument("--no-sandbox")
+        options.add_argument("--disable-dev-shm-usage")
+        
+        prefs = {
+            "download.default_directory": self.download_dir,
+            "plugins.always_open_pdf_externally": True,
+            "download.prompt_for_download": False,
+            "download.directory_upgrade": True
+        }
+        options.add_experimental_option("prefs", prefs)
+
+        service = Service(ChromeDriverManager().install())
+        self._driver = webdriver.Chrome(service=service, options=options)
+        self._driver.maximize_window()
+        
+        # Reset the session clear flag (file-based clearing is done on startup)
+        self._needs_session_clear = False
+
+    def quit_driver(self):
+        """Quit browser (only call on shutdown)."""
+        with self._lock:
+            if self._driver:
+                try:
+                    self._driver.quit()
+                except:
+                    pass
+                self._driver = None
+            # Also clean up any orphaned processes
+            self._kill_existing_chrome_for_profile()
+
+
+# Singleton accessor
+_manager = None
+
+def get_browser_manager():
+    global _manager
+    if _manager is None:
+        _manager = DentaQuestBrowserManager()
+    return _manager
+
+
+def clear_dentaquest_session_on_startup():
+    """Called by agent.py on startup to clear session."""
+    manager = get_browser_manager()
+    manager.clear_session_on_startup()

apps/SeleniumService/helpers_dentaquest_eligibility.py

@@ -0,0 +1,264 @@
+import os
+import time
+import asyncio
+from typing import Dict, Any
+from selenium.webdriver.common.by import By
+from selenium.webdriver.support.ui import WebDriverWait
+from selenium.webdriver.support import expected_conditions as EC
+from selenium.common.exceptions import WebDriverException
+
+from selenium_DentaQuest_eligibilityCheckWorker import AutomationDentaQuestEligibilityCheck
+
+# In-memory session store
+sessions: Dict[str, Dict[str, Any]] = {}
+
+SESSION_OTP_TIMEOUT = int(os.getenv("SESSION_OTP_TIMEOUT", "120"))  # seconds
+
+
+def make_session_entry() -> str:
+    """Create a new session entry and return its ID."""
+    import uuid
+    sid = str(uuid.uuid4())
+    sessions[sid] = {
+        "status": "created",     # created -> running -> waiting_for_otp -> otp_submitted -> completed / error
+        "created_at": time.time(),
+        "last_activity": time.time(),
+        "bot": None,             # worker instance
+        "driver": None,          # selenium webdriver
+        "otp_event": asyncio.Event(),
+        "otp_value": None,
+        "result": None,
+        "message": None,
+        "type": None,
+    }
+    return sid
+
+
+async def cleanup_session(sid: str, message: str | None = None):
+    """
+    Close driver (if any), wake OTP waiter, set final state, and remove session entry.
+    Idempotent: safe to call multiple times.
+    """
+    s = sessions.get(sid)
+    if not s:
+        return
+    try:
+        # Ensure final state
+        try:
+            if s.get("status") not in ("completed", "error", "not_found"):
+                s["status"] = "error"
+            if message:
+                s["message"] = message
+        except Exception:
+            pass
+
+        # Wake any OTP waiter (so awaiting coroutines don't hang)
+        try:
+            ev = s.get("otp_event")
+            if ev and not ev.is_set():
+                ev.set()
+        except Exception:
+            pass
+
+        # NOTE: Do NOT quit driver - keep browser alive for next patient
+        # Browser manager handles the persistent browser instance
+
+    finally:
+        # Remove session entry from map
+        sessions.pop(sid, None)
+
+
+async def _remove_session_later(sid: str, delay: int = 20):
+    await asyncio.sleep(delay)
+    await cleanup_session(sid)
+
+
+async def start_dentaquest_run(sid: str, data: dict, url: str):
+    """
+    Run the DentaQuest workflow for a session (WITHOUT managing semaphore/counters).
+    Called by agent.py inside a wrapper that handles queue/counters.
+    """
+    s = sessions.get(sid)
+    if not s:
+        return {"status": "error", "message": "session not found"}
+
+    s["status"] = "running"
+    s["last_activity"] = time.time()
+
+    try:
+        bot = AutomationDentaQuestEligibilityCheck({"data": data})
+        bot.config_driver()
+
+        s["bot"] = bot
+        s["driver"] = bot.driver
+        s["last_activity"] = time.time()
+
+        # Navigate to login URL
+        try:
+            if not url:
+                raise ValueError("URL not provided for DentaQuest run")
+            bot.driver.maximize_window()
+            bot.driver.get(url)
+            await asyncio.sleep(1)
+        except Exception as e:
+            s["status"] = "error"
+            s["message"] = f"Navigation failed: {e}"
+            await cleanup_session(sid)
+            return {"status": "error", "message": s["message"]}
+
+        # Login
+        try:
+            login_result = bot.login(url)
+        except WebDriverException as wde:
+            s["status"] = "error"
+            s["message"] = f"Selenium driver error during login: {wde}"
+            await cleanup_session(sid, s["message"])
+            return {"status": "error", "message": s["message"]}
+        except Exception as e:
+            s["status"] = "error"
+            s["message"] = f"Unexpected error during login: {e}"
+            await cleanup_session(sid, s["message"])
+            return {"status": "error", "message": s["message"]}
+
+        # Already logged in - session persisted from profile, skip to step1
+        if isinstance(login_result, str) and login_result == "ALREADY_LOGGED_IN":
+            s["status"] = "running"
+            s["message"] = "Session persisted"
+            # Continue to step1 below
+
+        # OTP required path
+        elif isinstance(login_result, str) and login_result == "OTP_REQUIRED":
+            s["status"] = "waiting_for_otp"
+            s["message"] = "OTP required for login"
+            s["last_activity"] = time.time()
+
+            try:
+                await asyncio.wait_for(s["otp_event"].wait(), timeout=SESSION_OTP_TIMEOUT)
+            except asyncio.TimeoutError:
+                s["status"] = "error"
+                s["message"] = "OTP timeout"
+                await cleanup_session(sid)
+                return {"status": "error", "message": "OTP not provided in time"}
+
+            otp_value = s.get("otp_value")
+            if not otp_value:
+                s["status"] = "error"
+                s["message"] = "OTP missing after event"
+                await cleanup_session(sid)
+                return {"status": "error", "message": "OTP missing after event"}
+
+            # Submit OTP
+            try:
+                driver = s["driver"]
+                wait = WebDriverWait(driver, 30)
+                
+                # Check if there's a popup window and switch to it
+                original_window = driver.current_window_handle
+                all_windows = driver.window_handles
+                if len(all_windows) > 1:
+                    for window in all_windows:
+                        if window != original_window:
+                            driver.switch_to.window(window)
+                            break
+
+                # DentaQuest OTP input field - adjust selectors as needed
+                otp_input = wait.until(
+                    EC.presence_of_element_located(
+                        (By.XPATH, "//input[contains(@name,'otp') or contains(@name,'code') or contains(@placeholder,'code') or contains(@id,'otp') or @type='tel']")
+                    )
+                )
+                otp_input.clear()
+                otp_input.send_keys(otp_value)
+
+                try:
+                    submit_btn = wait.until(
+                        EC.element_to_be_clickable(
+                            (By.XPATH, "//button[contains(text(),'Verify') or contains(text(),'Submit') or contains(text(),'Continue') or @type='submit']")
+                        )
+                    )
+                    submit_btn.click()
+                except Exception:
+                    otp_input.send_keys("\n")
+                
+                # Wait for verification and switch back to main window if needed
+                await asyncio.sleep(2)
+                if len(driver.window_handles) > 0:
+                    driver.switch_to.window(driver.window_handles[0])
+
+                s["status"] = "otp_submitted"
+                s["last_activity"] = time.time()
+                await asyncio.sleep(0.5)
+
+            except Exception as e:
+                s["status"] = "error"
+                s["message"] = f"Failed to submit OTP into page: {e}"
+                await cleanup_session(sid)
+                return {"status": "error", "message": s["message"]}
+
+        elif isinstance(login_result, str) and login_result.startswith("ERROR"):
+            s["status"] = "error"
+            s["message"] = login_result
+            await cleanup_session(sid)
+            return {"status": "error", "message": login_result}
+
+        # Step 1
+        step1_result = bot.step1()
+        if isinstance(step1_result, str) and step1_result.startswith("ERROR"):
+            s["status"] = "error"
+            s["message"] = step1_result
+            await cleanup_session(sid)
+            return {"status": "error", "message": step1_result}
+
+        # Step 2 (PDF)
+        step2_result = bot.step2()
+        if isinstance(step2_result, dict) and step2_result.get("status") == "success":
+            s["status"] = "completed"
+            s["result"] = step2_result
+            s["message"] = "completed"
+            asyncio.create_task(_remove_session_later(sid, 30))
+            return step2_result
+        else:
+            s["status"] = "error"
+            if isinstance(step2_result, dict):
+                s["message"] = step2_result.get("message", "unknown error")
+            else:
+                s["message"] = str(step2_result)
+            await cleanup_session(sid)
+            return {"status": "error", "message": s["message"]}
+
+    except Exception as e:
+        s["status"] = "error"
+        s["message"] = f"worker exception: {e}"
+        await cleanup_session(sid)
+        return {"status": "error", "message": s["message"]}
+
+
+def submit_otp(sid: str, otp: str) -> Dict[str, Any]:
+    """Set OTP for a session and wake waiting runner."""
+    s = sessions.get(sid)
+    if not s:
+        return {"status": "error", "message": "session not found"}
+    if s.get("status") != "waiting_for_otp":
+        return {"status": "error", "message": f"session not waiting for otp (state={s.get('status')})"}
+    s["otp_value"] = otp
+    s["last_activity"] = time.time()
+    try:
+        s["otp_event"].set()
+    except Exception:
+        pass
+    return {"status": "ok", "message": "otp accepted"}
+
+
+def get_session_status(sid: str) -> Dict[str, Any]:
+    s = sessions.get(sid)
+    if not s:
+        return {"status": "not_found"}
+    return {
+        "session_id": sid,
+        "status": s.get("status"),
+        "message": s.get("message"),
+        "created_at": s.get("created_at"),
+        "last_activity": s.get("last_activity"),
+        "result": s.get("result") if s.get("status") == "completed" else None,
+    }
+

apps/SeleniumService/selenium_DDMA_eligibilityCheckWorker.py

@@ -34,9 +34,63 @@ class AutomationDeltaDentalMAEligibilityCheck:
         # Use persistent browser from manager (keeps device trust tokens)
         self.driver = get_browser_manager().get_driver(self.headless)
 
+    def _force_logout(self):
+        """Force logout by clearing cookies for Delta Dental domain."""
+        try:
+            print("[DDMA login] Forcing logout due to credential change...")
+            browser_manager = get_browser_manager()
+            
+            # First try to click logout button if visible
+            try:
+                self.driver.get("https://providers.deltadentalma.com/")
+                time.sleep(2)
+                
+                logout_selectors = [
+                    "//button[contains(text(), 'Log out') or contains(text(), 'Logout') or contains(text(), 'Sign out')]",
+                    "//a[contains(text(), 'Log out') or contains(text(), 'Logout') or contains(text(), 'Sign out')]",
+                    "//button[@aria-label='Log out' or @aria-label='Logout' or @aria-label='Sign out']",
+                    "//*[contains(@class, 'logout') or contains(@class, 'signout')]"
+                ]
+                
+                for selector in logout_selectors:
+                    try:
+                        logout_btn = WebDriverWait(self.driver, 3).until(
+                            EC.element_to_be_clickable((By.XPATH, selector))
+                        )
+                        logout_btn.click()
+                        print("[DDMA login] Clicked logout button")
+                        time.sleep(2)
+                        break
+                    except TimeoutException:
+                        continue
+            except Exception as e:
+                print(f"[DDMA login] Could not click logout button: {e}")
+            
+            # Clear cookies as backup
+            try:
+                self.driver.delete_all_cookies()
+                print("[DDMA login] Cleared all cookies")
+            except Exception as e:
+                print(f"[DDMA login] Error clearing cookies: {e}")
+            
+            browser_manager.clear_credentials_hash()
+            print("[DDMA login] Logout complete")
+            return True
+        except Exception as e:
+            print(f"[DDMA login] Error during forced logout: {e}")
+            return False
+
     def login(self, url):
         wait = WebDriverWait(self.driver, 30)
+        browser_manager = get_browser_manager()
+        
         try:
+            # Check if credentials have changed - if so, force logout first
+            if self.massddma_username and browser_manager.credentials_changed(self.massddma_username):
+                self._force_logout()
+                self.driver.get(url)
+                time.sleep(2)
+            
             # First check if we're already on a logged-in page (from previous run)
             try:
                 current_url = self.driver.current_url
@@ -179,6 +233,10 @@ class AutomationDeltaDentalMAEligibilityCheck:
             login_button = wait.until(EC.element_to_be_clickable((By.XPATH, "//button[@type='submit' and @aria-label='Sign in']")))
             login_button.click()
             
+            # Save credentials hash after login attempt
+            if self.massddma_username:
+                browser_manager.save_credentials_hash(self.massddma_username)
+
             # OTP detection
             try:
                 otp_candidate = WebDriverWait(self.driver, 30).until(

apps/SeleniumService/selenium_DentaQuest_eligibilityCheckWorker.py

@@ -0,0 +1,479 @@
+from selenium import webdriver
+from selenium.common.exceptions import WebDriverException, TimeoutException
+from selenium.webdriver.chrome.service import Service
+from selenium.webdriver.common.by import By
+from selenium.webdriver.common.keys import Keys
+from selenium.webdriver.support.ui import WebDriverWait
+from selenium.webdriver.support import expected_conditions as EC
+from webdriver_manager.chrome import ChromeDriverManager
+import time
+import os
+import base64
+
+from dentaquest_browser_manager import get_browser_manager
+
+class AutomationDentaQuestEligibilityCheck:    
+    def __init__(self, data):
+        self.headless = False
+        self.driver = None
+
+        self.data = data.get("data", {}) if isinstance(data, dict) else {}
+
+        # Flatten values for convenience
+        self.memberId = self.data.get("memberId", "")
+        self.dateOfBirth = self.data.get("dateOfBirth", "")
+        self.dentaquest_username = self.data.get("dentaquestUsername", "")
+        self.dentaquest_password = self.data.get("dentaquestPassword", "")
+
+        # Use browser manager's download dir
+        self.download_dir = get_browser_manager().download_dir
+        os.makedirs(self.download_dir, exist_ok=True)
+
+    def config_driver(self):
+        # Use persistent browser from manager (keeps device trust tokens)
+        self.driver = get_browser_manager().get_driver(self.headless)
+
+    def _force_logout(self):
+        """Force logout by clearing cookies for DentaQuest domain."""
+        try:
+            print("[DentaQuest login] Forcing logout due to credential change...")
+            browser_manager = get_browser_manager()
+            
+            # First try to click logout button if visible
+            try:
+                self.driver.get("https://providers.dentaquest.com/")
+                time.sleep(2)
+                
+                logout_selectors = [
+                    "//button[contains(text(), 'Log out') or contains(text(), 'Logout') or contains(text(), 'Sign out')]",
+                    "//a[contains(text(), 'Log out') or contains(text(), 'Logout') or contains(text(), 'Sign out')]",
+                    "//button[@aria-label='Log out' or @aria-label='Logout' or @aria-label='Sign out']",
+                    "//*[contains(@class, 'logout') or contains(@class, 'signout')]"
+                ]
+                
+                for selector in logout_selectors:
+                    try:
+                        logout_btn = WebDriverWait(self.driver, 3).until(
+                            EC.element_to_be_clickable((By.XPATH, selector))
+                        )
+                        logout_btn.click()
+                        print("[DentaQuest login] Clicked logout button")
+                        time.sleep(2)
+                        break
+                    except TimeoutException:
+                        continue
+            except Exception as e:
+                print(f"[DentaQuest login] Could not click logout button: {e}")
+            
+            # Clear cookies as backup
+            try:
+                self.driver.delete_all_cookies()
+                print("[DentaQuest login] Cleared all cookies")
+            except Exception as e:
+                print(f"[DentaQuest login] Error clearing cookies: {e}")
+            
+            browser_manager.clear_credentials_hash()
+            print("[DentaQuest login] Logout complete")
+            return True
+        except Exception as e:
+            print(f"[DentaQuest login] Error during forced logout: {e}")
+            return False
+
+    def login(self, url):
+        wait = WebDriverWait(self.driver, 30)
+        browser_manager = get_browser_manager()
+        
+        try:
+            # Check if credentials have changed - if so, force logout first
+            if self.dentaquest_username and browser_manager.credentials_changed(self.dentaquest_username):
+                self._force_logout()
+                self.driver.get(url)
+                time.sleep(2)
+            
+            # First check if we're already on a logged-in page (from previous run)
+            try:
+                current_url = self.driver.current_url
+                print(f"[DentaQuest login] Current URL: {current_url}")
+                
+                # Check if we're already on dashboard with member search
+                if "dashboard" in current_url.lower() or "member" in current_url.lower():
+                    try:
+                        member_search = WebDriverWait(self.driver, 3).until(
+                            EC.presence_of_element_located((By.XPATH, '//input[@placeholder="Search by member ID"]'))
+                        )
+                        print("[DentaQuest login] Already on dashboard with member search")
+                        return "ALREADY_LOGGED_IN"
+                    except TimeoutException:
+                        pass
+            except Exception as e:
+                print(f"[DentaQuest login] Error checking current state: {e}")
+            
+            # Navigate to login URL
+            self.driver.get(url)
+            time.sleep(3)
+            
+            current_url = self.driver.current_url
+            print(f"[DentaQuest login] After navigation URL: {current_url}")
+            
+            # If already on dashboard, we're logged in
+            if "dashboard" in current_url.lower():
+                print("[DentaQuest login] Already on dashboard")
+                return "ALREADY_LOGGED_IN"
+            
+            # Try to dismiss the modal by clicking OK
+            try:
+                ok_button = WebDriverWait(self.driver, 5).until(
+                    EC.element_to_be_clickable((By.XPATH, "//button[normalize-space(text())='Ok' or normalize-space(text())='OK' or normalize-space(text())='Continue']"))
+                )
+                ok_button.click()
+                print("[DentaQuest login] Clicked OK modal button")
+                time.sleep(3)
+            except TimeoutException:
+                print("[DentaQuest login] No OK modal button found")
+            
+            # Check if we're now on dashboard (session was valid)
+            current_url = self.driver.current_url
+            print(f"[DentaQuest login] After modal click URL: {current_url}")
+            
+            if "dashboard" in current_url.lower():
+                # Check for member search input to confirm logged in
+                try:
+                    member_search = WebDriverWait(self.driver, 5).until(
+                        EC.presence_of_element_located((By.XPATH, '//input[@placeholder="Search by member ID"]'))
+                    )
+                    print("[DentaQuest login] Session valid - on dashboard with member search")
+                    return "ALREADY_LOGGED_IN"
+                except TimeoutException:
+                    pass
+            
+            # Check if OTP is required (popup window or OTP input)
+            if len(self.driver.window_handles) > 1:
+                original_window = self.driver.current_window_handle
+                for window in self.driver.window_handles:
+                    if window != original_window:
+                        self.driver.switch_to.window(window)
+                        print("[DentaQuest login] Switched to popup window")
+                        break
+                
+                try:
+                    otp_input = WebDriverWait(self.driver, 5).until(
+                        EC.presence_of_element_located((By.XPATH, "//input[@type='tel' or contains(@placeholder,'code') or contains(@aria-label,'Verification')]"))
+                    )
+                    print("[DentaQuest login] OTP input found in popup")
+                    return "OTP_REQUIRED"
+                except TimeoutException:
+                    self.driver.switch_to.window(original_window)
+            
+            # Check for OTP input on main page
+            try:
+                otp_input = WebDriverWait(self.driver, 3).until(
+                    EC.presence_of_element_located((By.XPATH, "//input[@type='tel' or contains(@placeholder,'code') or contains(@aria-label,'Verification')]"))
+                )
+                print("[DentaQuest login] OTP input found")
+                return "OTP_REQUIRED"
+            except TimeoutException:
+                pass
+            
+            # If still on login page, need to fill credentials
+            if "onboarding" in current_url.lower() or "login" in current_url.lower():
+                print("[DentaQuest login] Need to fill login credentials")
+                
+                try:
+                    email_field = WebDriverWait(self.driver, 10).until(
+                        EC.element_to_be_clickable((By.XPATH, "//input[@name='username' or @type='text']"))
+                    )
+                    email_field.clear()
+                    email_field.send_keys(self.dentaquest_username)
+                    
+                    password_field = wait.until(EC.presence_of_element_located((By.XPATH, "//input[@type='password']")))
+                    password_field.clear()
+                    password_field.send_keys(self.dentaquest_password)
+                    
+                    # Click login button
+                    login_button = wait.until(EC.element_to_be_clickable((By.XPATH, "//button[@type='submit']")))
+                    login_button.click()
+                    print("[DentaQuest login] Submitted login form")
+                    
+                    # Save credentials hash after login attempt
+                    if self.dentaquest_username:
+                        browser_manager.save_credentials_hash(self.dentaquest_username)
+                    
+                    time.sleep(5)
+                    
+                    # Check for OTP after login
+                    try:
+                        otp_input = WebDriverWait(self.driver, 10).until(
+                            EC.presence_of_element_located((By.XPATH, "//input[@type='tel' or contains(@placeholder,'code') or contains(@aria-label,'Verification')]"))
+                        )
+                        return "OTP_REQUIRED"
+                    except TimeoutException:
+                        pass
+                    
+                    # Check if login succeeded
+                    if "dashboard" in self.driver.current_url.lower():
+                        return "SUCCESS"
+                    
+                except TimeoutException:
+                    print("[DentaQuest login] Login form elements not found")
+                    return "ERROR: Login form not found"
+            
+            return "SUCCESS"
+                
+        except Exception as e:
+            print(f"[DentaQuest login] Exception: {e}")
+            return f"ERROR:LOGIN FAILED: {e}"
+
+    def step1(self):
+        """Navigate to member search and enter member ID + DOB"""
+        wait = WebDriverWait(self.driver, 30)
+
+        try:
+            print(f"[DentaQuest step1] Starting member search for ID: {self.memberId}, DOB: {self.dateOfBirth}")
+            
+            # Wait for page to be ready
+            time.sleep(2)
+            
+            # Parse DOB - format: YYYY-MM-DD
+            try:
+                dob_parts = self.dateOfBirth.split("-")
+                dob_year = dob_parts[0]
+                dob_month = dob_parts[1].zfill(2)
+                dob_day = dob_parts[2].zfill(2)
+                print(f"[DentaQuest step1] Parsed DOB: {dob_month}/{dob_day}/{dob_year}")
+            except Exception as e:
+                print(f"[DentaQuest step1] Error parsing DOB: {e}")
+                return "ERROR: PARSING DOB"
+
+            # Get today's date for Date of Service
+            from datetime import datetime
+            today = datetime.now()
+            service_month = str(today.month).zfill(2)
+            service_day = str(today.day).zfill(2)
+            service_year = str(today.year)
+            print(f"[DentaQuest step1] Service date: {service_month}/{service_day}/{service_year}")
+
+            # Helper function to fill contenteditable date spans within a specific container
+            def fill_date_by_testid(testid, month_val, day_val, year_val, field_name):
+                try:
+                    container = self.driver.find_element(By.XPATH, f"//div[@data-testid='{testid}']")
+                    month_elem = container.find_element(By.XPATH, ".//span[@data-type='month' and @contenteditable='true']")
+                    day_elem = container.find_element(By.XPATH, ".//span[@data-type='day' and @contenteditable='true']")
+                    year_elem = container.find_element(By.XPATH, ".//span[@data-type='year' and @contenteditable='true']")
+                    
+                    def replace_with_sendkeys(el, value):
+                        el.click()
+                        time.sleep(0.05)
+                        el.send_keys(Keys.CONTROL, "a")
+                        el.send_keys(Keys.BACKSPACE)
+                        el.send_keys(value)
+
+                    replace_with_sendkeys(month_elem, month_val)
+                    time.sleep(0.1)
+                    replace_with_sendkeys(day_elem, day_val)
+                    time.sleep(0.1)
+                    replace_with_sendkeys(year_elem, year_val)
+                    print(f"[DentaQuest step1] Filled {field_name}: {month_val}/{day_val}/{year_val}")
+                    return True
+                except Exception as e:
+                    print(f"[DentaQuest step1] Error filling {field_name}: {e}")
+                    return False
+
+            # 1. Fill Date of Service with TODAY's date using specific data-testid
+            fill_date_by_testid("member-search_date-of-service", service_month, service_day, service_year, "Date of Service")
+            time.sleep(0.3)
+
+            # 2. Fill Date of Birth with patient's DOB using specific data-testid
+            fill_date_by_testid("member-search_date-of-birth", dob_month, dob_day, dob_year, "Date of Birth")
+            time.sleep(0.3)
+
+            # 3. Fill Member ID
+            member_id_input = wait.until(EC.presence_of_element_located(
+                (By.XPATH, '//input[@placeholder="Search by member ID"]')
+            ))
+            member_id_input.clear()
+            member_id_input.send_keys(self.memberId)
+            print(f"[DentaQuest step1] Entered member ID: {self.memberId}")
+
+            time.sleep(0.3)
+
+            # 4. Click Search button
+            try:
+                search_btn = wait.until(EC.element_to_be_clickable(
+                    (By.XPATH, '//button[@data-testid="member-search_search-button"]')
+                ))
+                search_btn.click()
+                print("[DentaQuest step1] Clicked search button")
+            except TimeoutException:
+                # Fallback
+                try:
+                    search_btn = self.driver.find_element(By.XPATH, '//button[contains(text(),"Search")]')
+                    search_btn.click()
+                    print("[DentaQuest step1] Clicked search button (fallback)")
+                except:
+                    member_id_input.send_keys(Keys.RETURN)
+                    print("[DentaQuest step1] Pressed Enter to search")
+            
+            time.sleep(5)
+            
+            # Check for "no results" error
+            try:
+                error_msg = WebDriverWait(self.driver, 3).until(EC.presence_of_element_located(
+                    (By.XPATH, '//*[contains(@data-testid,"no-results") or contains(@class,"no-results") or contains(text(),"No results") or contains(text(),"not found") or contains(text(),"No member found") or contains(text(),"Nothing was found")]')
+                ))
+                if error_msg and error_msg.is_displayed():
+                    print("[DentaQuest step1] No results found")
+                    return "ERROR: INVALID MEMBERID OR DOB"
+            except TimeoutException:
+                pass
+
+            print("[DentaQuest step1] Search completed successfully")
+            return "Success"
+
+        except Exception as e: 
+            print(f"[DentaQuest step1] Exception: {e}")
+            return f"ERROR:STEP1 - {e}"
+
+    
+    def step2(self):
+        """Get eligibility status and capture screenshot"""
+        wait = WebDriverWait(self.driver, 90)
+
+        try:
+            print("[DentaQuest step2] Starting eligibility capture")
+            
+            # Wait for results to load
+            time.sleep(3)
+            
+            # Try to find eligibility status from the results
+            eligibilityText = "unknown"
+            try:
+                # Look for a link or element with eligibility status
+                status_elem = wait.until(EC.presence_of_element_located((
+                    By.XPATH,
+                    "//a[contains(@href,'eligibility')] | //*[contains(@class,'status')] | //*[contains(text(),'Active') or contains(text(),'Inactive') or contains(text(),'Eligible')]"
+                )))
+                eligibilityText = status_elem.text.strip().lower()
+                print(f"[DentaQuest step2] Found status element: {eligibilityText}")
+                
+                # Normalize status
+                if "active" in eligibilityText or "eligible" in eligibilityText:
+                    eligibilityText = "active"
+                elif "inactive" in eligibilityText or "ineligible" in eligibilityText:
+                    eligibilityText = "inactive"
+            except TimeoutException:
+                print("[DentaQuest step2] Could not find specific eligibility status")
+
+            # Try to find patient name
+            patientName = ""
+            try:
+                # Look for the patient name in the results
+                name_elem = self.driver.find_element(By.XPATH, "//h1 | //div[contains(@class,'name')] | //*[contains(@class,'member-name') or contains(@class,'patient-name')]")
+                patientName = name_elem.text.strip()
+                print(f"[DentaQuest step2] Found patient name: {patientName}")
+            except:
+                pass
+
+            # Wait for page to fully load
+            try:
+                WebDriverWait(self.driver, 30).until(
+                    lambda d: d.execute_script("return document.readyState") == "complete"
+                )
+            except Exception:
+                pass
+
+            time.sleep(1)
+
+            # Capture full page screenshot
+            print("[DentaQuest step2] Capturing screenshot")
+            total_width = int(self.driver.execute_script(
+                "return Math.max(document.body.scrollWidth, document.documentElement.scrollWidth, document.documentElement.clientWidth);"
+            ))
+            total_height = int(self.driver.execute_script(
+                "return Math.max(document.body.scrollHeight, document.documentElement.scrollHeight, document.documentElement.clientHeight);"
+            ))
+            dpr = float(self.driver.execute_script("return window.devicePixelRatio || 1;"))
+
+            self.driver.execute_cdp_cmd('Emulation.setDeviceMetricsOverride', {
+                "mobile": False,
+                "width": total_width,
+                "height": total_height,
+                "deviceScaleFactor": dpr,
+                "screenOrientation": {"angle": 0, "type": "portraitPrimary"}
+            })
+
+            time.sleep(0.2)
+
+            # Capture screenshot
+            result = self.driver.execute_cdp_cmd("Page.captureScreenshot", {"format": "png", "fromSurface": True})
+            image_data = base64.b64decode(result.get('data', ''))
+            screenshot_path = os.path.join(self.download_dir, f"dentaquest_ss_{self.memberId}_{int(time.time())}.png")
+            with open(screenshot_path, "wb") as f:
+                f.write(image_data)
+            print(f"[DentaQuest step2] Screenshot saved: {screenshot_path}")
+
+            # Restore original metrics
+            try:
+                self.driver.execute_cdp_cmd('Emulation.clearDeviceMetricsOverride', {})
+            except Exception:
+                pass
+
+            # Close the browser window after screenshot
+            try:
+                from dentaquest_browser_manager import get_browser_manager
+                get_browser_manager().quit_driver()
+                print("[DentaQuest step2] Browser closed")
+            except Exception as e:
+                print(f"[DentaQuest step2] Error closing browser: {e}")
+            
+            output = {
+                "status": "success",
+                "eligibility": eligibilityText,
+                "ss_path": screenshot_path,
+                "patientName": patientName
+            }
+            print(f"[DentaQuest step2] Success: {output}")
+            return output
+            
+        except Exception as e:
+            print(f"[DentaQuest step2] Exception: {e}")
+            # Cleanup download folder on error
+            try:
+                dl = os.path.abspath(self.download_dir)
+                if os.path.isdir(dl):
+                    for name in os.listdir(dl):
+                        item = os.path.join(dl, name)
+                        try:
+                            if os.path.isfile(item) or os.path.islink(item):
+                                os.remove(item)
+                        except Exception:
+                            pass
+            except Exception:
+                pass
+            return {"status": "error", "message": str(e)}
+
+    def main_workflow(self, url):
+        try: 
+            self.config_driver()
+            self.driver.maximize_window()
+            time.sleep(3)
+
+            login_result = self.login(url)
+            if login_result.startswith("ERROR"):
+                return {"status": "error", "message": login_result}
+            if login_result == "OTP_REQUIRED":
+                return {"status": "otp_required", "message": "OTP required after login"}
+
+            step1_result = self.step1()
+            if step1_result.startswith("ERROR"):
+                return {"status": "error", "message": step1_result}
+
+            step2_result = self.step2()
+            if step2_result.get("status") == "error":
+                return {"status": "error", "message": step2_result.get("message")}
+
+            return step2_result
+        except Exception as e: 
+            return {
+                "status": "error",
+                "message": str(e)
+            }

packages/db/types/patient-types.ts

@@ -22,10 +22,10 @@ export const insuranceIdSchema = z.preprocess(
     }
     return val;
   },
-  // After preprocess, require digits-only string (or optional nullable)
+  // After preprocess, allow alphanumeric insurance IDs (some providers like DentaQuest use letter prefixes)
   z
     .string()
-    .regex(/^\d+$/, { message: "Insurance ID must contain only digits" })
+    .regex(/^[A-Za-z0-9]+$/, { message: "Insurance ID must contain only letters and digits" })
     .min(1)
     .max(32)
     .optional()