fix(webapp): align buffered API responses with existing SDK schemas

A broader audit of every public API route's buffered branch found a
handful of schema-drift bugs the SDK would reject on existing clients:

- /api/v1/runs/{id}/spans/{spanId} returned `parentId: undefined`
  (omitted in JSON). Schema declares `parentId: z.string().nullable()`
  — present-but-null is required. Send `null` explicitly. Also reflect
  the snapshot's cancelled state in `isPartial` / `isCancelled`.

- /api/v1/runs/{id}/reschedule's buffered branch returned a stripped
  `{ id, delayUntil }`. The SDK's `rescheduleRun` validates against the
  full `RetrieveRunResponse` shape. Route the buffered response through
  the same ApiRetrieveRunPresenter the PG branch uses (which falls back
  to the buffer for synthetic runs). Allows `synthesisedResponse` in
  `mutateWithFallback` to be async.

- ApiRetrieveRunPresenter.synthesiseFoundRunFromBuffer ignored the
  snapshot's `cancelledAt` and `delayUntil`. Status was hardcoded to
  `PENDING` regardless of cancellation; `completedAt` and `delayUntil`
  were always `null`. SDK callers (and the MCP cancel_run helper)
  reported status as Queued after a successful cancel. Map the synthetic
  status through a small switch so CANCELED, SYSTEM_FAILURE and PENDING
  all surface correctly.

- Add `delayUntil` to SyntheticRun so set_delay reschedule patches
  survive the next retrieve. Mirror it onto the dashboard SpanRun
  synthesiser too.

Verified end-to-end by replaying every public-API method against a
buffered run.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: d-cs

apps/webapp/app/presenters/v3/ApiRetrieveRunPresenter.server.ts

@@ -523,9 +523,19 @@ function resolveTriggerFunction(run: CommonRelatedRun): TriggerFunction {
 // yet, so every field that comes from execution state (output, attempts,
 // completedAt, cost, relations) takes a default. The presenter's call()
 // handles QUEUED-state runs without surprise.
+function bufferedStatusToTaskRunStatus(status: SyntheticRun["status"]): TaskRunStatus {
+  switch (status) {
+    case "FAILED":
+      return "SYSTEM_FAILURE";
+    case "CANCELED":
+      return "CANCELED";
+    default:
+      return "PENDING";
+  }
+}
+
 function synthesiseFoundRunFromBuffer(buffered: SyntheticRun): FoundRun {
-  const status: TaskRunStatus =
-    buffered.status === "FAILED" ? "SYSTEM_FAILURE" : "PENDING";
+  const status: TaskRunStatus = bufferedStatusToTaskRunStatus(buffered.status);
 
   const errorJson: Prisma.JsonValue = buffered.error
     ? {
@@ -544,10 +554,10 @@ function synthesiseFoundRunFromBuffer(buffered: SyntheticRun): FoundRun {
     taskIdentifier: buffered.taskIdentifier ?? "",
     createdAt: buffered.createdAt,
     startedAt: null,
-    updatedAt: buffered.createdAt,
-    completedAt: null,
+    updatedAt: buffered.cancelledAt ?? buffered.createdAt,
+    completedAt: buffered.cancelledAt ?? null,
     expiredAt: null,
-    delayUntil: null,
+    delayUntil: buffered.delayUntil ?? null,
     metadata,
     metadataType: buffered.metadataType ?? "application/json",
     ttl: buffered.ttl ?? null,

apps/webapp/app/routes/api.v1.runs.$runId.spans.$spanId.ts

@@ -89,20 +89,15 @@ export const loader = createLoaderApiRoute(
       return json(
         {
           spanId: resolved.run.spanId,
-          parentId: resolved.run.parentSpanId,
+          parentId: resolved.run.parentSpanId ?? null,
           runId: resolved.run.friendlyId,
           message: resolved.run.taskIdentifier ?? "",
           isError: false,
-          isPartial: true,
-          isCancelled: false,
+          isPartial: resolved.run.status !== "CANCELED",
+          isCancelled: resolved.run.status === "CANCELED",
           level: "TRACE",
           startTime: resolved.run.createdAt,
           durationMs: 0,
-          properties: undefined,
-          events: undefined,
-          entityType: undefined,
-          ai: undefined,
-          triggeredRuns: undefined,
         },
         { status: 200 }
       );

apps/webapp/app/routes/api.v1.runs.$runParam.reschedule.ts

@@ -76,20 +76,26 @@ export async function action({ request, params }: ActionFunctionArgs) {
         }
         return json(result);
       },
-      // Buffered snapshot has been patched. Synthesise a minimal
-      // retrieve-shape response — the run hasn't materialised yet, so
-      // the presenter's full pass would synthesise mostly defaults
-      // anyway. Returning the friendlyId + the new delay is sufficient
-      // for SDK confirmation; subsequent retrieve calls go through the
-      // existing presenter with read-fallback (Phase A).
-      synthesisedResponse: () =>
-        json(
-          {
-            id: parsed.data.runParam,
-            delayUntil: delayUntil.toISOString(),
-          },
-          { status: 200 }
-        ),
+      // Buffered snapshot has been patched. Run it through the same
+      // ApiRetrieveRunPresenter the PG branch uses (it falls back to
+      // the buffer for the SyntheticRun lookup) so the response shape
+      // matches `RetrieveRunResponse` — that's what the SDK's
+      // `rescheduleRun` zod-validates against. Returning a stripped
+      // `{ id, delayUntil }` object fails the SDK schema on every
+      // existing SDK version.
+      synthesisedResponse: async () => {
+        const run = await ApiRetrieveRunPresenter.findRun(parsed.data.runParam, env);
+        if (!run) {
+          return json({ error: "Run not found" }, { status: 404 });
+        }
+        const apiVersion = getApiVersion(request);
+        const presenter = new ApiRetrieveRunPresenter(apiVersion);
+        const result = await presenter.call(run, env);
+        if (!result) {
+          return json({ error: "Run not found" }, { status: 404 });
+        }
+        return json(result);
+      },
       abortSignal: getRequestAbortSignal(),
     });
 

apps/webapp/app/v3/mollifier/mutateWithFallback.server.ts

@@ -23,7 +23,7 @@ export type MutateWithFallbackInput<TResponse> = {
   pgMutation: (pgRow: TaskRun) => Promise<TResponse>;
   // Called when the patch landed cleanly on the buffer snapshot. The
   // drainer will see the patched payload on its next pop.
-  synthesisedResponse: () => TResponse;
+  synthesisedResponse: () => TResponse | Promise<TResponse>;
   abortSignal?: AbortSignal;
   // Override defaults for tests.
   safetyNetMs?: number;
@@ -77,7 +77,7 @@ export async function mutateWithFallback<TResponse>(
   );
 
   if (result === "applied_to_snapshot") {
-    return { kind: "snapshot", response: input.synthesisedResponse() };
+    return { kind: "snapshot", response: await input.synthesisedResponse() };
   }
 
   if (result === "not_found") {

apps/webapp/app/v3/mollifier/readFallback.server.ts

@@ -25,6 +25,10 @@ export type SyntheticRun = {
   // the drainer materialises it.
   cancelledAt: Date | undefined;
   cancelReason: string | undefined;
+  // Reschedule patch (`set_delay`) writes `delayUntil` into the snapshot.
+  // Surfacing it on SyntheticRun lets the retrieve-run shape reflect the
+  // pending delay before the drainer materialises the PG row.
+  delayUntil: Date | undefined;
   taskIdentifier: string | undefined;
   createdAt: Date;
 
@@ -133,18 +137,22 @@ export async function findRunByIdWithMollifierFallback(
     const cancelledAtRaw = asString(snapshot.cancelledAt);
     const cancelledAt = cancelledAtRaw ? new Date(cancelledAtRaw) : undefined;
     const cancelReason = asString(snapshot.cancelReason);
-    const status: SyntheticRun["status"] = cancelledAt
-      ? "CANCELED"
-      : entry.status === "FAILED"
-      ? "FAILED"
-      : "QUEUED";
+    let status: SyntheticRun["status"] = "QUEUED";
+    if (cancelledAt) {
+      status = "CANCELED";
+    } else if (entry.status === "FAILED") {
+      status = "FAILED";
+    }
+    const delayUntilRaw = asString(snapshot.delayUntil);
+    const delayUntil = delayUntilRaw ? new Date(delayUntilRaw) : undefined;
 
     return {
       id: RunId.fromFriendlyId(entry.runId),
       friendlyId: entry.runId,
       status,
       cancelledAt,
       cancelReason,
+      delayUntil,
       taskIdentifier: asString(snapshot.taskIdentifier),
       createdAt: entry.createdAt,
 

apps/webapp/app/v3/mollifier/syntheticSpanRun.server.ts

@@ -62,7 +62,7 @@ export async function buildSyntheticSpanRun(args: {
     startedAt: null,
     executedAt: null,
     updatedAt: run.cancelledAt ?? run.createdAt,
-    delayUntil: null,
+    delayUntil: run.delayUntil ?? null,
     expiredAt: null,
     completedAt: run.cancelledAt ?? null,
     logsDeletedAt: null,