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({