@devries-cameron20 / t3code Mirror · read-only / commits / b492e28c7b
Fork 0

The best way to control Claude Code, Codex and more from any computer or phone

Mirrored from https://github.com/Camo67/t3code.git

Synced Nov 22, 05:45 UTC

fix(server): coalesced webhook runs use the prompt saved before dispatch (#29476)

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>

Julius Marminge committed Nov 2, 2026 at 18:50 UTC b492e28c7bad91874f5efdea09c8b4f03faff7e3
3 files changed +118 -5
apps/server/src/scheduledTasks/ScheduledTaskService.ts
+17 -4
@@ -66,6 +66,7 @@ import {
66 acceptImmediateWebhookDedupe,
67 releaseWebhookReplay,
68 decodePendingTask,
69 + encodePendingTask,
70 decodePendingRequest,
71 dedupeError,
72 } from "./webhookDedupe.ts";
@@ -880,7 +881,6 @@ export const layer = Layer.effect(
881 : `${active.id}:webhook:${webhook.deliveryId}`;
882 const commandId = CommandId.make(`scheduled-task:${fireKey}`);
883 const messageId = MessageId.make(`scheduled-task-message:${fireKey}`);
883 - // A webhook prompt was rendered from the row when the request arrived.
884 const prompt = webhook?.prompt ?? active.prompt;
885
886 // A bound thread can move to another project (No project to a project) while
@@ -2331,10 +2331,21 @@ export const layer = Layer.effect(
2331 continue;
2332 }
2333 const prepared = yield* Effect.gen(function* () {
2334 - const task = yield* decodePendingTask(entry.task_json);
2334 + // A running row was already sent, so recovery keeps the prompt it was sent with.
2335 + const current = entry.state === "dispatching" ? yield* findTask(taskId) : null;
2336 + const snapshot = yield* decodePendingTask(entry.task_json);
2337 + // The snapshot keeps the identity runTask checks; the prompt is the one saved now.
2338 + const task =
2339 + current?.createdAt === snapshot.createdAt && current.prompt !== snapshot.prompt
2340 + ? { ...snapshot, prompt: current.prompt }
2341 + : snapshot;
2342 const request = yield* decodePendingRequest(entry.request_json);
2343 const frameId = Buffer.from(yield* random.randomBytes(6)).toString("hex");
2337 - return { task, rendered: renderWebhookPrompt(task.prompt, request, frameId) };
2344 + return {
2345 + task,
2346 + taskJson: task === snapshot ? null : yield* encodePendingTask(task),
2347 + rendered: renderWebhookPrompt(task.prompt, request, frameId),
2348 + };
2349 }).pipe(Effect.exit);
2350 if (Exit.isFailure(prepared)) {
2351 if (Cause.hasInterruptsOnly(prepared.cause))
@@ -2347,11 +2358,13 @@ export const layer = Layer.effect(
2358 yield* remove;
2359 continue;
2360 }
2350 - const { task, rendered } = prepared.value;
2361 + const { task, taskJson, rendered } = prepared.value;
2362 if (rendered.prompt.trim().length > PROVIDER_SEND_TURN_MAX_INPUT_CHARS) {
2363 yield* markDeliveryFailed(entry.delivery_id, PROMPT_TOO_LONG);
2364 yield* releaseFailedDelivery(entry.delivery_id);
2365 } else {
2366 + if (taskJson !== null)
2367 + yield* sql`UPDATE scheduled_task_webhook_pending SET task_json = ${taskJson} WHERE delivery_id = ${entry.delivery_id}`;
2368 yield* sql`UPDATE scheduled_task_webhook_deliveries SET outcome = 'accepted', error = NULL, rendered_prompt = ${rendered.prompt.slice(0, WEBHOOK_DELIVERY_LOG_PROMPT_LIMIT)}, missing_fields_json = ${encodeMissingFieldsJson(rendered.missing)} WHERE delivery_id = ${entry.delivery_id}`;
2369 if (!(yield* runWebhookDelivery(task, entry.delivery_id, rendered.prompt))) return;
2370 }
apps/server/src/scheduledTasks/ScheduledTaskService.webhook.test.ts
+100
@@ -1031,6 +1031,106 @@ it.effect.each([1, 3])(
1031 },
1032 );
1033
1034 +it.effect("a coalesced window dispatches the prompt saved after it opened", () => {
1035 + const workers = new Map<string, Effect.Effect<void>>();
1036 + return withService(
1037 + ({ service, launches }) =>
1038 + Effect.gen(function* () {
1039 + const schedule = {
1040 + type: "webhook",
1041 + dedupe: { coalesceKey: "{{body.id}}", coalesceWindowSeconds: 10 },
1042 + };
1043 + const { task } = yield* service.upsert(
1044 + yield* webhookTaskInput({ prompt: "Use the original instructions.", schedule }),
1045 + );
1046 + const bodyText = JSON.stringify({ id: "review" });
1047 + yield* service.triggerWebhook(
1048 + requestFor(task, { bodyText, body: new TextEncoder().encode(bodyText) }),
1049 + );
1050 + yield* service.upsert(
1051 + yield* webhookTaskInput({ prompt: "Use the updated instructions.", schedule }),
1052 + );
1053 + yield* TestClock.adjust("10 seconds");
1054 + yield* workers.get("webhook-coalescing")!;
1055 + const launched = yield* Queue.take(launches);
1056 + assert.equal(launched.initialMessage?.text, "Use the updated instructions.");
1057 + const owner = (yield* service.listWebhookDeliveries({ id: task.id })).deliveries[0]!;
1058 + const { delivery } = yield* service.getWebhookDelivery({
1059 + id: task.id,
1060 + deliveryId: owner.id,
1061 + });
1062 + assert.equal(delivery.renderedPrompt, "Use the updated instructions.");
1063 + }),
1064 + { workers },
1065 + );
1066 +});
1067 +
1068 +it.effect("retrying a running window keeps the prompt it was dispatched with", () => {
1069 + const workers = new Map<string, Effect.Effect<void>>();
1070 + return withService(
1071 + ({ service, sql, launches }) =>
1072 + Effect.gen(function* () {
1073 + const schedule = {
1074 + type: "webhook",
1075 + dedupe: { coalesceKey: "{{body}}", coalesceWindowSeconds: 10 },
1076 + };
1077 + const save = (prompt: string) =>
1078 + Effect.flatMap(webhookTaskInput({ prompt, schedule }), service.upsert);
1079 + const { task } = yield* save("Prompt when the window opened");
1080 + yield* service.triggerWebhook(requestFor(task));
1081 + yield* save("Prompt at dispatch");
1082 + yield* sql`CREATE TRIGGER fail_completion BEFORE UPDATE ON scheduled_tasks
1083 + WHEN NEW.last_run_status = 'succeeded' BEGIN SELECT RAISE(FAIL, 'completion unavailable'); END`;
1084 + yield* TestClock.adjust("10 seconds");
1085 + yield* drainPendingDispatch(workers);
1086 + const launched = yield* Queue.take(launches);
1087 + assert.equal(launched.initialMessage?.text, "Prompt at dispatch");
1088 + yield* save("Prompt saved after dispatch");
1089 + yield* sql`DROP TRIGGER fail_completion`;
1090 + yield* drainPendingDispatch(workers);
1091 + assert.equal((yield* sql`SELECT 1 FROM scheduled_task_webhook_pending`).length, 0);
1092 + const owner = (yield* service.listWebhookDeliveries({ id: task.id })).deliveries[0]!;
1093 + const { delivery } = yield* service.getWebhookDelivery({
1094 + id: task.id,
1095 + deliveryId: owner.id,
1096 + });
1097 + assert.equal(delivery.renderedPrompt, "Prompt at dispatch");
1098 + }),
1099 + { workers },
1100 + );
1101 +});
1102 +
1103 +it.effect("a coalesced window fails its delivery when the task row cannot be read", () => {
1104 + const workers = new Map<string, Effect.Effect<void>>();
1105 + return withService(
1106 + ({ service, sql, launches }) =>
1107 + Effect.gen(function* () {
1108 + const { task } = yield* service.upsert(
1109 + yield* webhookTaskInput({
1110 + schedule: {
1111 + type: "webhook",
1112 + dedupe: { coalesceKey: "{{body}}", coalesceWindowSeconds: 10 },
1113 + },
1114 + }),
1115 + );
1116 + yield* service.triggerWebhook(requestFor(task));
1117 + yield* sql`UPDATE scheduled_tasks SET model_selection_json = 'not json' WHERE task_id = ${task.id}`;
1118 + yield* TestClock.adjust("10 seconds");
1119 + yield* drainPendingDispatch(workers);
1120 + assert.equal(yield* Queue.size(launches), 0);
1121 + assert.equal((yield* sql`SELECT 1 FROM scheduled_task_webhook_pending`).length, 0);
1122 + const [delivery] = yield* sql<{
1123 + outcome: string;
1124 + error: string | null;
1125 + }>`SELECT outcome, error FROM scheduled_task_webhook_deliveries`;
1126 + assert.equal(delivery?.outcome, "dispatch_failed");
1127 + // Failing before dispatch means a later successful read cannot send the stale snapshot.
1128 + assert.equal(delivery?.error, "The pending webhook payload could not be prepared.");
1129 + }),
1130 + { workers },
1131 + );
1132 +});
1133 +
1134 it.effect("recovers a persisted coalescing window after restarting the service", () => {
1135 const workers = new Map<string, Effect.Effect<void>>();
1136 return withService(
apps/server/src/scheduledTasks/webhookDedupe.ts
+1 -1
@@ -111,7 +111,7 @@ export const acceptImmediateWebhookDedupe = Effect.fn(
111 });
112
113 const PendingTaskJson = Schema.fromJsonString(ScheduledTask);
114 -const encodePendingTask = Schema.encodeEffect(PendingTaskJson);
114 +export const encodePendingTask = Schema.encodeEffect(PendingTaskJson);
115 export const decodePendingTask = Schema.decodeUnknownEffect(PendingTaskJson);
116 const PendingRequestJson = Schema.fromJsonString(
117 Schema.Struct({