Open-source platform for 3D AI agents. Turn text or a photo into a rigged, animated GLB avatar, give it an LLM brain, memory and a wallet, and embed it anywhere with one web component. Remote MCP server, x402 payments, Three.js, browser-native.
JavaScript 3d-generationai-agentsanimationavatardigital-humangenerative-aiglbgltfimage-to-3dllmmcpmcp-servermodel-context-protocolsolanatext-to-3dthreejsweb-componentswebglwebxrx402
/**
* Memory Seed Module
* ------------------
* Reusable identity synthesis + memory management UI that can be mounted
* into any page. Handles connector fetching, Claude synthesis, and saving
* memories to agents via the real API.
*
* Usage:
* import { mountMemorySeed } from './memory-seed.js';
* mountMemorySeed(document.getElementById('container'), { agentId: '...' });
*/
import { apiFetch } from './api.js';
import { renderMarkdown } from './shared/markdown.js';
import { timeAgo } from './shared/coin-format.js';
const esc = (s) => String(s ?? '').replace(/[&<>"']/g, c =>
({ '&': '&', '<': '<', '>': '>', '"': '"', "'": ''' }[c]));
function uuid() {
return crypto.randomUUID ? crypto.randomUUID()
: Math.random().toString(36).slice(2) + Date.now().toString(36);
}
// Synthesized identity text is model output: render it through the shared
// sanitized pipeline (marked + DOMPurify) rather than a local regex pass.
// Headings shift down one level so a `#` sits under the panel's own heading.
function renderMdBasic(md) {
return renderMarkdown(md, { demoteHeadings: 1 });
}
// ── Connector fetching ───────────────────────────────────────────────────────
export async function fetchConnector(name, handle) {
const r = await fetch(`/api/seed/${name}?handle=${encodeURIComponent(handle)}`, {
credentials: 'include',
});
if (!r.ok) {
const body = await r.json().catch(() => ({}));
throw new Error(body.error_description || body.error || `HTTP ${r.status}`);
}
const data = await r.json();
if (data.ok === false) throw new Error(data.reason || 'Connector not configured');
return data;
}
export async function synthesizeMemorySeed(connectors) {
const payload = {};
for (const [name, data] of Object.entries(connectors)) {
if (data) payload[name] = data;
}
if (!Object.keys(payload).length) throw new Error('No connector data');
const r = await fetch('/api/seed/synthesize', {
method: 'POST',
credentials: 'include',
headers: { 'content-type': 'application/json' },
body: JSON.stringify({ connectors: payload }),
});
const body = await r.json();
if (!r.ok || body.ok === false) {
throw new Error(body.error_description || body.error || 'Synthesis failed');
}
return body;
}
export async function saveMemoryToAgent(agentId, content, opts = {}) {
const entry = {
id: uuid(),
type: opts.type || 'user',
content,
tags: opts.tags || ['identity', 'seed'],
salience: opts.salience ?? 0.9,
context: opts.context || {
source: 'memory_seed_synthesis',
synthesized_at: new Date().toISOString(),
},
};
const r = await apiFetch('/api/agent-memory', {
method: 'POST',
credentials: 'include',
headers: { 'content-type': 'application/json' },
body: JSON.stringify({ agentId, entry }),
});
if (!r.ok) {
const body = await r.json().catch(() => ({}));
throw new Error(body.error_description || body.error || `HTTP ${r.status}`);
}
return await r.json();
}
export async function loadAgentMemories(agentId, opts = {}) {
const params = new URLSearchParams({ agentId, limit: String(opts.limit || 500) });
if (opts.type) params.set('type', opts.type);
const r = await fetch(`/api/agent-memory?${params}`, { credentials: 'include' });
if (!r.ok) return [];
const data = await r.json();
return data.entries || [];
}
export async function deleteAgentMemory(agentId, memoryId) {
await apiFetch(`/api/agent-memory/${memoryId}?agentId=${encodeURIComponent(agentId)}`, {
method: 'DELETE',
credentials: 'include',
});
}
export async function addAgentMemory(agentId, entry) {
const payload = {
id: uuid(),
type: entry.type || 'project',
content: entry.content,
tags: entry.tags || [],
salience: entry.salience ?? 0.5,
};
const r = await apiFetch('/api/agent-memory', {
method: 'POST',
credentials: 'include',
headers: { 'content-type': 'application/json' },
body: JSON.stringify({ agentId, entry: payload }),
});
if (!r.ok) throw new Error('Failed to save memory');
return await r.json();
}
export async function loadUserAgents() {
const r = await fetch('/api/agents', { credentials: 'include' });
if (!r.ok) return [];
const data = await r.json();
return data.agents || [];
}
// ── Mountable seed widget ────────────────────────────────────────────────────
export function mountSeedWidget(host, opts = {}) {
const { agentId, compact = false, onSaved } = opts;
const state = {
agentId: agentId || '',
connectors: { github: null, x: null, farcaster: null },
seedMarkdown: '',
};
host.innerHTML = `
<div class="msw" data-compact="${compact}">
<div class="msw-conns">
${['github', 'x', 'farcaster'].map(n => `
<div class="msw-conn" data-name="${n}">
<div class="msw-conn-head">
<span class="msw-conn-icon">${n === 'github' ? 'GH' : n === 'x' ? 'X' : 'FC'}</span>
<span class="msw-conn-label">${n === 'github' ? 'GitHub' : n === 'x' ? 'X' : 'Farcaster'}</span>
<span class="msw-conn-dot" data-dot="${n}"></span>
</div>
<div class="msw-conn-row">
<input type="text" data-input="${n}" placeholder="${n === 'farcaster' ? 'username or fid' : 'handle'}" autocomplete="off" spellcheck="false" />
<button class="msw-btn msw-btn-sm" data-fetch="${n}">Fetch</button>
</div>
</div>
`).join('')}
</div>
<button class="msw-btn msw-btn-full" data-fetch-all>Fetch all & synthesize</button>
<div class="msw-data" data-data hidden></div>
<div class="msw-synth" data-synth hidden>
<div class="msw-synth-output" data-output></div>
<div class="msw-synth-meta" data-meta></div>
<div class="msw-btn-row">
<button class="msw-btn msw-btn-sm" data-copy>Copy</button>
<button class="msw-btn msw-btn-sm" data-save ${!state.agentId ? 'disabled' : ''}>Save to agent</button>
<span class="msw-notice" data-notice></span>
</div>
</div>
</div>
`;
function q(sel) { return host.querySelector(sel); }
function qAll(sel) { return host.querySelectorAll(sel); }
async function doFetch(name) {
const input = q(`[data-input="${name}"]`);
const handle = (input.value || '').trim();
if (!handle) return;
const btn = q(`[data-fetch="${name}"]`);
const dot = q(`[data-dot="${name}"]`);
btn.disabled = true;
btn.textContent = '…';
dot.className = 'msw-conn-dot loading';
try {
state.connectors[name] = await fetchConnector(name, handle);
dot.className = 'msw-conn-dot ok';
q(`[data-name="${name}"]`).classList.add('ok');
} catch {
state.connectors[name] = null;
dot.className = 'msw-conn-dot err';
} finally {
btn.disabled = false;
btn.textContent = 'Fetch';
}
}
async function doFetchAllAndSynthesize() {
const btn = q('[data-fetch-all]');
btn.disabled = true;
btn.textContent = 'Fetching…';
const names = ['github', 'x', 'farcaster'];
const fetches = names
.filter(n => (q(`[data-input="${n}"]`).value || '').trim())
.map(n => doFetch(n));
await Promise.allSettled(fetches);
const hasData = Object.values(state.connectors).some(v => v);
if (!hasData) {
btn.disabled = false;
btn.textContent = 'Fetch all & synthesize';
return;
}
btn.textContent = 'Synthesizing…';
renderData();
try {
const result = await synthesizeMemorySeed(state.connectors);
state.seedMarkdown = result.memory_seed || '';
const synthEl = q('[data-synth]');
synthEl.hidden = false;
q('[data-output]').innerHTML = renderMdBasic(state.seedMarkdown);
q('[data-meta]').innerHTML = `Sources: <b>${result.sources_used.join(' + ')}</b> · <b>${result.tokens_used}</b> tokens`;
} catch (err) {
const synthEl = q('[data-synth]');
synthEl.hidden = false;
q('[data-output]').innerHTML = `<span style="color:#ff5a5a">${esc(err.message)}</span>`;
} finally {
btn.disabled = false;
btn.textContent = 'Fetch all & synthesize';
}
}
function renderData() {
const container = q('[data-data]');
const panels = [];
const gh = state.connectors.github;
if (gh) {
panels.push(`<div class="msw-panel">
<div class="msw-panel-head">
${gh.avatar_url ? `<img loading="lazy" decoding="async" class="msw-panel-av" src="${esc(gh.avatar_url)}" alt="" referrerpolicy="no-referrer"/>` : ''}
<div><div class="msw-panel-name">${esc(gh.name || gh.handle)}</div><div class="msw-panel-sub">@${esc(gh.handle)}</div></div>
</div>
<div class="msw-panel-stats"><span><b>${gh.public_repos}</b> repos</span><span><b>${gh.followers}</b> followers</span></div>
</div>`);
}
const x = state.connectors.x;
if (x) {
panels.push(`<div class="msw-panel">
<div class="msw-panel-head">
${x.avatar_url ? `<img loading="lazy" decoding="async" class="msw-panel-av" src="${esc(x.avatar_url)}" alt="" referrerpolicy="no-referrer"/>` : ''}
<div><div class="msw-panel-name">${esc(x.name || x.handle)}</div><div class="msw-panel-sub">@${esc(x.handle)}</div></div>
</div>
<div class="msw-panel-stats"><span><b>${x.follower_count}</b> followers</span><span><b>${x.tweet_count}</b> posts</span></div>
</div>`);
}
const fc = state.connectors.farcaster;
if (fc) {
// follower_count is null on the keyless hub lane, which serves raw
// protocol messages and cannot know it. Fall back to the cast count
// instead of printing "null followers".
const fcStat = typeof fc.follower_count === 'number'
? `<span><b>${fc.follower_count}</b> followers</span>`
: `<span><b>${fc.recent_casts?.length || 0}</b> casts</span>`;
panels.push(`<div class="msw-panel">
<div class="msw-panel-head">
${fc.avatar_url ? `<img loading="lazy" decoding="async" class="msw-panel-av" src="${esc(fc.avatar_url)}" alt="" referrerpolicy="no-referrer"/>` : ''}
<div><div class="msw-panel-name">${esc(fc.display_name || fc.handle)}</div><div class="msw-panel-sub">@${esc(fc.handle)}</div></div>
</div>
<div class="msw-panel-stats">${fcStat}</div>
</div>`);
}
if (panels.length) {
container.innerHTML = panels.join('');
container.hidden = false;
}
}
qAll('[data-fetch]').forEach(btn => {
btn.addEventListener('click', () => doFetch(btn.dataset.fetch));
});
qAll('[data-input]').forEach(input => {
input.addEventListener('keydown', e => {
if (e.key === 'Enter') {
e.preventDefault();
doFetch(input.dataset.input);
}
});
});
q('[data-fetch-all]').addEventListener('click', doFetchAllAndSynthesize);
q('[data-copy]')?.addEventListener('click', async () => {
if (!state.seedMarkdown) return;
const btn = q('[data-copy]');
try {
await navigator.clipboard.writeText(state.seedMarkdown);
btn.textContent = 'Copied';
} catch {
btn.textContent = 'Copy failed'; // clipboard blocked (permissions / unfocused doc)
}
setTimeout(() => { btn.textContent = 'Copy'; }, 1200);
});
q('[data-save]')?.addEventListener('click', async () => {
if (!state.seedMarkdown || !state.agentId) return;
const btn = q('[data-save]');
const notice = q('[data-notice]');
btn.disabled = true;
btn.textContent = 'Saving…';
notice.className = 'msw-notice';
notice.textContent = '';
try {
await saveMemoryToAgent(state.agentId, state.seedMarkdown);
notice.className = 'msw-notice ok';
notice.textContent = 'Saved to agent.';
onSaved?.();
} catch (err) {
notice.className = 'msw-notice err';
notice.textContent = err.message;
} finally {
btn.disabled = false;
btn.textContent = 'Save to agent';
}
});
return {
setAgentId(id) {
state.agentId = id;
const saveBtn = q('[data-save]');
if (saveBtn) saveBtn.disabled = !state.seedMarkdown || !id;
},
getState() { return { ...state }; },
};
}
// ── Mountable memory browser ─────────────────────────────────────────────────
export function mountMemoryBrowser(host, opts = {}) {
const { agentId } = opts;
const state = {
agentId: agentId || '',
memories: [],
filter: { type: '', search: '' },
showForm: false,
};
host.innerHTML = `
<div class="mmb">
<div class="mmb-form" hidden data-form>
<div class="mmb-form-row">
<select data-form-type>
<option value="user">User</option>
<option value="feedback">Feedback</option>
<option value="project" selected>Project</option>
<option value="reference">Reference</option>
</select>
<input type="text" data-form-tags placeholder="Tags (comma-separated)" style="flex:1" />
</div>
<textarea data-form-content placeholder="Memory content…"></textarea>
<div class="mmb-btn-row">
<button class="msw-btn msw-btn-sm" data-form-save>Save memory</button>
<button class="msw-btn msw-btn-sm msw-btn-ghost" data-form-cancel>Cancel</button>
</div>
</div>
<div class="mmb-bar">
<div class="mmb-pills" data-pills>
<button class="mmb-pill active" data-type="">All</button>
<button class="mmb-pill" data-type="user">User</button>
<button class="mmb-pill" data-type="feedback">Feedback</button>
<button class="mmb-pill" data-type="project">Project</button>
<button class="mmb-pill" data-type="reference">Reference</button>
</div>
<input class="mmb-search" data-search type="text" placeholder="Search…" />
<button class="msw-btn msw-btn-sm msw-btn-ghost" data-add-btn>+ Add</button>
</div>
<div class="mmb-stats" data-stats></div>
<div class="mmb-grid" data-grid></div>
</div>
`;
function q(sel) { return host.querySelector(sel); }
async function load() {
if (!state.agentId) { render([]); return; }
try {
state.memories = await loadAgentMemories(state.agentId);
} catch {
q('[data-grid]').innerHTML =
'<div class="mmb-empty"><h4>Could not load memories</h4><p>Check your connection, then <button type="button" data-mmb-retry style="appearance:none;background:none;border:0;padding:0;font:inherit;color:inherit;cursor:pointer;text-decoration:underline">retry</button>.</p></div>';
q('[data-mmb-retry]')?.addEventListener('click', () => load(), { once: true });
return;
}
render(state.memories);
}
function render(memories) {
const filtered = memories.filter(m => {
if (state.filter.type && m.type !== state.filter.type) return false;
if (state.filter.search) {
const q = state.filter.search.toLowerCase();
return (m.content || '').toLowerCase().includes(q) ||
(m.tags || []).some(t => t.toLowerCase().includes(q));
}
return true;
});
const counts = { user: 0, feedback: 0, project: 0, reference: 0, total: memories.length };
memories.forEach(m => { if (counts[m.type] !== undefined) counts[m.type]++; });
q('[data-stats]').innerHTML = `<span><b>${counts.total}</b> total</span> <span><b>${counts.user}</b> user</span> <span><b>${counts.feedback}</b> feedback</span> <span><b>${counts.project}</b> project</span> <span><b>${counts.reference}</b> reference</span>`;
if (!state.agentId) {
q('[data-grid]').innerHTML = '<div class="mmb-empty"><h4>Select an agent</h4><p>Choose an agent to view its memories.</p></div>';
return;
}
if (!filtered.length) {
q('[data-grid]').innerHTML = `<div class="mmb-empty"><h4>No memories${state.filter.type || state.filter.search ? ' matching filter' : ''}</h4><p>${memories.length ? 'Try a different filter.' : 'Seed your agent or add memories manually.'}</p></div>`;
return;
}
q('[data-grid]').innerHTML = filtered.map(m => `
<div class="mmb-card" data-id="${esc(m.id)}">
<div class="mmb-card-head">
<span class="mmb-badge" data-t="${esc(m.type)}">${esc(m.type)}</span>
<div class="mmb-sal"><div class="mmb-sal-bar"><div class="mmb-sal-fill" style="width:${Math.round((m.salience || 0) * 100)}%"></div></div>${(m.salience || 0).toFixed(2)}</div>
</div>
<div class="mmb-content">${esc(m.content)}</div>
<div class="mmb-foot">
${(m.tags || []).map(t => `<span class="mmb-tag">${esc(t)}</span>`).join('')}
<span class="mmb-date">${timeAgo(m.createdAt || m.created_at || Date.now())}</span>
<button class="mmb-del" data-del="${esc(m.id)}">Del</button>
</div>
</div>
`).join('');
}
q('[data-pills]').addEventListener('click', e => {
const pill = e.target.closest('[data-type]');
if (!pill) return;
state.filter.type = pill.dataset.type;
host.querySelectorAll('.mmb-pill').forEach(p =>
p.classList.toggle('active', p.dataset.type === state.filter.type));
render(state.memories);
});
q('[data-search]').addEventListener('input', e => {
state.filter.search = e.target.value;
render(state.memories);
});
q('[data-add-btn]').addEventListener('click', () => {
const form = q('[data-form]');
form.hidden = !form.hidden;
});
q('[data-form-cancel]').addEventListener('click', () => {
q('[data-form]').hidden = true;
});
q('[data-form-save]').addEventListener('click', async () => {
if (!state.agentId) return;
const content = q('[data-form-content]').value.trim();
if (!content) return;
q('[data-form-save]').disabled = true;
try {
await addAgentMemory(state.agentId, {
type: q('[data-form-type]').value,
content,
tags: q('[data-form-tags]').value.split(',').map(t => t.trim()).filter(Boolean),
});
q('[data-form]').hidden = true;
q('[data-form-content]').value = '';
q('[data-form-tags]').value = '';
await load();
} catch {} finally {
q('[data-form-save]').disabled = false;
}
});
q('[data-grid]').addEventListener('click', async e => {
const del = e.target.closest('[data-del]');
if (del && state.agentId) {
del.disabled = true;
try {
await deleteAgentMemory(state.agentId, del.dataset.del);
} catch {
del.disabled = false;
return; // network failure — keep the row so the user can retry
}
state.memories = state.memories.filter(m => m.id !== del.dataset.del);
render(state.memories);
}
const content = e.target.closest('.mmb-content');
if (content) content.classList.toggle('expanded');
});
load();
return {
setAgentId(id) { state.agentId = id; load(); },
refresh() { load(); },
};
}