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.

fix(webhooks): release a claimed Tripo or print delivery when its side effect throws so provider retries re-run it

nirholas4b32111aafb4
diff --git a/api/_lib/forge-store.js b/api/_lib/forge-store.js
index 09b2e4d61..56408e563 100644
--- a/api/_lib/forge-store.js
+++ b/api/_lib/forge-store.js
@@ -340,6 +340,15 @@ export async function claimForgeWebhookDelivery({ provider, deliveryId, jobId })
return { fresh: rows.length > 0 };
}
+// Drops a claim so the provider's retry of a delivery whose side effect failed
+// runs again instead of being acknowledged as a duplicate.
+export async function releaseForgeWebhookDelivery({ provider, deliveryId }) {
+ await sql`
+ delete from forge_webhook_deliveries
+ where provider = ${provider} and delivery_id = ${deliveryId}
+ `;
+}
+
export async function markForgeWebhookApplied({ provider, deliveryId }) {
await sql`
update forge_webhook_deliveries
diff --git a/api/_lib/print/fulfillment-queries.js b/api/_lib/print/fulfillment-queries.js
index 414e06247..a5bb67903 100644
--- a/api/_lib/print/fulfillment-queries.js
+++ b/api/_lib/print/fulfillment-queries.js
@@ -199,6 +199,17 @@ export async function markWebhookApplied({ provider, deliveryId, orderId = null
where provider = ${provider} and delivery_id = ${deliveryId}`;
}
+/**
+ * Drop a claim so the provider's retry of a delivery whose apply failed runs
+ * again instead of being acknowledged as a duplicate.
+ * @param {{ provider: string, deliveryId: string }} input
+ */
+export async function releaseWebhookDelivery({ provider, deliveryId }) {
+ await sql`
+ delete from print_webhook_deliveries
+ where provider = ${provider} and delivery_id = ${deliveryId}`;
+}
+
/**
* Deliveries recorded against an order, newest first. Diagnostic read for the
* console: "did their webhook actually reach us?" is the first question when a
diff --git a/api/forge/webhook/tripo.js b/api/forge/webhook/tripo.js
index be7baf42a..6d2c12135 100644
--- a/api/forge/webhook/tripo.js
+++ b/api/forge/webhook/tripo.js
@@ -34,6 +34,7 @@ import {
markFailed,
markForgeWebhookApplied,
materializeCreation,
+ releaseForgeWebhookDelivery,
} from '../../_lib/forge-store.js';
const PROVIDER = 'tripo';
@@ -124,36 +125,41 @@ export default wrap(async (req, res) => {
return json(res, 200, { ok: true, applied: false, reason: `event '${eventType}' is informational` });
}
- const existing = await findByJobAnyClient({ replicateJobId: taskId });
- if (!existing) {
- // Verified sender, unknown job (e.g. a task submitted before this row's
- // retention window, or outside forge entirely). Answer 200 so Tripo stops
- // retrying.
- return json(res, 200, { ok: true, applied: false, reason: 'no matching job' });
- }
-
+ // The claim above is released if the lookup or the apply throws, so the 5xx
+ // makes Tripo's retry run the side effect again instead of hitting the ledger.
let applied = true;
- let status = existing.status;
- if (eventType === 'task.completed') {
- const modelUrl = data?.output?.model_url;
- if (!modelUrl) {
- applied = false;
- status = existing.status;
+ let status;
+ try {
+ const existing = await findByJobAnyClient({ replicateJobId: taskId });
+ if (!existing) {
+ // Verified sender, unknown job (e.g. a task submitted before this row's
+ // retention window, or outside forge entirely). Answer 200 so Tripo stops
+ // retrying.
+ return json(res, 200, { ok: true, applied: false, reason: 'no matching job' });
+ }
+ status = existing.status;
+ if (eventType === 'task.completed') {
+ const modelUrl = data?.output?.model_url;
+ if (!modelUrl) {
+ applied = false;
+ } else {
+ const result = await materializeCreation({
+ replicateJobId: taskId,
+ clientKey: existing.client_key,
+ glbUrl: modelUrl,
+ });
+ status = result ? 'done' : existing.status;
+ applied = Boolean(result);
+ }
} else {
- const result = await materializeCreation({
- replicateJobId: taskId,
- clientKey: existing.client_key,
- glbUrl: modelUrl,
- });
- status = result ? 'done' : existing.status;
- applied = Boolean(result);
+ await markFailed({ replicateJobId: taskId, clientKey: existing.client_key, error: failureMessage(data) });
+ status = 'failed';
}
- } else {
- await markFailed({ replicateJobId: taskId, clientKey: existing.client_key, error: failureMessage(data) });
- status = 'failed';
+ await markForgeWebhookApplied({ provider: PROVIDER, deliveryId });
+ } catch (err) {
+ await releaseForgeWebhookDelivery({ provider: PROVIDER, deliveryId }).catch(() => {});
+ throw err;
}
- await markForgeWebhookApplied({ provider: PROVIDER, deliveryId });
-
return json(res, 200, { ok: true, applied, status });
});
diff --git a/api/print/webhook/[provider].js b/api/print/webhook/[provider].js
index d20d244f2..ca0676cad 100644
--- a/api/print/webhook/[provider].js
+++ b/api/print/webhook/[provider].js
@@ -26,6 +26,7 @@ import {
getOrderByProviderId,
markWebhookApplied,
printStoreEnabled,
+ releaseWebhookDelivery,
} from '../../_lib/print/fulfillment-queries.js';
import { getAdapter } from '../../_lib/print/adapters/index.js';
import { normalizeWebhookEvent } from '../../_lib/print/adapters/contract.js';
@@ -82,22 +83,32 @@ export default wrap(async (req, res) => {
return error(res, 400, 'validation_error', 'body must be JSON');
}
- const event = normalizeWebhookEvent(adapter.key, adapter.parseWebhook(payload));
- const order = await getOrderByProviderId(provider, event.providerOrderId);
- if (!order) {
- // Verified sender, unknown job. Answer 200 so they stop retrying, and say
- // so plainly: this is a real condition when a provider replays history
- // after we have deleted an order.
- return json(res, 200, { ok: true, applied: false, reason: 'no matching order' });
- }
+ // Both claims are released if the lookup or the apply throws, so the 5xx
+ // makes the provider's retry run the side effect again instead of hitting
+ // the ledger and being dropped as a duplicate.
+ try {
+ const event = normalizeWebhookEvent(adapter.key, adapter.parseWebhook(payload));
+ const order = await getOrderByProviderId(provider, event.providerOrderId);
+ if (!order) {
+ // Verified sender, unknown job. Answer 200 so they stop retrying, and say
+ // so plainly: this is a real condition when a provider replays history
+ // after we have deleted an order.
+ return json(res, 200, { ok: true, applied: false, reason: 'no matching order' });
+ }
- const result = await applyProviderEvent({ order, event, actor: 'provider' });
- await markWebhookApplied({ provider, deliveryId: verdict.deliveryId, orderId: order.id });
+ const result = await applyProviderEvent({ order, event, actor: 'provider' });
+ await markWebhookApplied({ provider, deliveryId: verdict.deliveryId, orderId: order.id });
- return json(res, 200, {
- ok: true,
- applied: result.applied,
- status: result.order.status,
- reason: result.reason || undefined,
- });
+ return json(res, 200, {
+ ok: true,
+ applied: result.applied,
+ status: result.order.status,
+ reason: result.reason || undefined,
+ });
+ } catch (err) {
+ for (const id of new Set([verdict.deliveryId, verdict.bodyDeliveryId])) {
+ if (id) await releaseWebhookDelivery({ provider, deliveryId: id }).catch(() => {});
+ }
+ throw err;
+ }
});
diff --git a/tests/api/forge-webhook-tripo.test.js b/tests/api/forge-webhook-tripo.test.js
index 4793a23fa..a87159e9e 100644
--- a/tests/api/forge-webhook-tripo.test.js
+++ b/tests/api/forge-webhook-tripo.test.js
@@ -22,6 +22,9 @@ const claimForgeWebhookDelivery = vi.fn(async ({ provider, deliveryId }) => {
return { fresh: true };
});
const markForgeWebhookApplied = vi.fn(async () => {});
+const releaseForgeWebhookDelivery = vi.fn(async ({ provider, deliveryId }) => {
+ ledger.delete(`${provider}:${deliveryId}`);
+});
const materializeCreation = vi.fn(async ({ replicateJobId }) => ({
id: 'creation-1',
glbUrl: `https://cdn.example.com/forge/creation-1.glb`,
@@ -32,6 +35,7 @@ const findByJobAnyClient = vi.fn(async () => ROW);
vi.mock('../../api/_lib/forge-store.js', () => ({
claimForgeWebhookDelivery: (...a) => claimForgeWebhookDelivery(...a),
markForgeWebhookApplied: (...a) => markForgeWebhookApplied(...a),
+ releaseForgeWebhookDelivery: (...a) => releaseForgeWebhookDelivery(...a),
materializeCreation: (...a) => materializeCreation(...a),
markFailed: (...a) => markFailed(...a),
findByJobAnyClient: (...a) => findByJobAnyClient(...a),
@@ -219,12 +223,27 @@ describe('a replayed delivery is applied exactly once', () => {
});
});
+describe('a failed side effect releases the claim so the retry re-runs it', () => {
+ it('lets the Tripo retry apply the completion after the first apply threw', async () => {
+ materializeCreation.mockRejectedValueOnce(new Error('r2 write failed'));
+ const first = await deliver(COMPLETED, { deliveryId: 'dlv-retry' });
+ expect(first.statusCode).toBeGreaterThanOrEqual(500);
+ expect(releaseForgeWebhookDelivery).toHaveBeenCalledWith({ provider: 'tripo', deliveryId: 'dlv-retry' });
+ const retry = await deliver(COMPLETED, { deliveryId: 'dlv-retry' });
+ expect(retry.statusCode).toBe(200);
+ expect(retry.json.duplicate).toBeUndefined();
+ expect(retry.json.applied).toBe(true);
+ expect(materializeCreation).toHaveBeenCalledTimes(2);
+ });
+});
+
describe('the database being unavailable makes Tripo retry', () => {
it('returns 503 when forgeStoreEnabled() is false', async () => {
vi.resetModules();
vi.doMock('../../api/_lib/forge-store.js', () => ({
claimForgeWebhookDelivery,
markForgeWebhookApplied,
+ releaseForgeWebhookDelivery,
materializeCreation,
markFailed,
findByJobAnyClient,
diff --git a/tests/print-webhook-idempotency.test.js b/tests/print-webhook-idempotency.test.js
index a49d21b7a..f79bd5a48 100644
--- a/tests/print-webhook-idempotency.test.js
+++ b/tests/print-webhook-idempotency.test.js
@@ -27,11 +27,15 @@ const claimWebhookDelivery = vi.fn(async ({ provider, deliveryId }) => {
return { fresh: true };
});
const markWebhookApplied = vi.fn(async () => {});
+const releaseWebhookDelivery = vi.fn(async ({ provider, deliveryId }) => {
+ ledger.delete(`${provider}:${deliveryId}`);
+});
const getOrderByProviderId = vi.fn(async () => ORDER);
vi.mock('../api/_lib/print/fulfillment-queries.js', () => ({
claimWebhookDelivery,
markWebhookApplied,
+ releaseWebhookDelivery,
getOrderByProviderId,
printStoreEnabled: () => true,
ADAPTER_DRIVABLE_STATUSES: ['submitted', 'printing', 'quality_check', 'shipped', 'delivered', 'canceled', 'rejected'],
@@ -147,6 +151,20 @@ describe('a replayed delivery is applied exactly once', () => {
});
});
+describe('a failed apply releases the claim so the provider retry re-runs it', () => {
+ it('applies on the retry after the first apply threw', async () => {
+ const PAYLOAD = { id: 'p-42', state: 'shipped' };
+ applyProviderEvent.mockRejectedValueOnce(new Error('db write failed'));
+ const first = await deliver(PAYLOAD, { headers: { 'x-print-delivery': 'dlv_9' } });
+ expect(first.statusCode).toBeGreaterThanOrEqual(500);
+ const retry = await deliver(PAYLOAD, { headers: { 'x-print-delivery': 'dlv_9' } });
+ expect(retry.statusCode).toBe(200);
+ expect(retry.json.duplicate).toBeUndefined();
+ expect(retry.json.applied).toBe(true);
+ expect(timeline).toHaveLength(1);
+ });
+});
+
describe('the unsigned delivery header cannot launder a replay', () => {
it('treats a signed body replayed under a fresh x-print-delivery as a duplicate', async () => {
const PAYLOAD = { id: 'p-42', state: 'shipped' };