fix(responses): backfill missing status and created_at for strict decoders

Author: bet4it

src/server/responses/responses-field-backfill.ts

@@ -91,6 +91,23 @@ function nextSyntheticItemSlot(): ItemIdSlot {
   return { kind: "fallback", ordinal: syntheticItemOrdinal };
 }
 
+/**
+ * Backfill `status: "completed"` on a message output item if missing.
+ *
+ * The Responses API spec defines `status` as a required field on
+ * `OutputMessage`. Some upstream relays omit it, which causes strict
+ * deserializers (e.g. grok-build's serde types) to fail with
+ * `missing field 'status'`. Only message items carry this field in the
+ * Responses schema; reasoning, function_call, and other item types do not.
+ *
+ * Returns the same object reference if no change is needed.
+ */
+function backfillItemStatus(item: Record<string, unknown>): Record<string, unknown> {
+  if (item.type !== "message") return item;
+  if ("status" in item) return item;
+  return { ...item, status: "completed" };
+}
+
 /**
  * Backfill annotations: [] on an output_text content part if missing.
  * Returns the same object reference if no change is needed.
@@ -136,26 +153,39 @@ function backfillOutputItem(item: unknown, slot: ItemIdSlot): unknown {
   const content = item.content;
   const repaired = backfillContentArray(content);
   const withId = backfillItemId(item, slot);
-  if (repaired === content && withId === item) return item;
-  return { ...withId, ...(repaired === content ? {} : { content: repaired }) };
+  const withStatus = backfillItemStatus(withId);
+  if (repaired === content && withStatus === item) return item;
+  return { ...withStatus, ...(repaired === content ? {} : { content: repaired }) };
 }
 
 /**
  * Walk a response object's output[] and backfill output_text parts.
+ * Also backfills `created_at` on the response itself when absent.
  * Returns the same object reference if nothing changed.
  */
 function backfillResponseOutput(response: unknown): unknown {
   if (!isPlainObject(response)) return response;
-  const output = response.output;
-  if (!Array.isArray(output)) return response;
+  let current = response;
+
+  // Backfill created_at on the Response object. Strict Responses decoders (e.g. grok-build's
+  // serde types) require `created_at: u64` — no `#[serde(default)]` — so an upstream relay that
+  // omits it causes `missing field 'created_at'`. Use the current Unix epoch second; the exact
+  // value is not semantically important to the client, but the field must be present.
+  if (!("created_at" in current)) {
+    current = { ...current, created_at: Math.floor(Date.now() / 1000) };
+  }
+
+  const output = current.output;
+  if (!Array.isArray(output)) return current === response ? response : current;
   let changed = false;
   const repaired = output.map((item, idx) => {
     if (!isPlainObject(item)) return item;
     const next = backfillOutputItem(item, { kind: "index", index: idx });
     if (next !== item) changed = true;
     return next;
   });
-  return changed ? { ...response, output: repaired } : response;
+  if (!changed && current === response) return response;
+  return { ...current, output: repaired };
 }
 
 /**

tests/responses-field-backfill.test.ts

@@ -350,6 +350,153 @@ describe("responses-field-backfill", () => {
     expect(result.output[0].id).toBe("msg_real");
   });
 
+  test("backfills missing status on output_item.done message", () => {
+    const event = {
+      type: "response.output_item.done",
+      output_index: 0,
+      item: {
+        type: "message",
+        id: "msg_1",
+        role: "assistant",
+        content: [{ type: "output_text", text: "hi" }],
+      },
+    };
+    const [out] = apply(sseBlock(event));
+    const parsed = parseData([out])[0];
+    expect(parsed.item.status).toBe("completed");
+  });
+
+  test("preserves existing status on message items", () => {
+    const event = {
+      type: "response.output_item.done",
+      output_index: 0,
+      item: {
+        type: "message",
+        id: "msg_1",
+        role: "assistant",
+        status: "in_progress",
+        content: [{ type: "output_text", text: "hi" }],
+      },
+    };
+    const [out] = apply(sseBlock(event));
+    const parsed = parseData([out])[0];
+    expect(parsed.item.status).toBe("in_progress");
+  });
+
+  test("backfills missing status on response.completed output items", () => {
+    const event = {
+      type: "response.completed",
+      sequence_number: 42,
+      response: {
+        id: "resp_1",
+        object: "response",
+        status: "completed",
+        output: [
+          {
+            type: "message",
+            id: "msg_1",
+            role: "assistant",
+            content: [{ type: "output_text", text: "hello" }],
+          },
+        ],
+      },
+    };
+    const [out] = apply(sseBlock(event));
+    const parsed = parseData([out])[0];
+    expect(parsed.response.output[0].status).toBe("completed");
+  });
+
+  test("does not add status to non-message items", () => {
+    const event = {
+      type: "response.output_item.done",
+      output_index: 0,
+      item: {
+        type: "function_call",
+        id: "fc_1",
+        call_id: "call_1",
+        name: "do_thing",
+        arguments: "{}",
+      },
+    };
+    const [out] = apply(sseBlock(event));
+    const parsed = parseData([out])[0];
+    expect(parsed.item).not.toHaveProperty("status");
+  });
+
+  test("backfillResponsesFieldsJson backfills missing status on message items", () => {
+    const response = {
+      id: "resp_1",
+      object: "response",
+      status: "completed",
+      output: [
+        {
+          type: "message",
+          id: "msg_1",
+          role: "assistant",
+          content: [{ type: "output_text", text: "hello" }],
+        },
+      ],
+    };
+    const result = JSON.parse(backfillResponsesFieldsJson(JSON.stringify(response))) as typeof response;
+    expect(result.output[0].status).toBe("completed");
+  });
+
+  test("backfills missing created_at on response.completed", () => {
+    const event = {
+      type: "response.completed",
+      sequence_number: 42,
+      response: {
+        id: "resp_1",
+        object: "response",
+        status: "completed",
+        model: "grok-4.5",
+        output: [
+          {
+            type: "message",
+            id: "msg_1",
+            role: "assistant",
+            status: "completed",
+            content: [{ type: "output_text", text: "answer" }],
+          },
+        ],
+      },
+    };
+    const [out] = apply(sseBlock(event));
+    const parsed = parseData([out])[0];
+    expect(parsed.response.created_at).toEqual(expect.any(Number));
+    expect(parsed.response.created_at).toBeGreaterThan(0);
+  });
+
+  test("preserves existing created_at on response objects", () => {
+    const event = {
+      type: "response.created",
+      sequence_number: 1,
+      response: {
+        id: "resp_1",
+        object: "response",
+        created_at: 1700000000,
+        status: "in_progress",
+        model: "grok-4.5",
+        output: [],
+      },
+    };
+    const [out] = apply(sseBlock(event));
+    const parsed = parseData([out])[0];
+    expect(parsed.response.created_at).toBe(1700000000);
+  });
+
+  test("backfillResponsesFieldsJson backfills missing created_at", () => {
+    const response = {
+      id: "resp_1",
+      object: "response",
+      status: "completed",
+      output: [],
+    };
+    const result = JSON.parse(backfillResponsesFieldsJson(JSON.stringify(response))) as typeof response;
+    expect(result.created_at).toEqual(expect.any(Number));
+    expect(result.created_at).toBeGreaterThan(0);
+  });
+
   test("the canonical image_generation_call type gets its own prefix", () => {
     const response = {
       id: "resp_1",