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
import { describe, it, expect, beforeEach } from 'vitest';
import { promises as fs } from 'node:fs';
import os from 'node:os';
import path from 'node:path';
// Isolate the fs-backend store per test run so parallel test files (and repeat
// runs) never see each other's spend history.
const tmpDir = path.join(os.tmpdir(), `threews-persona-spend-test-${process.pid}-${Date.now()}`);
process.env.PERSONA_SPEND_STORE_DIR = tmpDir;
const {
checkPersonaSpend,
recordPersonaSpend,
sessionSpentUsdc,
defaultSessionId,
PERSONA_SPEND_CAPS,
reservePersonaSpend,
releasePersonaSpend,
finalizePersonaSpend,
} = await import('../api/_lib/persona-spend-ledger.js');
beforeEach(async () => {
await fs.rm(tmpDir, { recursive: true, force: true }).catch(() => {});
await fs.mkdir(tmpDir, { recursive: true });
});
describe('persona spend ledger — per-call cap', () => {
it('allows a call within the per-call cap', async () => {
const gate = await checkPersonaSpend({ personaId: 'persona_percall0000001', sessionId: 's1', usdc: PERSONA_SPEND_CAPS.maxPerCallUsdc });
expect(gate.ok).toBe(true);
});
it('blocks a call over the per-call cap', async () => {
const gate = await checkPersonaSpend({ personaId: 'persona_percall0000002', sessionId: 's1', usdc: PERSONA_SPEND_CAPS.maxPerCallUsdc + 0.01 });
expect(gate.ok).toBe(false);
expect(gate.code).toBe('over_call_cap');
});
it('rejects a non-positive amount', async () => {
const gate = await checkPersonaSpend({ personaId: 'persona_percall0000003', sessionId: 's1', usdc: 0 });
expect(gate.ok).toBe(false);
expect(gate.code).toBe('invalid_amount');
});
});
describe('persona spend ledger — cumulative per-session cap', () => {
it('a second call in the same session that would exceed the session cap is blocked', async () => {
const personaId = 'persona_sessioncap00001';
const sessionId = 'session-a';
// Spend right up to (but not over) the per-call cap, repeatedly, until the
// session cap is nearly exhausted, recording each as SETTLED (mirrors what
// the handler does only after a real transfer confirms).
const perCall = Math.min(PERSONA_SPEND_CAPS.maxPerCallUsdc, PERSONA_SPEND_CAPS.maxPerSessionUsdc / 2);
let spent = 0;
while (spent + perCall <= PERSONA_SPEND_CAPS.maxPerSessionUsdc) {
const gate = await checkPersonaSpend({ personaId, sessionId, usdc: perCall });
expect(gate.ok).toBe(true);
await recordPersonaSpend({ personaId, sessionId, usdc: perCall, tool: 'persona_tip', toAddress: 'DestAddr111', signature: `sig-${spent}` });
spent += perCall;
}
// One more call of any positive size should now be blocked by the session cap.
const over = await checkPersonaSpend({ personaId, sessionId, usdc: Math.max(0.001, PERSONA_SPEND_CAPS.maxPerSessionUsdc - spent + 0.001) });
expect(over.ok).toBe(false);
expect(over.code).toBe('over_session_cap');
});
it('a DIFFERENT persona has its own independent cap', async () => {
const personaId = 'persona_sessionisolate01';
await recordPersonaSpend({ personaId, sessionId: 'session-x', usdc: PERSONA_SPEND_CAPS.maxPerSessionUsdc, tool: 'persona_send', toAddress: 'A', signature: 'sig-x' });
const exhausted = await checkPersonaSpend({ personaId, sessionId: 'session-x', usdc: 0.01 });
expect(exhausted.ok).toBe(false);
const otherPersona = await checkPersonaSpend({ personaId: 'persona_sessionisolate02', sessionId: 'session-x', usdc: 0.01 });
expect(otherPersona.ok).toBe(true);
});
it('sessionSpentUsdc sums exactly what was recorded', async () => {
const personaId = 'persona_sumcheck0000001';
const sessionId = 'sum-session';
await recordPersonaSpend({ personaId, sessionId, usdc: 0.1, tool: 'persona_tip', toAddress: 'A', signature: 's1' });
await recordPersonaSpend({ personaId, sessionId, usdc: 0.25, tool: 'persona_tip', toAddress: 'A', signature: 's2' });
expect(await sessionSpentUsdc(personaId, sessionId)).toBeCloseTo(0.35, 6);
});
});
describe('persona spend ledger — default session bucketing', () => {
it('defaultSessionId groups by persona + UTC day', () => {
const id = defaultSessionId('persona_defaultbucket01');
expect(id).toMatch(/^persona_defaultbucket01:\d{4}-\d{2}-\d{2}$/);
});
});
describe('persona spend ledger - cap cannot be reset with a fresh session_id', () => {
it('spend recorded under one session counts against another session of the same persona', async () => {
const personaId = 'persona_freshsession001';
const cap = PERSONA_SPEND_CAPS.maxPerSessionUsdc;
const perCall = PERSONA_SPEND_CAPS.maxPerCallUsdc;
let spent = 0;
while (spent + perCall <= cap + 1e-9) {
await recordPersonaSpend({ personaId, sessionId: 'session-a', usdc: perCall, tool: 'persona_send' });
spent += perCall;
}
const gate = await checkPersonaSpend({ personaId, sessionId: 'session-b', usdc: perCall });
expect(gate.ok).toBe(false);
expect(gate.code).toBe('over_session_cap');
});
});
describe('persona spend ledger - atomic reservation', () => {
it('parallel reservations cannot exceed the session cap', async () => {
const personaId = 'persona_race000000001';
const sessionId = 'race-session';
const perCall = PERSONA_SPEND_CAPS.maxPerCallUsdc;
const attempts = Math.ceil(PERSONA_SPEND_CAPS.maxPerSessionUsdc / perCall) + 4;
const results = await Promise.all(
Array.from({ length: attempts }, () => reservePersonaSpend({ personaId, sessionId, usdc: perCall, tool: 'persona_tip' })),
);
const granted = results.filter((r) => r.ok).length;
expect(granted).toBe(Math.floor(PERSONA_SPEND_CAPS.maxPerSessionUsdc / perCall));
expect(await sessionSpentUsdc(personaId, sessionId)).toBeLessThanOrEqual(PERSONA_SPEND_CAPS.maxPerSessionUsdc);
});
it('a released reservation frees its budget and a finalized one keeps it', async () => {
const personaId = 'persona_release00000001';
const sessionId = 'release-session';
const first = await reservePersonaSpend({ personaId, sessionId, usdc: 0.5, tool: 'persona_tip' });
expect(first.ok).toBe(true);
expect(await sessionSpentUsdc(personaId, sessionId)).toBeCloseTo(0.5);
await releasePersonaSpend(first.reservation);
expect(await sessionSpentUsdc(personaId, sessionId)).toBe(0);
const second = await reservePersonaSpend({ personaId, sessionId, usdc: 0.5, tool: 'persona_tip' });
await finalizePersonaSpend(second.reservation, 'sig-final');
expect(await sessionSpentUsdc(personaId, sessionId)).toBeCloseTo(0.5);
});
it('a fresh session id cannot reset the daily bucket through reservations', async () => {
const personaId = 'persona_daily000000001';
const perCall = PERSONA_SPEND_CAPS.maxPerCallUsdc;
const n = Math.floor(PERSONA_SPEND_CAPS.maxPerSessionUsdc / perCall);
for (let i = 0; i < n; i++) {
expect((await reservePersonaSpend({ personaId, sessionId: `s-${i}`, usdc: perCall, tool: 't' })).ok).toBe(true);
}
const over = await reservePersonaSpend({ personaId, sessionId: 'brand-new', usdc: perCall, tool: 't' });
expect(over.ok).toBe(false);
expect(over.code).toBe('over_session_cap');
});
});