core: restructure v2 event system with session.next namespace and data encapsulation

- Rename all event types from session.* to session.next.* for clearer namespacing

- Wrap event payload in data field for better schema organization

- Add timestamp to all event schemas for consistent event tracking

- Fix effect-zod handling for Declaration ASTs with type parameters

- Remove obsolete session-entry-stepper tests

This provides a cleaner event structure that separates metadata from payload data, making the event system more maintainable and easier to extend.

Author: thdxr

packages/opencode/src/util/effect-zod.ts

@@ -90,7 +90,7 @@ function bodyWithChecks(ast: SchemaAST.AST): z.ZodTypeAny {
   // Schema.withDecodingDefault also attaches encoding, but we want `.default(v)`
   // on the inner Zod rather than a transform wrapper — so optional ASTs whose
   // encoding resolves a default from Option.none() route through body()/opt().
-  const hasEncoding = ast.encoding?.length && ast._tag !== "Declaration"
+  const hasEncoding = ast.encoding?.length && (ast._tag !== "Declaration" || ast.typeParameters.length === 0)
   const hasTransform = hasEncoding && !(SchemaAST.isOptional(ast) && extractDefault(ast) !== undefined)
   const base = hasTransform ? encoded(ast) : body(ast)
   return ast.checks?.length ? applyChecks(base, ast.checks, ast) : base

packages/opencode/src/v2/event.ts

@@ -17,13 +17,10 @@ export function define<const Type extends string, Fields extends Schema.Struct.F
   aggregate: string
   version?: number
 }) {
-  const Event = Schema.Struct({
-    id: ID,
+  const Payload = Schema.Struct({
     metadata: Schema.Record(Schema.String, Schema.Unknown).pipe(Schema.optional),
-    timestamp: Schema.DateTimeUtc,
     type: Schema.Literal(input.type),
-    version: Schema.Number.pipe(Schema.optional),
-    ...input.schema,
+    data: Schema.Struct(input.schema),
   }).annotate({
     identifier: input.type,
   })
@@ -32,10 +29,14 @@ export function define<const Type extends string, Fields extends Schema.Struct.F
     type: input.type,
     version: input.version ?? 1,
     aggregate: input.aggregate,
-    schema: Event,
+    schema: Payload.fields.data,
   })
 
-  return Object.assign(Event, { Sync })
+  return Object.assign(Payload, {
+    Sync,
+    version: input.version,
+    aggregate: input.aggregate,
+  })
 }
 
 export * as Event from "./event"

packages/opencode/src/v2/session-entry-stepper.ts

@@ -63,40 +63,40 @@ export function stepWith<Result>(adapter: Adapter<Result>, event: SessionEvent.E
   const latestReasoning = (assistant: DraftAssistant | undefined) =>
     assistant?.content.findLast((item): item is DraftReasoning => item.type === "reasoning")
 
-  SessionEvent.Event.match(event, {
-    "session.prompted": (event) => {
+  SessionEvent.All.match(event, {
+    "session.next.prompted": (event) => {
       const entry = SessionEntry.User.fromEvent(event)
       if (currentAssistant) {
         adapter.appendPending(entry)
         return
       }
       adapter.appendEntry(entry)
     },
-    "session.synthetic": (event) => {
+    "session.next.synthetic": (event) => {
       adapter.appendEntry(SessionEntry.Synthetic.fromEvent(event))
     },
-    "session.step.started": (event) => {
+    "session.next.step.started": (event) => {
       if (currentAssistant) {
         adapter.updateAssistant(
           produce(currentAssistant, (draft) => {
-            draft.time.completed = event.timestamp
+            draft.time.completed = event.data.timestamp
           }),
         )
       }
       adapter.appendEntry(SessionEntry.Assistant.fromEvent(event))
     },
-    "session.step.ended": (event) => {
+    "session.next.step.ended": (event) => {
       if (currentAssistant) {
         adapter.updateAssistant(
           produce(currentAssistant, (draft) => {
-            draft.time.completed = event.timestamp
-            draft.cost = event.cost
-            draft.tokens = event.tokens
+            draft.time.completed = event.data.timestamp
+            draft.cost = event.data.cost
+            draft.tokens = event.data.tokens
           }),
         )
       }
     },
-    "session.text.started": () => {
+    "session.next.text.started": () => {
       if (currentAssistant) {
         adapter.updateAssistant(
           produce(currentAssistant, (draft) => {
@@ -108,27 +108,27 @@ export function stepWith<Result>(adapter: Adapter<Result>, event: SessionEvent.E
         )
       }
     },
-    "session.text.delta": (event) => {
+    "session.next.text.delta": (event) => {
       if (currentAssistant) {
         adapter.updateAssistant(
           produce(currentAssistant, (draft) => {
             const match = latestText(draft)
-            if (match) match.text += event.delta
+            if (match) match.text += event.data.delta
           }),
         )
       }
     },
-    "session.text.ended": () => {},
-    "session.tool.input.started": (event) => {
+    "session.next.text.ended": () => {},
+    "session.next.tool.input.started": (event) => {
       if (currentAssistant) {
         adapter.updateAssistant(
           produce(currentAssistant, (draft) => {
             draft.content.push({
               type: "tool",
-              callID: event.callID,
-              name: event.name,
+              callID: event.data.callID,
+              name: event.data.name,
               time: {
-                created: event.timestamp,
+                created: event.data.timestamp,
               },
               state: {
                 status: "pending",
@@ -139,62 +139,62 @@ export function stepWith<Result>(adapter: Adapter<Result>, event: SessionEvent.E
         )
       }
     },
-    "session.tool.input.delta": (event) => {
+    "session.next.tool.input.delta": (event) => {
       if (currentAssistant) {
         adapter.updateAssistant(
           produce(currentAssistant, (draft) => {
-            const match = latestTool(draft, event.callID)
+            const match = latestTool(draft, event.data.callID)
             // oxlint-disable-next-line no-base-to-string -- event.delta is a Schema.String (runtime string)
-            if (match && match.state.status === "pending") match.state.input += event.delta
+            if (match && match.state.status === "pending") match.state.input += event.data.delta
           }),
         )
       }
     },
-    "session.tool.input.ended": () => {},
-    "session.tool.called": (event) => {
+    "session.next.tool.input.ended": () => {},
+    "session.next.tool.called": (event) => {
       if (currentAssistant) {
         adapter.updateAssistant(
           produce(currentAssistant, (draft) => {
-            const match = latestTool(draft, event.callID)
+            const match = latestTool(draft, event.data.callID)
             if (match) {
-              match.time.ran = event.timestamp
+              match.time.ran = event.data.timestamp
               match.state = {
                 status: "running",
-                input: event.input,
+                input: event.data.input,
               }
             }
           }),
         )
       }
     },
-    "session.tool.success": (event) => {
+    "session.next.tool.success": (event) => {
       if (currentAssistant) {
         adapter.updateAssistant(
           produce(currentAssistant, (draft) => {
-            const match = latestTool(draft, event.callID)
+            const match = latestTool(draft, event.data.callID)
             if (match && match.state.status === "running") {
               match.state = {
                 status: "completed",
                 input: match.state.input,
-                output: event.output ?? "",
-                title: event.title,
+                output: event.data.output ?? "",
+                title: event.data.title,
                 metadata: event.metadata ?? {},
-                attachments: [...(event.attachments ?? [])],
+                attachments: [...(event.data.attachments ?? [])],
               }
             }
           }),
         )
       }
     },
-    "session.tool.error": (event) => {
+    "session.next.tool.error": (event) => {
       if (currentAssistant) {
         adapter.updateAssistant(
           produce(currentAssistant, (draft) => {
-            const match = latestTool(draft, event.callID)
+            const match = latestTool(draft, event.data.callID)
             if (match && match.state.status === "running") {
               match.state = {
                 status: "error",
-                error: event.error,
+                error: event.data.error,
                 input: match.state.input,
                 metadata: event.metadata ?? {},
               }
@@ -203,7 +203,7 @@ export function stepWith<Result>(adapter: Adapter<Result>, event: SessionEvent.E
         )
       }
     },
-    "session.reasoning.started": () => {
+    "session.next.reasoning.started": () => {
       if (currentAssistant) {
         adapter.updateAssistant(
           produce(currentAssistant, (draft) => {
@@ -215,27 +215,27 @@ export function stepWith<Result>(adapter: Adapter<Result>, event: SessionEvent.E
         )
       }
     },
-    "session.reasoning.delta": (event) => {
+    "session.next.reasoning.delta": (event) => {
       if (currentAssistant) {
         adapter.updateAssistant(
           produce(currentAssistant, (draft) => {
             const match = latestReasoning(draft)
-            if (match) match.text += event.delta
+            if (match) match.text += event.data.delta
           }),
         )
       }
     },
-    "session.reasoning.ended": (event) => {
+    "session.next.reasoning.ended": (event) => {
       if (currentAssistant) {
         adapter.updateAssistant(
           produce(currentAssistant, (draft) => {
             const match = latestReasoning(draft)
-            if (match) match.text = event.text
+            if (match) match.text = event.data.text
           }),
         )
       }
     },
-    "session.retried": (event) => {
+    "session.next.retried": (event) => {
       if (currentAssistant) {
         adapter.updateAssistant(
           produce(currentAssistant, (draft) => {
@@ -244,7 +244,7 @@ export function stepWith<Result>(adapter: Adapter<Result>, event: SessionEvent.E
         )
       }
     },
-    "session.compacted": (event) => {
+    "session.next.compacted": (event) => {
       adapter.appendEntry(SessionEntry.Compaction.fromEvent(event))
     },
   })

packages/opencode/src/v2/session-entry.ts

@@ -26,27 +26,30 @@ export class User extends Schema.Class<User>("Session.Entry.User")({
 }) {
   static fromEvent(event: SessionEvent.Prompted) {
     return new User({
-      id: event.id,
+      id: ID.create(),
       type: "user",
       metadata: event.metadata,
-      text: event.prompt.text,
-      files: event.prompt.files,
-      agents: event.prompt.agents,
-      time: { created: event.timestamp },
+      text: event.data.prompt.text,
+      files: event.data.prompt.files,
+      agents: event.data.prompt.agents,
+      time: { created: event.data.timestamp },
     })
   }
 }
 
 export class Synthetic extends Schema.Class<Synthetic>("Session.Entry.Synthetic")({
-  ...SessionEvent.Synthetic.fields,
   ...Base,
+  sessionID: SessionEvent.Synthetic.fields.data.fields.sessionID,
+  text: SessionEvent.Synthetic.fields.data.fields.text,
   type: Schema.Literal("synthetic"),
 }) {
   static fromEvent(event: SessionEvent.Synthetic) {
     return new Synthetic({
-      ...event,
+      sessionID: event.data.sessionID,
+      text: event.data.text,
+      id: ID.create(),
       type: "synthetic",
-      time: { created: event.timestamp },
+      time: { created: event.data.timestamp },
     })
   }
 }
@@ -116,10 +119,10 @@ export class AssistantRetry extends Schema.Class<AssistantRetry>("Session.Entry.
 }) {
   static fromEvent(event: SessionEvent.Retried) {
     return new AssistantRetry({
-      attempt: event.attempt,
-      error: event.error,
+      attempt: event.data.attempt,
+      error: event.data.error,
       time: {
-        created: event.timestamp,
+        created: event.data.timestamp,
       },
     })
   }
@@ -153,10 +156,10 @@ export class Assistant extends Schema.Class<Assistant>("Session.Entry.Assistant"
 }) {
   static fromEvent(event: SessionEvent.Step.Started) {
     return new Assistant({
-      id: event.id,
+      id: ID.create(),
       type: "assistant",
       time: {
-        created: event.timestamp,
+        created: event.data.timestamp,
       },
       content: [],
       retries: [],
@@ -165,15 +168,20 @@ export class Assistant extends Schema.Class<Assistant>("Session.Entry.Assistant"
 }
 
 export class Compaction extends Schema.Class<Compaction>("Session.Entry.Compaction")({
-  ...SessionEvent.Compacted.fields,
   type: Schema.Literal("compaction"),
+  sessionID: SessionEvent.Compacted.fields.data.fields.sessionID,
+  auto: SessionEvent.Compacted.fields.data.fields.auto,
+  overflow: SessionEvent.Compacted.fields.data.fields.overflow,
   ...Base,
 }) {
   static fromEvent(event: SessionEvent.Compacted) {
     return new Compaction({
-      ...event,
+      sessionID: event.data.sessionID,
+      auto: event.data.auto,
+      overflow: event.data.overflow,
+      id: ID.create(),
       type: "compaction",
-      time: { created: event.timestamp },
+      time: { created: event.data.timestamp },
     })
   }
 }