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.

feat(forge): add a house-key Tripo rerig lane to avatar auto-rig

nirholase366b6fa05e8
diff --git a/api/_lib/regen-provider.js b/api/_lib/regen-provider.js
index 986e04e50..05dcd9f7a 100644
--- a/api/_lib/regen-provider.js
+++ b/api/_lib/regen-provider.js
@@ -82,7 +82,11 @@ function createMeshyRegenAdapter(key) {
};
}
-// Wraps createTripoProvider to speak the regen submit/status interface.
+// Wraps createTripoProvider to speak the regen submit/status interface. Used
+// both as a BYOK provider (user's own key, mode 'reconstruct') and, when
+// TRIPO_API_KEY is set, as a platform provider for 'rerig' (see
+// PLATFORM_PROVIDER_ORDER / loadPlatformProvider below): the house-key auto-
+// rig lane that drives maybeAutoRigAvatar().
function createTripoRegenAdapter(key) {
let _tripo;
async function tripo() {
@@ -95,13 +99,31 @@ function createTripoRegenAdapter(key) {
return {
supportsMode(mode) {
- return mode === 'reconstruct';
+ return mode === 'reconstruct' || mode === 'rerig';
},
supportsMultiview() {
return false;
},
async submit({ mode, params, sourceUrl }) {
+ if (mode === 'rerig') {
+ if (!sourceUrl) {
+ throw Object.assign(new Error('tripo rerig: no source model URL provided'), {
+ code: 'invalid_request',
+ status: 400,
+ });
+ }
+ const provider = await tripo();
+ // spec:'mixamo' asks Tripo for Mixamo-named bones, which this repo's
+ // glb-canonicalize.js already knows how to map onto the canonical
+ // skeleton, so no new bone-naming code is needed to play idle/walk on it.
+ const result = await provider.rig({ input: sourceUrl, spec: 'mixamo' });
+ return {
+ extJobId: result.taskId,
+ eta: 90,
+ backend: 'tripo',
+ };
+ }
if (mode !== 'reconstruct') {
throw Object.assign(
new Error(`tripo BYOK regen does not support mode "${mode}"`),
@@ -161,8 +183,11 @@ export function getRegenProviderByName(name, key) {
const _platformProviderCache = new Map();
// Canonical platform provider names in paid → free precedence. Used both to
-// resolve the single primary and to enumerate failover candidates.
-const PLATFORM_PROVIDER_ORDER = Object.freeze(['replicate', 'gcp', 'huggingface']);
+// resolve the single primary and to enumerate failover candidates. 'tripo'
+// sits last: it is an additional house-key lane (billed through our own
+// credits, see forge-tiers.js), not a replacement for the self-hosted/free
+// options above it, and it only ever contributes 'rerig' candidates.
+const PLATFORM_PROVIDER_ORDER = Object.freeze(['replicate', 'gcp', 'huggingface', 'tripo']);
function canonicalProviderName(name) {
const n = (name || '').trim().toLowerCase();
@@ -181,6 +206,8 @@ function platformProviderConfigured(name) {
return Boolean(process.env.GCP_RECONSTRUCTION_URL && process.env.GCP_RECONSTRUCTION_KEY);
case 'huggingface':
return Boolean(process.env.HF_TOKEN);
+ case 'tripo':
+ return Boolean(process.env.TRIPO_API_KEY);
default:
return false;
}
@@ -215,6 +242,8 @@ async function loadPlatformProvider(rawName) {
instance = (await import('../_providers/huggingface.js')).createRegenProvider();
} else if (name === 'gcp') {
instance = (await import('../_providers/gcp.js')).createRegenProvider();
+ } else if (name === 'tripo') {
+ instance = createTripoRegenAdapter(process.env.TRIPO_API_KEY);
} else {
throw Object.assign(new Error(`unknown AVATAR_REGEN_PROVIDER: ${name}`), {
code: 'regen_provider_unknown',
@@ -317,13 +346,19 @@ export async function getRegenProviderForJob(jobProvider, req) {
// BYOK providers: re-resolve the user's stored key at poll time. The key
// is never stored on the job row itself (it's a secret); the user's session
- // is the authority.
+ // is the authority. Tripo doubles as a platform-level 'rerig' lane (house
+ // key, see PLATFORM_PROVIDER_ORDER above): jobs submitted that way have no
+ // corresponding user session key, so fall back to TRIPO_API_KEY rather than
+ // reporting a false "no instance" for an in-flight house-key job.
if (BYOK_REGEN_PROVIDERS.includes(jobProvider)) {
try {
const { resolveProviderKey } = await import('./forge-provider-key.js');
const key = await resolveProviderKey(req, null, jobProvider);
- if (!key) return { name: jobProvider, instance: null };
- return getRegenProviderByName(jobProvider, key);
+ if (key) return getRegenProviderByName(jobProvider, key);
+ if (jobProvider === 'tripo' && platformProviderConfigured('tripo')) {
+ return loadPlatformProvider('tripo');
+ }
+ return { name: jobProvider, instance: null };
} catch {
return { name: jobProvider, instance: null };
}
diff --git a/tests/regen-provider-tripo.test.js b/tests/regen-provider-tripo.test.js
new file mode 100644
index 000000000..1db4d4493
--- /dev/null
+++ b/tests/regen-provider-tripo.test.js
@@ -0,0 +1,122 @@
+// Tripo plays two roles in regen-provider.js: a BYOK 'reconstruct' provider
+// (the user's own key, unchanged) and, new here, a platform 'rerig' lane that
+// activates when TRIPO_API_KEY is set (house key, billed through our own
+// credits). Both share the provider name 'tripo' on the job row, which makes
+// getRegenProviderForJob's dispatch ambiguous at poll time unless the BYOK
+// branch falls back to the house key when no user session key exists. These
+// tests pin that fallback plus the rerig submit shape.
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+
+const rigMock = vi.fn(async () => ({ kind: 'task', taskId: 'task-rigged' }));
+const imageTo3dMock = vi.fn(async () => ({ kind: 'task', taskId: 'task-recon' }));
+const statusMock = vi.fn(async () => ({ status: 'done', resultGlbUrl: 'https://cdn/rigged.glb' }));
+
+vi.mock('../api/_providers/tripo.js', () => ({
+ createTripoProvider: (key) => ({
+ rig: rigMock,
+ imageTo3d: imageTo3dMock,
+ status: statusMock,
+ _key: key,
+ }),
+}));
+
+let resolveProviderKeyMock;
+vi.mock('../api/_lib/forge-provider-key.js', () => ({
+ resolveProviderKey: (...args) => resolveProviderKeyMock(...args),
+}));
+
+let regen;
+const priorKey = process.env.TRIPO_API_KEY;
+
+beforeEach(async () => {
+ vi.resetModules();
+ rigMock.mockClear();
+ imageTo3dMock.mockClear();
+ resolveProviderKeyMock = vi.fn(async () => null);
+ regen = await import('../api/_lib/regen-provider.js');
+});
+
+afterEach(() => {
+ if (priorKey === undefined) delete process.env.TRIPO_API_KEY;
+ else process.env.TRIPO_API_KEY = priorKey;
+});
+
+describe('tripo regen adapter: rerig mode', () => {
+ it('supports both reconstruct and rerig', () => {
+ const { instance } = regen.getRegenProviderByName('tripo', 'user-key');
+ expect(instance.supportsMode('reconstruct')).toBe(true);
+ expect(instance.supportsMode('rerig')).toBe(true);
+ expect(instance.supportsMode('texture')).toBe(false);
+ });
+
+ it('rerig submit calls provider.rig with spec:mixamo and the source url as input', async () => {
+ const { instance } = regen.getRegenProviderByName('tripo', 'user-key');
+ const result = await instance.submit({ mode: 'rerig', sourceUrl: 'https://cdn/avatar.glb' });
+ expect(rigMock).toHaveBeenCalledWith({ input: 'https://cdn/avatar.glb', spec: 'mixamo' });
+ expect(result).toEqual({ extJobId: 'task-rigged', eta: 90, backend: 'tripo' });
+ });
+
+ it('rerig submit without a sourceUrl throws invalid_request', async () => {
+ const { instance } = regen.getRegenProviderByName('tripo', 'user-key');
+ await expect(instance.submit({ mode: 'rerig' })).rejects.toMatchObject({ code: 'invalid_request' });
+ });
+});
+
+describe('getRegenProviderForJob("tripo") dispatch', () => {
+ it('re-resolves the BYOK user key when a session key exists', async () => {
+ resolveProviderKeyMock = vi.fn(async () => 'user-key');
+ const { name, instance } = await regen.getRegenProviderForJob('tripo', {});
+ expect(name).toBe('tripo');
+ expect(instance).not.toBeNull();
+ await instance.status('task-1');
+ expect(statusMock).toHaveBeenCalledWith({ taskId: 'task-1' });
+ });
+
+ it('falls back to the house key when no user session key exists and TRIPO_API_KEY is set', async () => {
+ process.env.TRIPO_API_KEY = 'house-key';
+ resolveProviderKeyMock = vi.fn(async () => null);
+ const { name, instance } = await regen.getRegenProviderForJob('tripo', {});
+ expect(name).toBe('tripo');
+ expect(instance).not.toBeNull();
+ expect(instance.supportsMode('rerig')).toBe(true);
+ });
+
+ it('reports no instance when neither a user key nor a house key is available', async () => {
+ delete process.env.TRIPO_API_KEY;
+ resolveProviderKeyMock = vi.fn(async () => null);
+ const { name, instance } = await regen.getRegenProviderForJob('tripo', {});
+ expect(name).toBe('tripo');
+ expect(instance).toBeNull();
+ });
+});
+
+describe('platform provider candidates include tripo when TRIPO_API_KEY is set', () => {
+ it('getRegenProviderForMode("rerig") picks up the house tripo lane when nothing else configured', async () => {
+ const priorReplicate = process.env.REPLICATE_API_TOKEN;
+ const priorGcpUrl = process.env.GCP_RECONSTRUCTION_URL;
+ const priorGcpKey = process.env.GCP_RECONSTRUCTION_KEY;
+ const priorHf = process.env.HF_TOKEN;
+ delete process.env.REPLICATE_API_TOKEN;
+ delete process.env.GCP_RECONSTRUCTION_URL;
+ delete process.env.GCP_RECONSTRUCTION_KEY;
+ delete process.env.HF_TOKEN;
+ process.env.TRIPO_API_KEY = 'house-key';
+ try {
+ const { name, instance } = await regen.getRegenProviderForMode('rerig');
+ expect(name).toBe('tripo');
+ expect(instance).not.toBeNull();
+ } finally {
+ if (priorReplicate === undefined) delete process.env.REPLICATE_API_TOKEN; else process.env.REPLICATE_API_TOKEN = priorReplicate;
+ if (priorGcpUrl === undefined) delete process.env.GCP_RECONSTRUCTION_URL; else process.env.GCP_RECONSTRUCTION_URL = priorGcpUrl;
+ if (priorGcpKey === undefined) delete process.env.GCP_RECONSTRUCTION_KEY; else process.env.GCP_RECONSTRUCTION_KEY = priorGcpKey;
+ if (priorHf === undefined) delete process.env.HF_TOKEN; else process.env.HF_TOKEN = priorHf;
+ }
+ });
+
+ it('unset TRIPO_API_KEY keeps tripo out of the platform candidate list', async () => {
+ delete process.env.TRIPO_API_KEY;
+ const { name, instance } = await regen.getRegenProviderForMode('rerig');
+ expect(instance === null || name !== 'tripo').toBe(true);
+ });
+});