Move hook input deserialization next to the cast that types it

normalizeHookInput lived in client.ts and inspected for a 'timestamp'
property by name, which felt magical (brittle against any future
hook-shaped wire payload that happens to contain a numeric 'timestamp').

Move the conversion into CopilotSession._handleHooksInvoke, renamed
deserializeHookInput, right next to the GenericHandler cast that says
'this unknown is now a HookInput'. That's the only call site that
actually knows the payload is a hook input, so it's the correct boundary
for the schema transform.

This is the TS equivalent of what C# does via
UnixMillisecondsDateTimeOffsetConverter (attached per-property on each
HookInput.Timestamp); TS just plumbs the same conversion through the
hooks dispatcher instead of a per-type JSON converter.

Verified 3/3 hooks_extended.e2e tests pass locally.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: SteveSandersonMS

nodejs/src/client.ts

@@ -87,23 +87,6 @@ function isZodSchema(value: unknown): value is { toJSONSchema(): Record<string,
     );
 }
 
-/**
- * Normalize an inbound hook input payload by converting the numeric
- * Unix-ms `timestamp` field (as sent on the wire) into a `Date`.
- */
-function normalizeHookInput(input: unknown): unknown {
-    if (
-        input &&
-        typeof input === "object" &&
-        "timestamp" in input &&
-        typeof (input as { timestamp: unknown }).timestamp === "number"
-    ) {
-        const t = (input as { timestamp: number }).timestamp;
-        return { ...(input as Record<string, unknown>), timestamp: new Date(t) };
-    }
-    return input;
-}
-
 /**
  * Convert tool parameters to JSON schema format for sending to CLI
  */
@@ -2059,10 +2042,7 @@ export class CopilotClient {
             throw new Error(`Session not found: ${params.sessionId}`);
         }
 
-        const output = await session._handleHooksInvoke(
-            params.hookType,
-            normalizeHookInput(params.input)
-        );
+        const output = await session._handleHooksInvoke(params.hookType, params.input);
         return { output };
     }
 

nodejs/src/session.ts

@@ -54,6 +54,23 @@ import type {
 export const NO_RESULT_PERMISSION_V2_ERROR =
     "Permission handlers cannot return 'no-result' when connected to a protocol v2 server.";
 
+/**
+ * Convert a raw hook input received over the wire into its public-facing shape.
+ * Currently this only deserializes the numeric Unix-ms `timestamp` field on
+ * BaseHookInput into a Date. Anything else passes through unchanged.
+ */
+function deserializeHookInput(raw: unknown): unknown {
+    if (
+        !raw ||
+        typeof raw !== "object" ||
+        typeof (raw as { timestamp?: unknown }).timestamp !== "number"
+    ) {
+        return raw;
+    }
+    const obj = raw as Record<string, unknown> & { timestamp: number };
+    return { ...obj, timestamp: new Date(obj.timestamp) };
+}
+
 /** Assistant message event - the final response from the assistant. */
 export type AssistantMessageEvent = Extract<SessionEvent, { type: "assistant.message" }>;
 
@@ -955,7 +972,14 @@ export class CopilotSession {
             return undefined;
         }
 
-        // Type-safe handler lookup with explicit casting
+        // All hook inputs share BaseHookInput, which exposes `timestamp` as a Date.
+        // The wire format sends it as Unix epoch ms (number), so we deserialize
+        // here, at the one place that knows the input is a hook payload. Bad data
+        // is left alone — the user-facing handler types still cast unknown to the
+        // specific HookInput, so a runtime type mismatch surfaces as a normal
+        // TypeError in user code rather than being silently masked.
+        const normalized = deserializeHookInput(input);
+
         type GenericHandler = (
             input: unknown,
             invocation: { sessionId: string }
@@ -976,7 +1000,7 @@ export class CopilotSession {
         }
 
         try {
-            const result = await handler(input, { sessionId: this.sessionId });
+            const result = await handler(normalized, { sessionId: this.sessionId });
             return result;
         } catch (_error) {
             // Hook failed, return undefined