Loraa AI engine
Governed NutriDMS automation
{server.configured ? "OpenAI connected" : "Secure setup required"}
{server.configured ? (server.model + " · live reasoning") : "Add OPENAI_API_KEY as a protected server secret"}
No API key is sent to or stored in the browser.
{server.tools || 16} governed toolsRole checkedAudit logged
choose("openai")} disabled={!server.configured}>
OpenAI reasoning {server.configured ? "Natural-language plans grounded in live NutriDMS data" : "Available after secure server setup"}
choose("builtin")}>
Built-in fallback Deterministic commands stay available without OpenAI
);
}
/* Renders Loraa's text answers cleanly: bold **x**, and numbered / bulleted
lists broken onto their own lines — never raw markdown. Types out when new. */
function locMdInline(s, key) {
const parts = String(s).split(/(\*\*[^*]+\*\*)/g);
return parts.map((p, i) => (p.startsWith("**") && p.endsWith("**"))
?
In-agent workspace {data.title} {data.desc}
{(data.metrics || []).map((m, i) =>
{m[1]} {m[0]}
)}
{(data.rows || []).length ? data.rows.map((r, i) => (
r.prompt && onAsk(r.prompt)}>
{r.title} {r.meta || "Live NutriDMS record"}
{r.status || "Open"}
{r.taskId && r.reviewable && onReview
?
onReview(r, "accept")}>
onReview(r, "reject")}>
:
)) :
No records need attention Loraa is still monitoring this workspace.
}
{(data.actions || []).map((a, i) => onAsk(a.prompt)}> )}
);
}
/* Enterprise structured-answer renderer. Renders the sections produced by
LoraaAnswers inside the existing chat bubble — richer content, same UI shell. */
function LoraaRich({ data, nav, animate, onProgress, onAsk, onFix, onCmd, onServerAction }) {
if (!data) return null;
const [reveal, setReveal] = locState(animate ? 0 : 2);
locEffect(() => { setReveal(animate ? 0 : 2); }, [data, animate]);
locEffect(() => {
if (animate && reveal === 0 && !data.intro) setReveal(1);
if (animate && reveal === 1 && !data.summary) setReveal(2);
}, [animate, reveal, data.intro, data.summary]);
const act = (a) => {
if (!a) return;
if (a.kind === "server-action" && onServerAction) { onServerAction(a.payload || {}); return; }
try {
if (a.kind === "fix-findings" && onFix) { onFix(a.item || {}); return; }
if (a.kind === "cmd-run" && onAsk && a.payload && a.payload.q) { onAsk(a.payload.q); return; }
if (a.kind === "cmd-focus" && onAsk) { onAsk(""); return; }
if (a.kind && a.kind.indexOf("cmd-") === 0 && onCmd) { onCmd(a); return; }
if (a.kind === "export-compliance" && window.LoraaAnswers && window.LoraaAnswers.exportReport) { window.LoraaAnswers.exportReport(a.report || "compliance", data.role); return; }
if (a.kind === "recipe" && a.arg && window.__openRecipe) { const list = (window.RECIPES || []); const r = list.find((x) => x.id === a.arg); if (r) { window.__openRecipe(r); return; } }
if (a.kind === "ingredient" && a.arg && window.__openIngredient) { const list = (window.INGREDIENT_ITEMS || []); const g = list.find((x) => x.id === a.arg); if (g) { window.__openIngredient(g); return; } }
} catch (e) {}
if (a.to) nav(a.to);
};
return (
{data.intro && (
{animate ? setReveal(1)} /> :
)}
{reveal >= 1 &&
{data.title}
}
{reveal >= 1 && data.summary && (
Executive summary
{animate ? setReveal(2)} /> : data.summary}
)}
{reveal >= 2 && data.stats && data.stats.length > 0 && (
{data.stats.map((s, i) => (
{s.value} {s.label}
))}
)}
{reveal >= 2 && data.analysis && data.analysis.length > 0 && (
See more {data.analysis.map((p, i) =>
{locFriendlyEvidence(p)}
)}
)}
{reveal >= 2 && data.records && data.records.length > 0 && (
{data.recordsTitle || "Supporting records"}
{data.records.map((r, i) => (
{r.thumb || (r.title || "?").trim().charAt(0).toUpperCase()}
{r.title}
{r.badge && {r.badge.text} }
{r.lead &&
{r.lead}
}
{r.fields && r.fields.length > 0 && (
{r.fields.map((f, j) => (
{f.k} {f.v}
)}
{r.actions && r.actions.length > 0 && (
{r.actions.map((a, j) => act(a)}>{a.icon && )}
)}
))}
)}
{reveal >= 2 && data.risks && data.risks.length > 0 && (
Risks
{data.risks.map((r, i) => (
{r.text}
))}
)}
{reveal >= 2 && data.recs && data.recs.length > 0 && (
Recommendations
{data.recs.map((r, i) => {r} )}
)}
{reveal >= 2 && data.permissionNote && (
{data.permissionNote}
)}
{reveal >= 2 && data.refs && (data.refs.internal.length > 0 || data.refs.external.length > 0) && (
See more
{data.refs.internal.length > 0 &&
Internal {data.refs.internal.map((r, i) => {locFriendlySource(r)} )}
}
{data.refs.external.length > 0 &&
External {data.refs.external.map((r, i) => {r} )}
}
)}
{reveal >= 2 && data.confidence && (
Confidence {data.confidence.pct}%
{data.confidence.basis &&
Based on {data.confidence.basis.map(locFriendlyEvidence).join(" · ")} · updated {data.confidence.updated}
}
)}
{reveal >= 2 && data.actions && data.actions.length > 0 && (
{data.actions.map((a, i) => act(a)}>{a.icon && )}
)}
{reveal >= 2 && data.followups && data.followups.length > 0 && onAsk && (
{data.followups.map((f, i) => onAsk(f)}>{f} )}
)}
Fixing · {data.item.title}
{data.item.regime ? data.item.regime + " · " : ""}{data.item.findingText}
Step {st === "options" ? "1" : st === "confirm" ? "2" : st === "preview" ? "3" : "✓"} / 3
{data.note &&
{data.note}
}
{st === "options" && (
{data.options.map((o, i) => (
onPick(data, o)}>
{o.label} {o.desc}
))}
)}
{st === "confirm" && (
{data.question}
{data.choices.map((c, i) => (
onPick(data, data.option, c)}>{c}
))}
onPick(data, data.option, val, resolved)} />
)}
{st === "preview" && (
Now {data.preview.before}
After fix {data.preview.after}
{data.preview.confidence != null && (
= 85 ? " ok" : data.preview.confidence >= 65 ? " warn" : " low")}>
Confidence {data.preview.confidence}%
)}
onApply(data)}>
onPick({ ...data, stage: "options" }, null)}>Choose another
)}
{st === "applied" && (
{data.result}
onOpen(data)}>
)}
);
}
function LoraaAsk({ role, open, onClose, user }) {
const [liveOps, setLiveOps] = locState({ items: [], summary: null, loading: true });
const m = locMemo(() => locModel(role, liveOps), [role, liveOps]);
const [chatOpen, setChatOpen] = locState(false); // slide-out chat drawer
const [history, setHistory] = locState([]);
const [activeId, setActiveId] = locState(null);
const [msgs, setMsgs] = locState([]);
const msgsRef = locRef([]);
locEffect(() => { msgsRef.current = msgs; }, [msgs]);
const [typing, setTyping] = locState(false);
const [input, setInput] = locState("");
const [attachments, setAttachments] = locState([]);
const [attachmentError, setAttachmentError] = locState("");
const [historyQuery, setHistoryQuery] = locState("");
const [collapsedGroups, setCollapsedGroups] = locState({});
const historyLoadedRef = locRef("");
const fileInputRef = locRef(null);
const [slash, setSlash] = locState(-1); // highlighted slash-command index, -1 = closed
const [ctxOpen, setCtxOpen] = locState(true);
const [sideOpen, setSideOpen] = locState(true);
const [chatExpanded, setChatExpanded] = locState(false); // widen chat drawer to the right
const [thinkSteps, setThinkSteps] = locState(null); // active reasoning steps while answering
const bodyRef = locRef(null);
const activeResponseRef = locRef(null);
const followTypingRef = locRef(true);
const inputRef = locRef(null);
const [agent, setAgent] = locState(() => (window.LoraaAgent ? window.LoraaAgent.status() : null));
const [provOpen, setProvOpen] = locState(false); // provider settings popover
const [learningOpen, setLearningOpen] = locState(false);
const [serverConversationId, setServerConversationId] = locState(null);
const [reviewAction, setReviewAction] = locState(null);
const [actionBusy, setActionBusy] = locState(false);
const [actionError, setActionError] = locState("");
const [reviewingId, setReviewingId] = locState("");
const registeredName = user && user.name ? String(user.name).trim() : "";
const name = registeredName ? registeredName.split(/\s+/)[0] : locFirstName(role);
const identity = (user && (user.id || user.email || user.name)) || role || "member";
const historyKey = locHistoryKey(identity);
const activeKey = historyKey + ":active";
const hour = new Date().getHours();
const greet = hour < 12 ? "Good morning" : hour < 18 ? "Good afternoon" : "Good evening";
// Subscribe to the live agent (crawler + memory + provider)
locEffect(() => {
if (!window.LoraaAgent) return;
window.LoraaAgent.start(role);
const unsub = window.LoraaAgent.subscribe(setAgent);
return () => {
unsub();
if (window.LoraaAgent && window.LoraaAgent.Crawler) window.LoraaAgent.Crawler.stop();
};
}, [role]);
// The Operations Feed is always loaded from the authenticated Django tenant.
// Polling plus product events keeps importance, ownership and review state
// current without reintroducing browser demo records.
locEffect(() => {
if (!open || !window.NutriLoraa || !window.NutriLoraa.feed) return;
let cancelled = false;
const applySnapshot = (snapshot) => {
if (!cancelled && snapshot && Array.isArray(snapshot.items)) {
setLiveOps({ ...snapshot, loading: false, error: "" });
}
return snapshot;
};
const loadFeed = () => window.NutriLoraa.feed();
const refresh = (force) => {
const coordinator = window.NutriWorkspaceRefresh;
const request = coordinator && coordinator.fetch
? coordinator.fetch("loraa:operations-feed", loadFeed, { scope: "org-user", ttlMs: coordinator.DEFAULT_TTL_MS, force: force === true })
: loadFeed();
return request.then(applySnapshot).catch((error) => {
if (!cancelled) setLiveOps((current) => ({ ...current, loading: false, error: (error && error.message) || "Live operations are temporarily unavailable." }));
});
};
const events = ["nutridms-submitted", "nutridms-automations", "nutridms-approval", "nutridms-published", "nutridms-task"];
const coordinator = window.NutriWorkspaceRefresh;
if (coordinator && coordinator.register) {
coordinator.register("loraa:operations-feed", loadFeed, { scope: "org-user", onValue: applySnapshot, active: true });
coordinator.activate("loraa:operations-feed", true);
}
const onEvent = () => refresh(false);
refresh(false);
events.forEach((eventName) => window.addEventListener(eventName, onEvent));
return () => {
cancelled = true;
if (coordinator && coordinator.activate) coordinator.activate("loraa:operations-feed", false);
events.forEach((eventName) => window.removeEventListener(eventName, onEvent));
};
}, [open, role]);
// Load one user-scoped cache immediately. Django is fetched once per signed-in
// identity, not every time the modal is hidden and shown.
locEffect(() => {
const localRows = locLoadHistory(historyKey);
setHistory(localRows);
let remembered = null;
try { remembered = sessionStorage.getItem(activeKey); } catch (e) {}
const active = localRows.find((row) => String(row.id) === String(remembered));
setActiveId(active ? active.id : null);
setServerConversationId(active ? active.serverId || null : null);
setMsgs(active ? (active.msgs || []) : []);
historyLoadedRef.current = "";
}, [historyKey]);
// Django owns conversation history. Merge it into the existing sidebar so
// titles, timestamps, pins and follow-ups survive browser/device changes.
locEffect(() => {
if (!open || !window.LoraaAgent || !window.LoraaAgent.conversations) return;
if (historyLoadedRef.current === historyKey) return;
historyLoadedRef.current = historyKey;
let cancelled = false;
window.LoraaAgent.conversations(false).then((rows) => {
if (cancelled || !Array.isArray(rows)) return;
setHistory((localRows) => {
const byServer = new Map((localRows || []).filter((row) => row.serverId).map((row) => [String(row.serverId), row]));
const remoteRows = rows.map((row) => {
const existing = byServer.get(String(row.id));
const existingPrompt = existing && existing.msgs && existing.msgs.find((message) => message.role === "user" && message.text);
const remoteTitle = String(row.title || "").trim();
const usefulTitle = remoteTitle && remoteTitle.toLowerCase() !== "conversation"
? remoteTitle
: (existing && existing.title && existing.title !== "Conversation" ? existing.title : (existingPrompt && existingPrompt.text) || row.summary || "New conversation");
return {
id: (existing && existing.id) || ("server-" + row.id),
serverId: row.id,
title: String(usefulTitle).slice(0, 72),
summary: row.summary || "",
pinned: !!row.pinned,
at: row.at || Date.now(),
msgs: (existing && existing.msgs) || [],
};
});
const remoteIds = new Set(remoteRows.map((row) => String(row.serverId)));
const localOnly = (localRows || []).filter((row) => !row.serverId || !remoteIds.has(String(row.serverId)));
const merged = [...remoteRows, ...localOnly].sort((a, b) => Number(!!b.pinned) - Number(!!a.pinned) || (b.at || 0) - (a.at || 0));
locSaveHistory(merged, historyKey);
return merged;
});
}).catch(() => { if (!cancelled) historyLoadedRef.current = ""; });
return () => { cancelled = true; };
}, [open, role, historyKey]);
locEffect(() => {
try {
if (activeId) sessionStorage.setItem(activeKey, String(activeId));
else sessionStorage.removeItem(activeKey);
} catch (e) {}
}, [activeId, activeKey]);
const learning = agent && agent.learning ? agent.learning : null;
const fam = learning ? learning.pct / 100 : (agent && agent.profile ? agent.profile.familiarity : 0);
const learned = agent && agent.topModules ? agent.topModules.slice(0, 3).map(x => x.module) : [];
// Proactive learning suggestion — Loraa offers to automate a clear pattern.
const [learnSug, setLearnSug] = locState(null);
const [learnDismissed, setLearnDismissed] = locState(false);
locEffect(() => {
if (!open) return;
try { if (window.LoraaCommands && window.LoraaCommands.learnSuggestion) setLearnSug(window.LoraaCommands.learnSuggestion()); } catch (e) {}
}, [open, msgs]);
const acceptLearn = () => {
try { if (learnSug && window.LoraaCommands) { window.LoraaCommands.learnAddRule(learnSug.cat, learnSug.initials, learnSug.name); } } catch (e) {}
setLearnDismissed(true); setLearnSug(null);
};
const MOD_LABEL = { compliance: "Compliance", labels: "Label Studio", nutrition: "Nutrition", ingredients: "Ingredients", publishing: "Publishing", assignments: "Team boards", reports: "Reports", recipes: "Recipes" };
// Adaptive greeting line that reflects what Loraa has learned about this user
const liveWorkload = liveOps && liveOps.summary ? Number(liveOps.summary.workload || 0) : null;
const liveSummary = liveOps && liveOps.summary ? liveOps.summary : {};
const liveSources = locMemo(() => {
const counts = {};
((liveOps && liveOps.items) || []).forEach((item) => {
const key = item.source || "django";
counts[key] = (counts[key] || 0) + 1;
});
return Object.entries(counts).sort((a, b) => b[1] - a[1]).slice(0, 8);
}, [liveOps]);
const introLine = liveOps.loading
? "I'm checking your live NutriDMS operation now."
: liveOps.error
? "I couldn't refresh the live operation just now; your saved conversations are still available."
: liveWorkload > 0
? ("I found " + liveWorkload + " current work item" + (liveWorkload === 1 ? "" : "s") + " and ranked the most important first.")
: "Nothing in the connected operation currently needs attention.";
// Recommendations reordered by what this user engages with most (per-user learning)
const recs = locMemo(() => {
try { return window.LoraaAgent ? window.LoraaAgent.personalize(m.recommendations, role) : m.recommendations; }
catch (e) { return m.recommendations; }
}, [m, role, agent]);
const opsPrompts = [
"Give me today's daily NutriDMS brief",
"Fix recipes failing our sodium policy",
"Show active automations",
"Generate missing CFIA labels",
"Balance the team's current workload",
"Run a NutriDMS health scan",
];
const appendAgent = (payload) => {
const cid = activeId || ("c-" + Date.now());
if (!activeId) setActiveId(cid);
const next = [...msgsRef.current, payload];
msgsRef.current = next; setMsgs(next); persist(cid, next);
setChatOpen(true);
setTimeout(scrollThread, 30);
};
const scrollToLatest = (behavior) => {
// Restored sessions can grow after React paints images and rich cards. A
// few short, local scroll passes keep the viewport at the latest message
// without refetching the conversation or spending another AI token.
[0, 60, 180].forEach((delay) => window.setTimeout(() => {
window.requestAnimationFrame(() => {
const body = bodyRef.current;
if (!body) return;
followTypingRef.current = true;
body.scrollTo({ top: body.scrollHeight, behavior: delay ? "auto" : (behavior || "auto") });
});
}, delay));
};
const nav = (to) => {
if (!to) return;
try { if (window.LoraaAgent) window.LoraaAgent.recordNav(to, role); } catch (e) {}
appendAgent({ role: "loraa", workspace: locWorkspaceData(to, role, liveOps), _new: true });
};
const slashMatches = locMemo(() => {
if (!input.startsWith("/")) return [];
const q = input.slice(1).toLowerCase();
return LOC_COMMANDS.filter(c => c.cmd.slice(1).startsWith(q) || c.label.toLowerCase().includes(q)).slice(0, 7);
}, [input]);
const entityMatches = locMemo(() => {
const q = input.trim().toLowerCase();
if (input.startsWith("/") || q.length < 2) return [];
const out = [];
try {
(typeof RECIPES !== "undefined" ? RECIPES : []).forEach(r => {
if (out.length < 4 && r.name && r.name.toLowerCase().includes(q)) out.push({ icon: "utensils-crossed", label: r.name, kind: "Recipe" });
});
(typeof INGREDIENTS !== "undefined" ? INGREDIENTS : []).forEach(i => {
if (out.length < 5 && i.name && i.name.toLowerCase().includes(q)) out.push({ icon: "leaf", label: i.name, kind: "Ingredient" });
});
} catch (e) {}
return out.slice(0, 5);
}, [input]);
const persist = (id, next, backendId) => {
setHistory((h) => {
let list = h.slice();
if (!id) return list;
const cleanMessages = locPersistableMessages(next);
const existing = list.find(x => x.id === id);
const serverId = backendId || serverConversationId || (existing && existing.serverId) || null;
const firstPrompt = cleanMessages.find((message) => message.role === "user" && message.text);
const title = firstPrompt && firstPrompt.text ? firstPrompt.text.replace(/\s+/g, " ").slice(0, 72) : "New conversation";
if (existing) list = list.map(x => x.id === id ? { ...x, title: x.title && x.title !== "Conversation" ? x.title : title, msgs: cleanMessages, serverId, at: Date.now() } : x);
else list = [{ id, serverId, title, when: "Now", at: Date.now(), msgs: cleanMessages }, ...list];
locSaveHistory(list, historyKey); return list;
});
};
const closeCenter = () => {
const stable = locPersistableMessages(msgsRef.current);
msgsRef.current = stable;
setMsgs(stable);
if (activeId) persist(activeId, stable, serverConversationId);
setAttachmentError("");
onClose();
};
const closeChat = () => {
const stable = locPersistableMessages(msgsRef.current);
msgsRef.current = stable;
setMsgs(stable);
if (activeId) persist(activeId, stable, serverConversationId);
setChatOpen(false);
setChatExpanded(false);
};
const readAttachment = (file) => new Promise((resolve, reject) => {
const reader = new FileReader();
reader.onload = () => resolve({
id: "att-" + Date.now() + "-" + Math.random().toString(36).slice(2, 8),
name: file.name,
type: file.type || "application/octet-stream",
size: file.size,
kind: String(file.type || "").startsWith("image/") ? "image" : "file",
data: reader.result,
previewUrl: String(file.type || "").startsWith("image/") ? reader.result : "",
});
reader.onerror = () => reject(new Error("Could not read " + file.name + "."));
reader.readAsDataURL(file);
});
const addAttachments = async (fileList) => {
const incoming = Array.from(fileList || []);
if (!incoming.length) return;
const allowed = /^(image\/(png|jpeg|webp|gif)|application\/pdf|text\/(plain|csv|markdown)|application\/(json|msword|vnd\.openxmlformats-officedocument\.(wordprocessingml\.document|presentationml\.presentation|spreadsheetml\.sheet)|vnd\.ms-(excel|powerpoint)))$/i;
const nextFiles = [];
let total = attachments.reduce((sum, item) => sum + Number(item.size || 0), 0);
for (const file of incoming) {
if (attachments.length + nextFiles.length >= 3) { setAttachmentError("Attach up to 3 files per message."); break; }
if (!allowed.test(file.type || "")) { setAttachmentError(file.name + " is not a supported image, PDF, document or spreadsheet."); continue; }
if (file.size > 6 * 1024 * 1024) { setAttachmentError(file.name + " is larger than 6 MB."); continue; }
if (total + file.size > 12 * 1024 * 1024) { setAttachmentError("Attachments can total up to 12 MB per message."); break; }
total += file.size;
nextFiles.push(await readAttachment(file));
}
if (nextFiles.length) {
setAttachments((current) => [...current, ...nextFiles]);
setAttachmentError("");
}
if (fileInputRef.current) fileInputRef.current.value = "";
};
const removeAttachment = (id) => setAttachments((current) => current.filter((item) => item.id !== id));
// ── Interactive Fix-Findings flow: Loraa works WITH the user ──
const pushFix = (fix) => {
appendAgent({ role: "loraa", fix });
};
const startFix = (item) => {
setChatOpen(true);
let options = [];
try { options = window.LoraaAnswers ? window.LoraaAnswers.fixOptionsFor(item) : []; } catch (e) {}
const cid = activeId || ("c-" + Date.now());
if (!activeId) setActiveId(cid);
const next = [...msgsRef.current, { role: "user", text: "Fix the findings on " + item.title }];
msgsRef.current = next; setMsgs(next); persist(cid, next);
setTimeout(() => pushFix({ stage: "options", item, options, note: "Here's what I found on " + item.title + ". How would you like to clear it? Pick an approach and I'll build the fix." }), 400);
};
const fixPick = (data, option, choice, resolved) => {
if (data.stage === "options" && option) {
const pv = window.LoraaAnswers.fixPreviewFor(data.item, option, choice);
if (pv.needQuestion) { pushFix({ stage: "confirm", item: data.item, option, question: pv.needQuestion, choices: pv.choices }); return; }
pushFix({ stage: "preview", item: data.item, option, preview: pv, note: "Here's the fix I'll apply. Review it, then Apply." }); return;
}
if (data.stage === "confirm" && option) {
const pv = window.LoraaAnswers.fixPreviewFor(data.item, option, choice);
if (resolved) { pv.after = (pv.after || ("Using " + choice)) + " · source: " + resolved.source; pv.confidence = resolved.confidence; }
const noteTx = resolved
? ("Got it — \u201c" + choice + "\u201d. I resolved it via " + resolved.source + " (confidence " + resolved.confidence + "%). Here's the fix.")
: ("Got it — " + choice + ". Here's the fix.");
pushFix({ stage: "preview", item: data.item, option, choice, preview: pv, note: noteTx }); return;
}
if (!option) {
const options = window.LoraaAnswers.fixOptionsFor(data.item);
pushFix({ stage: "options", item: data.item, options, note: "No problem — pick another approach." });
}
};
const fixApply = (data) => {
try { window.LoraaAnswers.markFixed(data.item.title, (data.option && data.option.label) || "resolved"); } catch (e) {}
const res = (data.option && data.option.id === "assign")
? (data.preview.after + ". I'll track it to completion.")
: (data.preview.after + ". I re-ran validation and the finding cleared — " + data.item.title + " is no longer blocked.");
pushFix({ stage: "applied", item: data.item, option: data.option, result: res });
};
const fixOpen = (data) => { const to = (data.item && data.item.openTo) || "label-studio"; nav(to); };
// ── Command follow-through: execute an action button from a command card ──
const runCmd = (action) => {
try {
const res = window.LoraaCommands && window.LoraaCommands.execute(action, role);
if (res && res.text) {
try { if (window.LoraaAgent) window.LoraaAgent.recordAction(action.kind, role, res.ok === false ? "failed" : "completed"); } catch (e) {}
appendAgent({ role: "loraa", text: res.text, conf: res.ok === false ? 74 : 98, _new: true });
if (/automation/.test(action.kind || "")) setTimeout(() => appendAgent({ role: "loraa", workspace: locWorkspaceData("automations", role, liveOps) }), 260);
}
} catch (e) {}
};
const chooseServerAction = (action) => {
if (!action) return;
if (action.requiresConfirmation === false && action.risk === "read_only" && action.target) {
nav(action.target);
return;
}
setActionError("");
setReviewAction(action);
};
const confirmServerAction = async () => {
const action = reviewAction;
if (!action) return;
const rawType = String(action.type || "").toLowerCase();
const type = locGovernedActionType(action);
if (type === "schedule_task" && !action.scheduleCron) {
setActionError("This schedule needs a clear time or recurrence before it can be queued.");
return;
}
setActionBusy(true);
setActionError("");
try {
const result = await window.LoraaAgent.prepareAction({
type,
label: action.label,
subjectType: action.subjectType || "",
subjectId: action.target || "",
targetUserId: locGovernedTargetUserId(action, type),
scheduleCron: action.scheduleCron || "",
requiredPermission: action.requiredPermission || "",
payload: {
canonicalCommand: action.canonicalCommand,
reason: action.reason,
message: action.reason,
targetLabel: locFriendlyTarget(action),
scheduleLabel: action.scheduleCron ? locFriendlySchedule(action) : "",
},
channels: /email|push|notif/.test(rawType) ? ["in_app", "email"] : ["in_app"],
});
let selfApproved = false;
if (result && result.canSelfApprove && result.taskId && window.NutriLoraa && window.NutriLoraa.review) {
await window.NutriLoraa.review(result.taskId, "accept");
selfApproved = true;
}
setReviewAction(null);
if (window.NutriLoraa && window.NutriLoraa.feed) {
try {
const snapshot = await window.NutriLoraa.feed();
if (snapshot && Array.isArray(snapshot.items)) setLiveOps({ ...snapshot, loading: false, error: "" });
} catch (e) {}
}
appendAgent({
role: "loraa",
rich: locServerRich({
type: "action_plan",
answer: selfApproved
? (type === "schedule_task"
? "Your reminder is scheduled. Loraa will deliver it in NutriDMS at the confirmed time."
: "Your NutriDMS notification is ready and has been sent.")
: "Your request is now in the NutriDMS review queue. Nothing sensitive has changed yet.",
confidence: 100,
evidence: [selfApproved
? "You confirmed this low-risk personal action, so NutriDMS recorded and activated it immediately."
: "The request is visible in Approvals & review, where an authorized reviewer can approve or dismiss it."],
actions: [],
suggestedPrompts: ["Show my pending approvals", "Explain what happens after approval"],
sourceOfTruth: "NutriDMS governed workflow",
audited: true,
}),
_new: true,
});
} catch (error) {
setActionError((error && error.message) || "I couldn’t queue this action. Check your permission and try again.");
} finally {
setActionBusy(false);
}
};
const reviewQueueItem = async (row, decision) => {
if (!row || !row.taskId || !window.NutriLoraa || !window.NutriLoraa.review) return;
setReviewingId(row.taskId);
try {
await window.NutriLoraa.review(row.taskId, decision);
const snapshot = await window.NutriLoraa.feed();
if (snapshot && Array.isArray(snapshot.items)) {
setLiveOps({ ...snapshot, loading: false, error: "" });
const updatedWorkspace = locWorkspaceData("review-queue", role, snapshot);
const next = msgsRef.current.map((message) => message.workspace && /review-queue|approval/.test(String(message.workspace.id || ""))
? { ...message, workspace: updatedWorkspace }
: message);
msgsRef.current = next;
setMsgs(next);
if (activeId) persist(activeId, next);
}
appendAgent({
role: "loraa",
text: decision === "accept"
? "Approved. NutriDMS recorded the decision and the review queue is now up to date."
: "Dismissed. NutriDMS recorded the decision and removed it from the active review queue.",
conf: 100,
_new: true,
});
} catch (error) {
appendAgent({
role: "loraa",
text: (error && error.message) || "I couldn't update that approval. Your current NutriDMS role may not include review permission.",
conf: 0,
_new: true,
});
} finally {
setReviewingId("");
}
};
const ask = async (q) => {
const selectedAttachments = attachments.slice();
const question = String(q || "").trim() || (selectedAttachments.length ? "Please review the attached files." : "");
if (!question) return;
setChatOpen(true);
const userMsg = {
role: "user",
text: question,
attachments: selectedAttachments.map((item) => ({ ...item })),
};
let id = activeId || ("c-" + Date.now());
if (!activeId) setActiveId(id);
const afterUser = [...msgsRef.current, userMsg];
msgsRef.current = afterUser;
setMsgs(afterUser); persist(id, afterUser); setInput(""); setAttachments([]); setAttachmentError(""); setSlash(-1);
// Show Loraa "thinking" through real steps while it works.
const steps = locThinkSteps(question);
setThinkSteps(steps); setTyping(true);
const thinkStart = Date.now();
const conversational = locConversationalIntent(question);
// Restore the original Loraa explanation engine from the approved folder.
// It reads the current NutriDMS workspace and produces the same structured,
// permission-aware answer cards the existing UI was designed to render.
let originalExplanation = null;
try {
if (!conversational && window.LoraaAnswers) originalExplanation = window.LoraaAnswers.answer(question, role);
} catch (e) {}
// Keep the governed Django/OpenAI request connected for server history,
// tenant grounding and Hybrid actions. If that service is unavailable or
// rejects the request, the original explanation remains usable.
let serverResult = null;
let serverError = null;
try {
if (window.LoraaAgent && window.LoraaAgent.askDetailed) {
serverResult = await window.LoraaAgent.askDetailed(question, role, { conversationId: serverConversationId, attachments: selectedAttachments.map(({ id, previewUrl, ...item }) => item) });
if (serverResult && serverResult.conversationId) setServerConversationId(serverResult.conversationId);
}
} catch (error) {
serverError = error;
serverResult = null;
}
const serverRich = serverResult && serverResult.answer ? locServerRich(serverResult) : null;
const serverHasGovernedAction = !!(
serverResult && Array.isArray(serverResult.actions) &&
serverResult.actions.some((action) => action && action.type && action.type !== "none")
);
// Governed actions must render from the authoritative Django/OpenAI
// response alone. Merging a cached local workspace card here could show an
// unrelated ingredient, recipe or dashboard beside a valid popup/action.
let rich = conversational ? null : (serverHasGovernedAction
? serverRich
: locHybridRich(originalExplanation, serverRich));
let aiConfidence = serverResult && typeof serverResult.confidence === "number" ? serverResult.confidence : null;
let originalReply = conversational && serverResult && serverResult.answer ? serverResult.answer : null;
if (!rich && serverError) {
try {
const fallback = window.LoraaAnswers && window.LoraaAnswers.clarify(question, role);
if (fallback && fallback.kind === "text") originalReply = fallback.text;
else if (fallback) rich = fallback;
} catch (e) {}
}
const providerMessage = String(serverError && serverError.message || "")
.replace(/sk-[A-Za-z0-9_-]+/g, "[redacted]")
.trim();
const errorStatus = serverError ? Number(serverError.status) : 0;
const reply = rich ? null : (originalReply || (
errorStatus === 401
? "Your NutriDMS session has expired, " + name + ". Please sign in again so I can securely access your organization."
: errorStatus === 403
? "You're signed in, " + name + ", but your current role does not have access to Loraa. Please ask an organization administrator to enable Loraa for your role."
: errorStatus === 503 && providerMessage
? "I reached NutriDMS, " + name + ", but OpenAI could not complete the response. " + providerMessage
: providerMessage
? "I reached NutriDMS, " + name + ", but the request could not be completed. " + providerMessage
: "I couldn't complete that request just now, " + name + ". I haven't guessed or used local demo data. Please try again."
));
// Let the thinking animation breathe for at least a moment.
const minThink = Math.min(steps.length * 850, 3200);
const wait = Math.max(0, minThink - (Date.now() - thinkStart));
setTimeout(() => {
setTyping(false); setThinkSteps(null);
let conf = aiConfidence;
if (!rich && conf == null) conf = 0;
const msg = rich ? { role: "loraa", rich: rich, _new: true } : { role: "loraa", text: reply, conf, _new: true };
const next = [...afterUser, msg];
setMsgs(next);
// Persist without the transient _new flag so reloads don't re-animate.
persist(id, next.map(({ _new, ...r }) => r), serverResult && serverResult.conversationId);
}, wait);
};
const openWorkspace = async (w) => {
setActiveId(w.id);
const h = history.find(x => x.id === w.id);
setServerConversationId((h && h.serverId) || null);
if (h && Array.isArray(h.msgs) && h.msgs.length) {
const cached = locPersistableMessages(h.msgs);
msgsRef.current = cached;
setMsgs(cached);
setChatOpen(true);
scrollToLatest();
return;
}
if (h && h.serverId && window.LoraaAgent && window.LoraaAgent.conversation) {
try {
const conversation = await window.LoraaAgent.conversation(h.serverId);
const loaded = locServerMessages(conversation);
setMsgs(loaded);
persist(h.id, loaded, h.serverId);
setChatOpen(true);
scrollToLatest();
return;
} catch (error) {}
}
if (h) { setMsgs(h.msgs || []); setChatOpen(true); scrollToLatest(); } else { setMsgs([]); ask(w.title); }
};
// Group real conversation history by date for the left panel.
const histGroups = locMemo(() => {
const now = new Date();
const startOfDay = new Date(now.getFullYear(), now.getMonth(), now.getDate()).getTime();
const dayMs = 86400e3;
const groups = { Pinned: [], Today: [], Yesterday: [], "Last week": [], Earlier: [] };
const query = historyQuery.trim().toLowerCase();
(history || []).filter((h) => !query || String((h.title || "") + " " + (h.summary || "")).toLowerCase().includes(query)).forEach((h) => {
if (h.pinned) { groups.Pinned.push(h); return; }
const at = h.at || 0;
let g = "Earlier";
if (at >= startOfDay) g = "Today";
else if (at >= startOfDay - dayMs) g = "Yesterday";
else if (at >= startOfDay - 7 * dayMs) g = "Last week";
groups[g].push(h);
});
return ["Pinned", "Today", "Yesterday", "Last week", "Earlier"].map((k) => ({ group: k, items: groups[k] })).filter((x) => x.items.length);
}, [history, historyQuery]);
const histIcon = (h) => {
const t = ((h.title || "") + " " + ((h.msgs && h.msgs[0] && h.msgs[0].text) || "")).toLowerCase();
if (/complian|risk|flag/.test(t)) return { icon: "shield-check", tone: "block" };
if (/label|cfia|fda|fop|nafdac/.test(t)) return { icon: "tag", tone: "info" };
if (/ingredient|nutrition|rice|salmon/.test(t)) return { icon: "leaf", tone: "ok" };
if (/board|assign|workload|team/.test(t)) return { icon: "kanban-square", tone: "info" };
if (/publish|pipeline|queue/.test(t)) return { icon: "calendar-days", tone: "run" };
if (/recipe|dish/.test(t)) return { icon: "utensils-crossed", tone: "warn" };
return { icon: "message-square", tone: "info" };
};
const histTime = (h) => {
if (!h.at) return h.when || "";
const d = new Date(h.at); const now = new Date();
if (d.toDateString() === now.toDateString()) return d.toLocaleTimeString([], { hour: "numeric", minute: "2-digit" });
return d.toLocaleDateString([], { weekday: "short" });
};
const toggleHistoryGroup = (group) => setCollapsedGroups((current) => ({ ...current, [group]: !current[group] }));
const togglePin = async (workspace, event) => {
event.preventDefault();
event.stopPropagation();
const nextPinned = !workspace.pinned;
setHistory((current) => {
const next = current.map((row) => row.id === workspace.id ? { ...row, pinned: nextPinned } : row);
locSaveHistory(next, historyKey);
return next;
});
if (workspace.serverId && window.LoraaAgent && window.LoraaAgent.updateConversation) {
try { await window.LoraaAgent.updateConversation(workspace.serverId, { pinned: nextPinned }); } catch (e) {}
}
};
const newConversation = () => {
setActiveId(null); setServerConversationId(null); setMsgs([]); msgsRef.current = [];
setInput(""); setAttachments([]); setAttachmentError(""); setSlash(-1); setReviewAction(null); setChatOpen(true);
};
const onKey = (e) => {
if (e.key === "Enter" && e.shiftKey) return;
if (slashMatches.length && slash >= 0) {
if (e.key === "ArrowDown") { e.preventDefault(); setSlash(i => Math.min(i + 1, slashMatches.length - 1)); return; }
if (e.key === "ArrowUp") { e.preventDefault(); setSlash(i => Math.max(i - 1, 0)); return; }
if (e.key === "Enter") { e.preventDefault(); const c = slashMatches[slash]; if (c) c.prompt ? ask(c.prompt) : nav(c.to); return; }
if (e.key === "Escape") { setSlash(-1); return; }
}
if (e.key === "Enter") { e.preventDefault(); ask(input); }
};
locEffect(() => {
const body = bodyRef.current;
const last = msgs[msgs.length - 1];
if (!body || !last) return;
followTypingRef.current = true;
if (last.role === "loraa" && last._new && activeResponseRef.current) {
const bodyBox = body.getBoundingClientRect();
const responseBox = activeResponseRef.current.getBoundingClientRect();
const top = body.scrollTop + responseBox.top - bodyBox.top - 12;
body.scrollTo({ top: Math.max(0, top), behavior: "smooth" });
} else if (last.role === "user") {
body.scrollTo({ top: body.scrollHeight, behavior: "smooth" });
}
}, [msgs.length]);
locEffect(() => {
if (open && chatOpen && msgsRef.current.length) scrollToLatest();
}, [open, chatOpen, activeId]);
const scrollThread = () => {
const body = bodyRef.current;
const response = activeResponseRef.current;
if (!body || !response || !followTypingRef.current) return;
const bodyBox = body.getBoundingClientRect();
const responseBox = response.getBoundingClientRect();
const overflow = responseBox.bottom - (bodyBox.bottom - 28);
if (overflow > 0) body.scrollTop += Math.min(overflow, 36);
};
const pauseFollow = () => { followTypingRef.current = false; };
locEffect(() => { const h = (e) => { if (e.key === "Escape" && open && slash < 0) { if (chatOpen) closeChat(); else closeCenter(); } }; window.addEventListener("keydown", h); return () => window.removeEventListener("keydown", h); }, [open, slash, chatOpen, activeId, serverConversationId]);
locEffect(() => { if (chatOpen) { const t = setTimeout(() => { if (inputRef.current) inputRef.current.focus(); }, 360); return () => clearTimeout(t); } }, [chatOpen]);
locEffect(() => { if (input.startsWith("/")) setSlash(s => s < 0 ? 0 : s); else setSlash(-1); }, [input]);
locEffect(() => {
const element = inputRef.current;
if (!element) return;
element.style.height = "auto";
element.style.height = Math.min(element.scrollHeight, 132) + "px";
}, [input]);
if (!open) return null;
const logo = (cls) => 
{ e.currentTarget.style.display = "none"; }} />