fix(core): handle nanosecond timestamps and nullable attemptNumber in RunEvent

Author: bharathkumar39293

packages/core/src/v3/schemas/api-type.test.ts

@@ -189,6 +189,21 @@ describe("RunEvent Schema", () => {
     expect(result.startTime.toISOString()).toBe("2024-03-14T00:00:00.000Z");
   });
 
+  it("handles 19-digit nanosecond startTime strings", () => {
+    const event = { ...validEvent, startTime: "1710374400000000000" };
+    const result = RunEvent.parse(event);
+    expect(result.startTime).toBeInstanceOf(Date);
+    // 1710374400000000000 ns = 1710374400000 ms = 2024-03-14T00:00:00Z
+    expect(result.startTime.toISOString()).toBe("2024-03-14T00:00:00.000Z");
+  });
+
+  it("handles bigint nanosecond startTime", () => {
+    const event = { ...validEvent, startTime: 1710374400000000000n };
+    const result = RunEvent.parse(event as any);
+    expect(result.startTime).toBeInstanceOf(Date);
+    expect(result.startTime.toISOString()).toBe("2024-03-14T00:00:00.000Z");
+  });
+
   it("allows optional/null parentId", () => {
     const eventWithoutParent = { ...validEvent };
     delete (eventWithoutParent as any).parentId;
@@ -197,6 +212,26 @@ describe("RunEvent Schema", () => {
     const eventWithNullParent = { ...validEvent, parentId: null };
     expect(RunEvent.safeParse(eventWithNullParent).success).toBe(true);
   });
+
+  it("allows nullish attemptNumber", () => {
+    const eventWithNullAttempt = { ...validEvent, attemptNumber: null };
+    const result = RunEvent.safeParse(eventWithNullAttempt);
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.attemptNumber).toBe(null);
+    }
+
+    const eventWithoutAttempt = { ...validEvent };
+    delete (eventWithoutAttempt as any).attemptNumber;
+    const result2 = RunEvent.safeParse(eventWithoutAttempt);
+    expect(result2.success).toBe(true);
+  });
+
+  it("supports taskSlug", () => {
+    const eventWithSlug = { ...validEvent, taskSlug: "my-task" };
+    const result = RunEvent.parse(eventWithSlug);
+    expect(result.taskSlug).toBe("my-task");
+  });
 });
 
 describe("ListRunEventsResponse Schema", () => {

packages/core/src/v3/schemas/api.ts

@@ -1643,22 +1643,44 @@ export const SendInputStreamResponseBody = z.object({
 export type SendInputStreamResponseBody = z.infer<typeof SendInputStreamResponseBody>;
 export const TaskEventLevel = z.enum(["TRACE", "DEBUG", "INFO", "LOG", "WARN", "ERROR"]);
 export type TaskEventLevel = z.infer<typeof TaskEventLevel>;
+export const NanosecondTimestampSchema = z
+  .union([z.string(), z.number(), z.bigint()])
+  .transform((val) => {
+    // If it's already a Date, return it (though union doesn't include it)
+    if (typeof val === "object" && val instanceof Date) return val;
+
+    const str = val.toString();
+
+    // 19 digits is nanoseconds (e.g., 1710374400000000000)
+    if (str.length === 19) {
+      return new Date(Number(BigInt(str) / 1000000n));
+    }
+
+    // 13 digits is milliseconds
+    if (str.length === 13) {
+      return new Date(Number(val));
+    }
+
+    // Default to standard date coercion
+    return new Date(val as any);
+  });
 
 export const RunEvent = z.object({
   spanId: z.string(),
   parentId: z.string().nullish(),
   runId: z.string(),
   message: z.string(),
   style: TaskEventStyle,
-  startTime: z.coerce.date(),
+  startTime: NanosecondTimestampSchema,
   duration: z.number(),
   isError: z.boolean(),
   isPartial: z.boolean(),
   isCancelled: z.boolean(),
   level: TaskEventLevel,
   events: SpanEvents.optional(),
   kind: z.string(),
-  attemptNumber: z.number().optional(),
+  attemptNumber: z.number().nullish(),
+  taskSlug: z.string().optional(),
 });
 
 export type RunEvent = z.infer<typeof RunEvent>;