Skip to content

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.

8.7 KB
Raw Blame
// Tests for Anatomy (/anatomy): the spec normalizer, the streaming partial
// scanner the page draws from, the server's salvage path for cut-off model
// text, the writer's stream readers and degenerate-output guard, the opening
// cutaway axis, and the rotor line budget that keeps dense engines fluid.

import { describe, it, expect } from 'vitest';

import { normalizeSpec, extractSpecJson, specStats, AnatomySpecError, LIMITS } from '../src/anatomy/spec.js';
import { scanPartialSpec } from '../src/anatomy/stream.js';
import { buildShape } from '../src/anatomy/shapes.js';
import { openingSection } from '../src/anatomy/viewer.js';
import { parseSpecText } from '../api/_lib/anatomy/service.js';
import { isDegenerate, readChatStream, readAnthropicStream, writerRungs } from '../api/_lib/anatomy/writer.js';
import { SPEC_GUIDE, OUTPUT_RULES } from '../api/_lib/anatomy/guide.js';

const part = (id, extra = {}) => ({ id, name: id, shape: { type: 'box', size: [1, 1, 1] }, ...extra });

function body(chunks) {
	const enc = new TextEncoder();
	return new ReadableStream({
		start(c) {
			for (const ch of chunks) c.enqueue(enc.encode(ch));
			c.close();
		},
	});
}

describe('normalizeSpec', () => {
	it('keeps good parts and warns about bad ones instead of failing', () => {
		const { spec, warnings } = normalizeSpec({
			title: 'Pump',
			parts: [part('a'), part('b', { shape: { type: 'warpdrive' } }), 'junk'],
		});
		expect(spec.parts.map((p) => p.id)).toEqual(['a', 'b']);
		expect(spec.parts[1].shape.type).toBe('box');
		expect(warnings.some((w) => w.includes('warpdrive'))).toBe(true);
	});

	it('rejects a spec with nothing renderable', () => {
		expect(() => normalizeSpec({ title: 'x', parts: [] })).toThrow(AnatomySpecError);
		expect(() => normalizeSpec('nope')).toThrow(AnatomySpecError);
	});

	it('re-roots missing parents and breaks parent cycles', () => {
		const { spec } = normalizeSpec({
			parts: [part('a', { parent: 'b' }), part('b', { parent: 'a' }), part('c', { parent: 'ghost' })],
		});
		const byId = Object.fromEntries(spec.parts.map((p) => [p.id, p]));
		expect(byId.c.parent).toBeNull();
		expect(byId.a.parent === null || byId.b.parent === null).toBe(true);
	});

	it('clamps rotor blades and drops unknown step focus ids', () => {
		const { spec, warnings } = normalizeSpec({
			parts: [part('fan', { shape: { type: 'rotor', blades: 5000, radius: 2 } })],
			steps: [{ title: 'Spin', body: 'It spins.', focus: ['fan', 'nope'] }],
			view: { section: 'q' },
		});
		expect(spec.parts[0].shape.blades).toBe(LIMITS.rotorBlades);
		expect(spec.steps[0].focus).toEqual(['fan']);
		expect(spec.view.section).toBeNull();
		expect(warnings.some((w) => w.includes('nope'))).toBe(true);
	});

	it('counts repeated and moving instances', () => {
		const { spec } = normalizeSpec({
			parts: [part('a', { repeat: { count: 6, radial: { axis: 'y' } }, motion: { type: 'spin', axis: 'y', speed: 1 } }), part('b')],
		});
		const stats = specStats(spec);
		expect(stats.parts).toBe(2);
		expect(stats.instances).toBe(spec.parts[0].repeat.count + 1);
		expect(stats.moving).toBe(spec.parts[0].repeat.count);
	});
});

describe('extractSpecJson', () => {
	it('reads a fenced block or the outermost object', () => {
		expect(extractSpecJson('Here:\n```json\n{"a":1}\n```')).toEqual({ a: 1 });
		expect(extractSpecJson('prose {"b":2} more')).toEqual({ b: 2 });
		expect(extractSpecJson('no json')).toBeNull();
	});
});

describe('scanPartialSpec', () => {
	it('returns every finished element while the text is still arriving', () => {
		const full = JSON.stringify({ title: 'Engine {v2}', parts: [part('a', { description: 'has } braces "and" quotes' }), part('b')] });
		const cut = full.slice(0, full.indexOf('"b"') + 5);
		const out = scanPartialSpec(cut);
		expect(out.title).toBe('Engine {v2}');
		expect(out.parts.map((p) => p.id)).toEqual(['a']);
		expect(scanPartialSpec(full).parts).toHaveLength(2);
	});

	it('never throws on garbage', () => {
		expect(scanPartialSpec('')).toEqual({ parts: [], effects: [], flows: [], steps: [] });
		expect(scanPartialSpec('{"parts":[{"id":')).toMatchObject({ parts: [] });
	});
});

describe('parseSpecText', () => {
	it('salvages the finished parts of a cut-off completion', () => {
		const parts = Array.from({ length: 14 }, (_, i) => part(`p${i}`));
		const text = JSON.stringify({ title: 'Cut', parts }).slice(0, -20);
		const out = parseSpecText(text);
		expect(out.salvaged).toBe(true);
		expect(out.spec.parts.length).toBeGreaterThan(0);
		expect(out.warnings[0]).toMatch(/ran out of room/);
	});

	it('throws when the model returned no spec', () => {
		expect(() => parseSpecText('I cannot do that.')).toThrow(/did not return a JSON spec/);
	});
});

describe('writer', () => {
	it('flags one character repeated forever, not ordinary JSON', () => {
		expect(isDegenerate('{"a":1}' + '!'.repeat(400))).toBe(true);
		expect(isDegenerate(JSON.stringify({ parts: Array.from({ length: 20 }, (_, i) => part(`p${i}`)) }))).toBe(false);
		expect(isDegenerate('!'.repeat(100))).toBe(false);
	});

	it('reads chat-completion deltas split across chunks', async () => {
		const seen = [];
		const out = await readChatStream(
			body([
				'data: {"choices":[{"delta":{"content":"{\\"ti"}}]}\n\n',
				'data: {"choices":[{"delta":{"content":"tle\\"}"},"finish_reason":"stop"}],',
				'"usage":{"prompt_tokens":7,"completion_tokens":3}}\n\ndata: [DONE]\n\n',
			]),
			(t) => seen.push(t),
		);
		expect(out.text).toBe('{"title"}');
		expect(seen).toEqual(['{"ti', 'tle"}']);
		expect(out.stopReason).toBe('stop');
		expect(out.usage).toEqual({ input: 7, output: 3 });
	});

	it('reads Anthropic message streams and surfaces stream errors', async () => {
		const ok = await readAnthropicStream(
			body([
				'event: message_start\ndata: {"type":"message_start","message":{"usage":{"input_tokens":12}}}\n\n',
				'event: content_block_delta\ndata: {"type":"content_block_delta","delta":{"type":"text_delta","text":"{}"}}\n\n',
				'event: message_delta\ndata: {"type":"message_delta","delta":{"stop_reason":"end_turn"},"usage":{"output_tokens":2}}\n\n',
			]),
			() => {},
		);
		expect(ok).toEqual({ text: '{}', usage: { input: 12, output: 2 }, stopReason: 'end_turn' });
		await expect(readAnthropicStream(body(['data: {"type":"error","error":{"message":"overloaded"}}\n\n']), () => {})).rejects.toThrow(/overloaded/);
	});

	it('only offers rungs whose credentials are configured', () => {
		expect(writerRungs({})).toEqual([]);
		const rungs = writerRungs({ NVIDIA_API_KEY: 'k', GOOGLE_CLOUD_PROJECT: 'p' });
		expect(rungs.every((r) => r.provider === 'nvidia')).toBe(true);
		expect(writerRungs({ GOOGLE_CLOUD_PROJECT: 'p', VERTEX_CLAUDE_ENABLED: '1' })[0].provider).toBe('vertex');
	});
});

describe('openingSection', () => {
	it('opens a long machine lengthwise instead of slicing across it', () => {
		expect(openingSection('x', { x: 11, y: 3, z: 3 })).toBe('z');
		expect(openingSection('z', { x: 3, y: 3, z: 11 })).toBe('x');
		expect(openingSection('y', { x: 2, y: 6, z: 2 })).toBe('z');
	});

	it('honours a cut across a short axis or a squat machine', () => {
		expect(openingSection('z', { x: 11, y: 3, z: 3 })).toBe('z');
		expect(openingSection('x', { x: 4, y: 3, z: 3 })).toBe('x');
		expect(openingSection(null, { x: 1, y: 1, z: 1 })).toBeNull();
		expect(openingSection('y', null)).toBe('y');
	});
});

describe('rotor line drawing', () => {
	const rotor = (blades) => normalizeSpec({ parts: [part('r', { shape: { type: 'rotor', axis: 'x', blades, radius: 1.4 } })] }).spec.parts[0].shape;
	const segments = (shape) => {
		const { fill, lines } = buildShape(shape);
		fill.dispose();
		return lines.length / 6;
	};

	it('draws each blade as an outline, not its triangle mesh', () => {
		// Wide blades: 5 segments on each edge, a tip and a root, plus two
		// 32-segment hub circles.
		expect(segments(rotor(12))).toBe(12 * 12 + 64);
	});

	it('keeps a dense compressor stage within a few hundred segments', () => {
		const n = segments(rotor(LIMITS.rotorBlades));
		// Dense stages drop to 3 segments per edge and hide the root.
		expect(n).toBe(LIMITS.rotorBlades * 7 + 64);
		expect(n).toBeLessThan(600);
	});
});

describe('guide', () => {
	it('documents every shape and effect the normalizer accepts', async () => {
		const { SHAPE_TYPES, EFFECT_TYPES, MOTION_TYPES } = await import('../src/anatomy/spec.js');
		for (const t of [...SHAPE_TYPES, ...EFFECT_TYPES, ...MOTION_TYPES]) expect(SPEC_GUIDE).toContain(t);
		expect(SPEC_GUIDE).toMatch(/opened with `"z"`/);
		expect(OUTPUT_RULES).toMatch(/title, subtitle, summary, view, parts/);
	});

	it('ships the same guide in the agent skill', async () => {
		const { readFileSync } = await import('node:fs');
		const { renderReference, REFERENCE_PATH } = await import('../scripts/build-anatomy-skill.mjs');
		expect(readFileSync(REFERENCE_PATH, 'utf8')).toBe(renderReference());
	});
});