@three-ws/mcp-server 1.1.0

package/src/tools/pose-seed.js

@@ -0,0 +1,169 @@
+// `get_pose_seed` — paid MCP tool that maps a natural-language pose prompt to
+// a deterministic seed + a complete joint-rotation map for the three.ws
+// pose-studio mannequin.
+//
+// Pricing: $0.001 USDC, settled `exact` in USDC on Solana mainnet.
+//
+// Output (real, not synthetic): the picked preset's full Euler rotation set
+// from src/pose-presets.js (the same data the public /pose page renders),
+// plus a stable seed derived from sha256(prompt|presetId), and a previewUrl
+// pointing at /pose with the seed param so the user can open the result.
+//
+// Selection algorithm: score every PRESET by token overlap against the
+// prompt, fall back to label/group substring containment, then to a
+// deterministic-by-seed pick across all presets. Always returns a real
+// preset — there is no synthetic-pose codepath.
+
+import { createHash } from 'node:crypto';
+import { z } from 'zod';
+
+import { paid } from '../payments.js';
+import { jsonSchemaFromZod } from './_shared.js';
+import { PRESETS, PRESET_GROUPS } from '../lib/pose-presets.js';
+
+const TOOL_NAME = 'get_pose_seed';
+const TOOL_DESCRIPTION =
+	'Deterministic pose-studio seed + complete joint rotations for the three.ws mannequin, picked from the in-repo preset library by matching natural-language prompt tokens against preset labels, IDs, and groups. Returns the preset id, the full Euler-rotation pose map (radians), a sha256-derived seed, and a previewUrl on three.ws/pose. Paid: $0.001 USDC.';
+
+const PREVIEW_BASE = process.env.MCP_POSE_PREVIEW_BASE || 'https://three.ws/pose';
+
+function tokensOf(s) {
+	return String(s || '')
+		.toLowerCase()
+		.split(/[^a-z0-9]+/g)
+		.filter(Boolean);
+}
+
+// Build a stable token set per preset once. ID, label words, and group all
+// contribute to the scoreable vocabulary so prompts like "running" hit `run`,
+// "wave" hits `wave`, "warrior pose" hits the `warrior` action preset, etc.
+const PRESET_INDEX = PRESETS.map((p) => {
+	const idTokens = tokensOf(p.id);
+	const labelTokens = tokensOf(p.label);
+	const groupTokens = tokensOf(p.group);
+	return {
+		preset: p,
+		all: new Set([...idTokens, ...labelTokens, ...groupTokens]),
+		idTokens,
+		labelTokens,
+	};
+});
+
+function scorePreset(promptTokens, entry) {
+	let score = 0;
+	for (const t of promptTokens) {
+		if (entry.all.has(t)) score += 3;
+		else {
+			// substring containment in id or label gives partial credit so
+			// "wav" hits "wave", "punch" hits "punch (right)".
+			for (const tok of [...entry.idTokens, ...entry.labelTokens]) {
+				if (tok.includes(t) || t.includes(tok)) {
+					score += 1;
+					break;
+				}
+			}
+		}
+	}
+	return score;
+}
+
+function pickPreset(prompt) {
+	const tokens = tokensOf(prompt);
+	if (tokens.length === 0) {
+		// Empty prompt is still legal — we deterministically pick a preset
+		// keyed off the prompt string (which may be whitespace) so the same
+		// caller gets the same result.
+		const hash = createHash('sha256').update(prompt).digest();
+		const idx = hash.readUInt32BE(0) % PRESETS.length;
+		return { entry: PRESET_INDEX[idx], score: 0, reason: 'no-match-deterministic-pick' };
+	}
+	let best = null;
+	let bestScore = -1;
+	for (const entry of PRESET_INDEX) {
+		const s = scorePreset(tokens, entry);
+		if (s > bestScore) {
+			best = entry;
+			bestScore = s;
+		}
+	}
+	if (bestScore <= 0) {
+		const hash = createHash('sha256').update(prompt).digest();
+		const idx = hash.readUInt32BE(0) % PRESETS.length;
+		return { entry: PRESET_INDEX[idx], score: 0, reason: 'no-match-deterministic-pick' };
+	}
+	return { entry: best, score: bestScore, reason: 'token-match' };
+}
+
+function deriveSeed(prompt, presetId) {
+	return createHash('sha256').update(`${prompt}|${presetId}`).digest('hex').slice(0, 16);
+}
+
+// Single source of truth: declare the args once as a Zod shape (with the
+// human-facing descriptions + bounds), and derive the JSON Schema the MCP
+// client / bazaar sees from it. The previous hand-written JSON Schema had no
+// length bounds; the Zod (min 1, max 500) is stricter and now wins.
+const inputZodShape = {
+	prompt: z
+		.string()
+		.min(1)
+		.max(500)
+		.describe('Natural-language description of the pose, e.g. "warrior stance", "wave hello", "sitting cross-legged".'),
+};
+
+const inputJsonSchema = jsonSchemaFromZod(inputZodShape);
+
+export async function buildPoseSeedTool() {
+	const handler = await paid(
+		{
+			toolName: TOOL_NAME,
+			description: TOOL_DESCRIPTION,
+			scheme: 'exact',
+			priceUsd: '$0.001',
+			inputSchema: inputJsonSchema,
+			example: { prompt: 'wave hello' },
+			outputExample: {
+				seed: '8c12...e0f9',
+				presetId: 'wave',
+				presetLabel: 'Wave hello',
+				group: 'Standing',
+				parameters: {
+					shoulderL: { x: 0, y: 0, z: 0.1 },
+					shoulderR: { x: 0, y: 0, z: -2.45 },
+					elbowR: { x: -1.2, y: 0, z: 0 },
+				},
+				previewUrl: 'https://three.ws/pose?seed=8c12...e0f9&preset=wave',
+				match: { score: 3, reason: 'token-match' },
+				groups: PRESET_GROUPS,
+			},
+		},
+		async ({ prompt }) => {
+			const picked = pickPreset(prompt);
+			const seed = deriveSeed(prompt, picked.entry.preset.id);
+			const previewUrl = `${PREVIEW_BASE}?seed=${encodeURIComponent(seed)}&preset=${encodeURIComponent(picked.entry.preset.id)}`;
+			return {
+				seed,
+				presetId: picked.entry.preset.id,
+				presetLabel: picked.entry.preset.label,
+				group: picked.entry.preset.group,
+				parameters: picked.entry.preset.pose,
+				previewUrl,
+				match: { score: picked.score, reason: picked.reason },
+				groups: PRESET_GROUPS,
+			};
+		},
+	);
+	return {
+		name: TOOL_NAME,
+		title: 'Pose seed ($0.001)',
+		description: TOOL_DESCRIPTION,
+		inputSchema: inputZodShape,
+		// Pure deterministic local compute: same prompt → same pose preset,
+		// no external interaction.
+		annotations: {
+			readOnlyHint: true,
+			idempotentHint: true,
+			openWorldHint: false,
+		},
+		handler,
+	};
+}

package/src/tools/pump-snapshot.js

@@ -0,0 +1,262 @@
+// `pump_snapshot` — paid MCP tool returning a real-time market snapshot for a
+// Solana token (pump.fun or any SPL mint).
+//
+// Pricing: $0.005 USDC, settled `exact` in USDC on Solana mainnet.
+//
+// All data is fetched live from public APIs and Solana RPC. No fallback
+// arrays, no mocked numbers. If a source is unreachable the field is null
+// in the response so callers see the gap rather than fake data.
+//
+// Sources:
+//   - Jupiter Lite price API (lite-api.jup.ag/price/v3)         → price, priceChange24h, liquidity
+//   - Dexscreener (api.dexscreener.com/latest/dex/tokens/<mint>) → volume24h, pair url, dex
+//   - pump.fun frontend-api-v3 (frontend-api-v3.pump.fun/coins/<mint>) → image, name, symbol, market_cap, creator
+//   - Solana RPC getTokenLargestAccounts                         → top holder distribution
+//   - Helius DAS getAsset (if HELIUS_API_KEY is set)             → exact holder count when available
+
+import { PublicKey } from '@solana/web3.js';
+import { z } from 'zod';
+
+import { paid, toolError } from '../payments.js';
+import { jsonSchemaFromZod } from './_shared.js';
+import { fetchJson as resilientFetchJson } from '../lib/resilient-fetch.js';
+import { withSolanaConnection, getSolanaEndpoints } from '../lib/solana-rpc.js';
+
+const TOOL_NAME = 'pump_snapshot';
+const TOOL_DESCRIPTION =
+	'Live snapshot for a Solana SPL or pump.fun token: USD price (Jupiter), 24h volume + DEX pair (Dexscreener), mint metadata + image (pump.fun frontend-api-v3), and on-chain top-holder distribution from Solana RPC getTokenLargestAccounts. Optional Helius DAS holder count when HELIUS_API_KEY is configured. Paid: $0.005 USDC.';
+
+const HELIUS_API_KEY = process.env.HELIUS_API_KEY || '';
+
+function isValidSolanaPubkey(s) {
+	try {
+		new PublicKey(s);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+// Every upstream read goes through the shared resilient layer: an 8s per-attempt
+// timeout plus jittered retries on transient 429/5xx and network blips. These
+// are all idempotent GETs (or a read-only JSON-RPC POST), so retrying is safe.
+async function fetchJson(url, init = {}, timeoutMs = 8000) {
+	return resilientFetchJson(url, init, {
+		timeoutMs,
+		retries: 2,
+		retryNonIdempotent: init.method && init.method.toUpperCase() !== 'GET',
+		label: url,
+	});
+}
+
+async function getJupiterPrice(mint) {
+	try {
+		const data = await fetchJson(`https://lite-api.jup.ag/price/v3?ids=${mint}`);
+		const entry = data?.[mint];
+		if (!entry) return null;
+		return {
+			usdPrice: entry.usdPrice ?? null,
+			priceChange24hPct: entry.priceChange24h ?? null,
+			liquidityUsd: entry.liquidity ?? null,
+			decimals: entry.decimals ?? null,
+			blockId: entry.blockId ?? null,
+		};
+	} catch (err) {
+		return { error: err.message };
+	}
+}
+
+async function getDexscreener(mint) {
+	try {
+		const data = await fetchJson(`https://api.dexscreener.com/latest/dex/tokens/${mint}`);
+		const pairs = Array.isArray(data?.pairs) ? data.pairs : [];
+		if (pairs.length === 0) return null;
+		// Pick the pair with the largest 24h volume so a token with multiple
+		// DEX pools surfaces its primary venue.
+		const pair = pairs.reduce((best, p) => {
+			const v = Number(p?.volume?.h24 || 0);
+			return v > (best?.vol || 0) ? { pair: p, vol: v } : best;
+		}, null)?.pair;
+		if (!pair) return null;
+		return {
+			volume24hUsd: Number(pair.volume?.h24 || 0),
+			priceUsd: pair.priceUsd ? Number(pair.priceUsd) : null,
+			priceChange24hPct: pair.priceChange?.h24 ?? null,
+			liquidityUsd: pair.liquidity?.usd ?? null,
+			fdvUsd: pair.fdv ?? null,
+			marketCapUsd: pair.marketCap ?? null,
+			pairAddress: pair.pairAddress,
+			dex: pair.dexId,
+			chain: pair.chainId,
+			url: pair.url,
+			txns24h: pair.txns?.h24 ?? null,
+		};
+	} catch (err) {
+		return { error: err.message };
+	}
+}
+
+async function getPumpFunMeta(mint) {
+	try {
+		const data = await fetchJson(`https://frontend-api-v3.pump.fun/coins/${mint}`);
+		if (!data || data.error) return null;
+		return {
+			name: data.name || null,
+			symbol: data.symbol || null,
+			description: data.description || null,
+			imageUrl: data.image_uri || null,
+			twitter: data.twitter || null,
+			telegram: data.telegram || null,
+			website: data.website || null,
+			creator: data.creator || null,
+			createdAtMs: data.created_timestamp || null,
+			complete: !!data.complete,
+			marketCapUsd: data.usd_market_cap ?? null,
+			marketCapQuote: data.market_cap ?? null,
+			totalSupply: data.total_supply_str || data.total_supply || null,
+			poolAddress: data.pool_address || null,
+			lastTradeTimestampMs: data.last_trade_timestamp || null,
+			athMarketCapUsd: data.ath_market_cap ?? null,
+			athMarketCapTimestampMs: data.ath_market_cap_timestamp || null,
+			program: data.program || null,
+		};
+	} catch (err) {
+		return { error: err.message };
+	}
+}
+
+async function getTopHolders(mint) {
+	try {
+		// Failover across the configured Solana endpoints: if the primary RPC is
+		// throttling or down, the next endpoint answers instead of failing.
+		const res = await withSolanaConnection((conn) =>
+			conn.getTokenLargestAccounts(new PublicKey(mint)),
+		);
+		const top = (res?.value || []).map((acct) => ({
+			address: acct.address.toBase58(),
+			uiAmount: acct.uiAmount,
+			amount: acct.amount,
+			decimals: acct.decimals,
+		}));
+		return {
+			topHolderCount: top.length,
+			topHolders: top,
+		};
+	} catch (err) {
+		return { error: err.message };
+	}
+}
+
+async function getHeliusHolderCount(mint) {
+	if (!HELIUS_API_KEY) return null;
+	try {
+		const url = `https://mainnet.helius-rpc.com/?api-key=${HELIUS_API_KEY}`;
+		const body = {
+			jsonrpc: '2.0',
+			id: 'getAsset',
+			method: 'getAsset',
+			params: { id: mint, options: { showFungible: true } },
+		};
+		const data = await fetchJson(url, {
+			method: 'POST',
+			headers: { 'content-type': 'application/json' },
+			body: JSON.stringify(body),
+		});
+		const supply = data?.result?.token_info?.supply ?? null;
+		const decimals = data?.result?.token_info?.decimals ?? null;
+		const priceInfo = data?.result?.token_info?.price_info ?? null;
+		return {
+			supply: supply !== null ? String(supply) : null,
+			decimals,
+			heliusPriceUsd: priceInfo?.price_per_token ?? null,
+		};
+	} catch (err) {
+		return { error: err.message };
+	}
+}
+
+// Single source of truth: Zod shape carries the base58 validity refinement AND
+// the length bounds/description; the JSON Schema is derived from it. (The
+// refine() predicate is the strict check; the min/max length bounds mirror the
+// previous hand-written JSON Schema so the bazaar still advertises them.)
+const inputZodShape = {
+	token: z
+		.string()
+		.min(32)
+		.max(64)
+		.refine((v) => isValidSolanaPubkey(v), 'must be a base58 Solana pubkey')
+		.describe('Solana SPL or pump.fun mint pubkey (base58).'),
+};
+
+const inputJsonSchema = jsonSchemaFromZod(inputZodShape);
+
+export async function buildPumpSnapshotTool() {
+	const handler = await paid(
+		{
+			toolName: TOOL_NAME,
+			description: TOOL_DESCRIPTION,
+			scheme: 'exact',
+			priceUsd: '$0.005',
+			inputSchema: inputJsonSchema,
+			example: { token: 'HZ1JovNiVvGrGNiiYvEozEVgZ58xaU3RKwX8eACQBCt3' },
+			outputExample: {
+				token: 'HZ1JovNiVvGrGNiiYvEozEVgZ58xaU3RKwX8eACQBCt3',
+				price: { usdPrice: 0.0415, priceChange24hPct: 2.5, liquidityUsd: 107732 },
+				volume24h: { volume24hUsd: 270780.6, dex: 'raydium' },
+				holders: { topHolderCount: 20, topHolders: [{ address: '...', uiAmount: 1234 }] },
+				meta: { name: 'Pyth Network', symbol: 'PYTH', imageUrl: 'https://...' },
+			},
+		},
+		async ({ token }) => {
+			if (!isValidSolanaPubkey(token)) {
+				return toolError('invalid_mint', 'token must be a base58 Solana pubkey', { token });
+			}
+			const [price, ds, meta, holders, helius] = await Promise.all([
+				getJupiterPrice(token),
+				getDexscreener(token),
+				getPumpFunMeta(token),
+				getTopHolders(token),
+				getHeliusHolderCount(token),
+			]);
+			// Price fallback: if Jupiter is unavailable but Dexscreener returned a
+			// pair price, surface it rather than leaving price null — two
+			// independent sources back the single most important field.
+			const priceUsd = price?.usdPrice ?? ds?.priceUsd ?? null;
+			const priceSource =
+				price?.usdPrice != null ? 'jupiter' : ds?.priceUsd != null ? 'dexscreener' : null;
+			return {
+				token,
+				fetchedAt: new Date().toISOString(),
+				price,
+				priceUsd,
+				priceSource,
+				volume24h: ds,
+				meta,
+				holders,
+				helius,
+				image: meta?.imageUrl || null,
+				sources: {
+					price: 'https://lite-api.jup.ag/price/v3',
+					volume24h: 'https://api.dexscreener.com',
+					meta: 'https://frontend-api-v3.pump.fun',
+					holders: getSolanaEndpoints(),
+					helius: HELIUS_API_KEY ? 'https://mainnet.helius-rpc.com' : null,
+				},
+			};
+		},
+	);
+	return {
+		name: TOOL_NAME,
+		title: 'Pump.fun snapshot ($0.005)',
+		description: TOOL_DESCRIPTION,
+		inputSchema: inputZodShape,
+		// Read-only live market snapshot — price/holders move between calls,
+		// so not idempotent.
+		annotations: {
+			readOnlyHint: true,
+			idempotentHint: false,
+			openWorldHint: true,
+		},
+		handler,
+	};
+}

package/src/tools/rig-mesh.js

@@ -0,0 +1,207 @@
+// `rig_mesh` — paid MCP tool: static GLB → rigged, animation-ready GLB.
+//
+// Pricing: $0.20 USDC, settled `exact` on Solana.
+//
+// Takes a GLB mesh URL and returns a rigged GLB — a humanoid skeleton plus
+// per-vertex skin weights — produced by the three.ws auto-rig pipeline
+// (/api/forge?action=rig, VAST-AI UniRig by default). Like mesh_forge, this is
+// a thin x402-gated client over the prod pipeline: it holds no generation
+// credentials; the USDC payment gates the call and all GPU work runs on
+// three.ws prod.
+//
+// Composes with mesh_forge: forge a mesh (text or image → GLB), then feed the
+// returned glbUrl here to get an animation-ready model that loads straight into
+// the three.ws pose studio.
+//
+// Environment (all optional — sensible prod defaults):
+//   MESH_FORGE_API_BASE  — three.ws origin. Default https://three.ws
+//   RIG_MESH_TIMEOUT_MS  — overall rig poll budget. Default 180000.
+//   RIG_MESH_POLL_MS     — poll interval. Default 3000.
+
+import { z } from 'zod';
+
+import { paid, toolError } from '../payments.js';
+import { jsonSchemaFromZod } from './_shared.js';
+
+const TOOL_NAME = 'rig_mesh';
+const TOOL_DESCRIPTION =
+	'Auto-rig a static 3D GLB mesh into an animation-ready model: adds a humanoid skeleton and per-vertex skin weights via the three.ws rig pipeline (VAST-AI UniRig by default). Takes a GLB URL, returns the rigged GLB URL and a three.ws pose-studio link. Pairs with mesh_forge — forge a mesh, then rig it. Paid: $0.20 USDC.';
+
+function env(k, def) {
+	const v = process.env[k];
+	return v && String(v).trim() ? String(v).trim() : def;
+}
+
+function apiBase() {
+	return env('MESH_FORGE_API_BASE', 'https://three.ws').replace(/\/$/, '');
+}
+
+async function startRig(glbUrl) {
+	const base = apiBase();
+	const res = await fetch(`${base}/api/forge?action=rig`, {
+		method: 'POST',
+		headers: { 'content-type': 'application/json' },
+		body: JSON.stringify({ glb_url: glbUrl }),
+		signal: AbortSignal.timeout(30_000),
+	});
+	const data = await res.json().catch(() => ({}));
+	if (res.status === 503) {
+		const e = new Error(data?.message || 'rigging is not configured on the three.ws deployment');
+		e.code = 'not_configured';
+		throw e;
+	}
+	if (res.status === 501) {
+		const e = new Error(data?.message || 'auto-rigging is not enabled on the three.ws deployment');
+		e.code = 'not_configured';
+		throw e;
+	}
+	if (res.status === 429) {
+		const e = new Error(data?.message || 'the rigger is busy; try again shortly');
+		e.code = 'rate_limited';
+		e.retryAfter = data?.retry_after;
+		throw e;
+	}
+	if (!res.ok || !data?.job_id) {
+		const e = new Error(data?.message || `rig start returned ${res.status}`);
+		e.code = 'provider_error';
+		throw e;
+	}
+	return data; // { job_id, creation_id, status, mode:'rig', source_glb_url }
+}
+
+async function pollRig(jobId, { timeoutMs, intervalMs }) {
+	const base = apiBase();
+	const deadline = Date.now() + timeoutMs;
+	let last = null;
+	while (Date.now() < deadline) {
+		let res;
+		try {
+			res = await fetch(`${base}/api/forge?job=${encodeURIComponent(jobId)}`, {
+				headers: { accept: 'application/json' },
+				signal: AbortSignal.timeout(Math.max(intervalMs * 3, 15_000)),
+			});
+		} catch (err) {
+			if (err?.name === 'AbortError' || err?.name === 'TimeoutError') {
+				await new Promise((r) => setTimeout(r, intervalMs));
+				continue;
+			}
+			const e = new Error(`rig poll failed: ${err?.message || err}`);
+			e.code = 'provider_error';
+			throw e;
+		}
+		const data = await res.json().catch(() => ({}));
+		if (!res.ok) {
+			const e = new Error(data?.message || `rig poll returned ${res.status}`);
+			e.code = 'provider_error';
+			throw e;
+		}
+		last = data;
+		if (data.status === 'done' && data.glb_url) return data;
+		if (data.status === 'failed') {
+			const e = new Error(data.error || 'rigging failed');
+			e.code = 'rig_failed';
+			throw e;
+		}
+		await new Promise((r) => setTimeout(r, intervalMs));
+	}
+	return { ...(last || {}), _timedOut: true };
+}
+
+const inputZodShape = {
+	glb_url: z
+		.string()
+		.url()
+		.describe('http(s) URL to the static GLB mesh to rig (e.g. the glbUrl returned by mesh_forge).'),
+};
+
+const inputJsonSchema = jsonSchemaFromZod(inputZodShape);
+
+export async function buildRigMeshTool() {
+	const handler = await paid(
+		{
+			toolName: TOOL_NAME,
+			description: TOOL_DESCRIPTION,
+			scheme: 'exact',
+			priceUsd: '$0.20',
+			inputSchema: inputJsonSchema,
+			example: { glb_url: 'https://three.ws/cdn/creations/abc123/mesh.glb' },
+			outputExample: {
+				ok: true,
+				riggedGlbUrl: 'https://three.ws/cdn/creations/def456/rigged.glb',
+				sourceGlbUrl: 'https://three.ws/cdn/creations/abc123/mesh.glb',
+				poseStudioUrl: 'https://three.ws/pose?src=https%3A%2F%2Fthree.ws%2F...',
+				jobId: 'r9k2m7x4',
+				creationId: 'def456',
+				durationMs: 48000,
+			},
+		},
+		async ({ glb_url }) => {
+			const started = Date.now();
+
+			let job;
+			try {
+				job = await startRig(glb_url);
+			} catch (err) {
+				return toolError(err.code || 'provider_error', err.message, {
+					...(err.retryAfter ? { retryAfter: err.retryAfter } : {}),
+				});
+			}
+
+			const timeoutMs = Number(env('RIG_MESH_TIMEOUT_MS', '180000'));
+			const intervalMs = Number(env('RIG_MESH_POLL_MS', '3000'));
+			let final;
+			try {
+				final = await pollRig(job.job_id, { timeoutMs, intervalMs });
+			} catch (err) {
+				return toolError(err.code || 'provider_error', err.message, {
+					jobId: job.job_id,
+					creationId: job.creation_id ?? null,
+					durationMs: Date.now() - started,
+				});
+			}
+
+			const durationMs = Date.now() - started;
+
+			if (final._timedOut) {
+				return toolError('timeout', `rigging did not finish within ${timeoutMs}ms`, {
+					jobId: job.job_id,
+					creationId: job.creation_id ?? null,
+					status: final.status || 'running',
+					resumeUrl: `${apiBase()}/api/forge?job=${job.job_id}`,
+					durationMs,
+				});
+			}
+
+			const riggedGlbUrl = final.glb_url;
+			const poseStudioUrl = `${apiBase()}/pose?src=${encodeURIComponent(riggedGlbUrl)}`;
+
+			return {
+				ok: true,
+				riggedGlbUrl,
+				sourceGlbUrl: glb_url,
+				poseStudioUrl,
+				jobId: job.job_id,
+				creationId: final.creation_id ?? job.creation_id ?? null,
+				durable: Boolean(final.durable),
+				durationMs,
+				fetchedAt: new Date().toISOString(),
+			};
+		},
+	);
+
+	return {
+		name: TOOL_NAME,
+		title: 'Rig 3D mesh ($0.20)',
+		description: TOOL_DESCRIPTION,
+		inputSchema: inputZodShape,
+		// Creates a new hosted rigged-GLB artifact via external rigging APIs;
+		// the input mesh is never modified or deleted.
+		annotations: {
+			readOnlyHint: false,
+			destructiveHint: false,
+			idempotentHint: false,
+			openWorldHint: true,
+		},
+		handler,
+	};
+}