);
}
function MyAgent({ user, onUpdate }) {
// Full agent rows fetched directly from GET /agents so we have
// personality / markets / max_leverage / target_tier / status per agent.
// (user.agents only carries the lightweight card shape used by the
// dashboard's AgentsGridPanel.)
const [agents, setAgents] = useState([]);
const [selectedAgentId, setSelectedAgentId] = useState(null);
const [loadedAgents, setLoadedAgents] = useState(false);
// Per-agent form state. Resets whenever the user picks a different
// agent so each agent's settings are edited in isolation.
const [desc, setDesc] = useState("");
const [target, setTarget] = useState("qualified");
const [markets, setMarkets] = useState([]);
const [maxLev, setMaxLev] = useState(2);
// Strategy-tuning form state — direct edit of strategy_state. When the
// user saves, the agent gets pinned (claude_executor stops auto-tuning).
// Reset to AI un-pins so Claude resumes hourly drift.
const [stratEdits, setStratEdits] = useState({});
const [stratSaving, setStratSaving] = useState(false);
const [saving, setSaving] = useState(false);
const [showApi, setShowApi] = useState(false);
const [keyVisible, setKeyVisible] = useState(false);
const [coachOpen, setCoachOpen] = useState(false);
const [pauseBusy, setPauseBusy] = useState(false);
async function togglePause() {
if (!selected || pauseBusy) return;
const nextAction = selected.status === "active" ? "pause" : "resume";
setPauseBusy(true);
try {
const res = await acSend(`/agents/${selected.id}/${nextAction}`, {});
// Merge the returned agent back into local state so the button + badge
// reflect the new status immediately without waiting on refresh.
const updated = (res && res.agent) || null;
if (updated) {
setAgents(prev => prev.map(a => a.id === selected.id ? { ...a, ...updated } : a));
}
toast && toast.push({
title: nextAction === "pause" ? "Agent paused" : "Agent resumed",
meta: (res && res.message) || "",
duration: 4500,
});
} catch (e) {
const msg = (e && (e.detail || e.message)) || "Try again";
toast && toast.push({ title: `${nextAction === "pause" ? "Pause" : "Resume"} failed`, meta: msg.replace(/^\d+:\s*/, ""), duration: 4000 });
} finally {
setPauseBusy(false);
}
}
const [addOpen, setAddOpen] = useState(false);
const toast = useToast && useToast();
// Fetch agents on mount + on tab-visibility regain (same pattern as
// the dashboard's refreshAgents). Auto-selects the primary if no
// selection yet, falling back to the first agent.
useEffect(() => {
let cancelled = false;
async function refresh() {
try {
const data = await acGet("/agents");
if (cancelled) return;
const list = (data && (data.agents || data)) || [];
setAgents(list);
setLoadedAgents(true);
setSelectedAgentId(prev => {
if (prev && list.some(a => a.id === prev)) return prev;
const primary = list.find(a => a.is_primary) || list[0];
return primary ? primary.id : null;
});
} catch (_) { setLoadedAgents(true); }
}
refresh();
function onVis() { if (!document.hidden) refresh(); }
document.addEventListener("visibilitychange", onVis);
return () => { cancelled = true; document.removeEventListener("visibilitychange", onVis); };
}, []);
const selected = agents.find(a => a.id === selectedAgentId) || null;
// When the user picks a different agent, reset the form to that
// agent's persisted values. Strip the "-PERP" suffix from markets
// for display (chips render bare symbols); we re-append on save.
useEffect(() => {
if (!selected) return;
setDesc(selected.personality || "");
setTarget((selected.target_tier || "qualified").toLowerCase());
setMarkets((selected.markets || []).map(m => m.replace(/-PERP$/, "")));
setMaxLev(Math.max(2, Math.min(20, Number(selected.max_leverage || 2))));
setStratEdits({}); // clear any in-flight tuning edits
}, [selectedAgentId]); // intentionally only on id change
const dirty = selected && (
desc !== (selected.personality || "") ||
target !== (selected.target_tier || "qualified").toLowerCase() ||
JSON.stringify(markets.slice().sort()) !==
JSON.stringify((selected.markets || []).map(m => m.replace(/-PERP$/, "")).slice().sort()) ||
Number(maxLev) !== Math.max(2, Math.min(20, Number(selected.max_leverage || 2)))
);
async function saveChanges() {
if (!selected || saving) return;
setSaving(true);
try {
const updated = await acSend(`/agents/${selected.id}`, {
personality: desc,
markets: (markets || []).map(m => m.endsWith("-PERP") ? m : `${m}-PERP`),
max_leverage: Number(maxLev),
}, "PUT");
// Merge the returned agent back into our local list so the picker
// labels + form baseline reflect the new state without a refetch.
const newAgent = (updated && updated.agent) || updated;
if (newAgent && newAgent.id) {
setAgents(prev => prev.map(a => a.id === newAgent.id ? { ...a, ...newAgent } : a));
}
// Mirror onto the dashboard's user object so other panels see the
// change without waiting for /me's 30s poll.
onUpdate && onUpdate({});
toast && toast.push({ title: `${selected.name} updated`, meta: "Agent picks it up on its next hourly review", duration: 3500 });
} catch (e) {
const msg = (e && (e.detail || e.message)) || "Try again";
toast && toast.push({ title: "Save failed", meta: msg.replace(/^\d+:\s*/, ""), duration: 4000 });
} finally {
setSaving(false);
}
}
// ---------------------------------------------------------------------
// Strategy tuning — PATCH /agents/:id/strategy + POST .../strategy/unpin
//
// stratEdits holds only the fields the user has touched. We merge them
// on top of the agent's current strategy_state for display, but only
// the edits are sent up. The backend merges onto the persisted
// strategy_state and (by default) pins the agent.
// ---------------------------------------------------------------------
function stratGet(field, fallback) {
if (stratEdits[field] !== undefined) return stratEdits[field];
const ss = (selected && selected.strategy_state) || {};
return ss[field] !== undefined ? ss[field] : fallback;
}
function stratSet(field, value) {
setStratEdits(e => ({ ...e, [field]: value }));
}
const stratDirty = Object.keys(stratEdits).length > 0;
const isPinned = !!(selected && selected.strategy_pinned);
async function saveStrategy() {
if (!selected || stratSaving || !stratDirty) return;
setStratSaving(true);
try {
// Coerce numeric fields back from strings (range/number inputs return
// strings depending on the browser). Only send fields the user edited.
const payload = { pin: true };
const numericFields = [
"target_position_size_pct", "max_positions", "leverage",
"stop_loss_pct", "take_profit_pct",
"trailing_trigger_pct", "trailing_lock_pct", "max_hold_hours",
"cooldown_minutes",
];
for (const [k, v] of Object.entries(stratEdits)) {
if (numericFields.includes(k)) {
const n = Number(v);
if (Number.isFinite(n)) payload[k] = n;
} else {
payload[k] = v;
}
}
const res = await acSend(`/agents/${selected.id}/strategy`, payload, "PATCH");
const newAgent = (res && res.agent) || null;
if (newAgent && newAgent.id) {
setAgents(prev => prev.map(a => a.id === newAgent.id ? { ...a, ...newAgent } : a));
}
setStratEdits({});
toast && toast.push({
title: `${selected.name} now self-managed`,
meta: `Your tuning is live — AI will not auto-adjust until you reset.`,
duration: 4500,
});
} catch (e) {
const msg = (e && (e.detail || e.message)) || "Try again";
toast && toast.push({ title: "Save failed", meta: msg.replace(/^\d+:\s*/, ""), duration: 4500 });
} finally {
setStratSaving(false);
}
}
async function resetToAI() {
if (!selected || stratSaving) return;
if (!window.confirm(`Hand ${selected.name} back to the AI? Current strategy stays as a starting point; the AI will tune it on its next hourly review.`)) {
return;
}
setStratSaving(true);
try {
const res = await acSend(`/agents/${selected.id}/strategy/unpin`, null, "POST");
const newAgent = (res && res.agent) || null;
if (newAgent && newAgent.id) {
setAgents(prev => prev.map(a => a.id === newAgent.id ? { ...a, ...newAgent } : a));
}
setStratEdits({});
toast && toast.push({
title: `${selected.name} is AI-managed again`,
meta: `Claude will retune within the hour.`,
duration: 4000,
});
} catch (e) {
const msg = (e && (e.detail || e.message)) || "Try again";
toast && toast.push({ title: "Reset failed", meta: msg.replace(/^\d+:\s*/, ""), duration: 4500 });
} finally {
setStratSaving(false);
}
}
function statusPill(a) {
if (!a) return null;
// Risk state takes precedence over LIVE/PAUSED. Halted is the loudest
// because it's the only state that needs user action to clear.
const rs = a.risk_state;
if (rs === "halted") {
return (
⚠ NO CREDIT
);
}
if (rs === "hard_cut") {
return (
🛑 HARD CUT
);
}
if (rs === "soft_cut") {
return (
⚠ SOFT CUT
);
}
const isLive = a.status === "active";
return (
{isLive ? "● LIVE" : "⏸ PAUSED"}
);
}
return (
{/* Agent picker — shows one tab per owned agent. Hidden when there's
only one (no need to pick) and replaced with a passive label.
When multiple agents exist this is how the user switches between
them; every form action below targets `selected`. */}
{!showApi && (
{selected.kya_status === "verified"
? "Verified by Billions Network — this agent's human owner has been linked on-chain."
: "Identity assigned. Face-scan ownership verification via the Billions app is coming soon."}