fix(server): preserve event API requirements

packages/core/src/event-manifest.ts

@@ -0,0 +1,9 @@
+export * as EventManifest from "./event-manifest"
+
+import { Event } from "@opencode-ai/schema/event"
+import { SessionEvent } from "@opencode-ai/schema/session-event"
+import { SessionV1 } from "@opencode-ai/schema/session-v1"
+
+export const Definitions = Event.inventory(...SessionV1.Events, ...SessionEvent.Definitions)
+export const Latest = Event.latest(Definitions)
+export const Durable = Event.durable(Definitions)

packages/core/src/event.ts

@@ -1,46 +1,19 @@
 export * as EventV2 from "./event"
 
 import { Cause, Context, Effect, Layer, Option, PubSub, Schema, Stream } from "effect"
+import { Event } from "@opencode-ai/schema/event"
+import type { Data, Definition, Payload } from "@opencode-ai/schema/event"
 import { and, asc, eq, gt } from "drizzle-orm"
 import { Database } from "./database/database"
 import { EventSequenceTable, EventTable } from "./event/sql"
 import { Location } from "./location"
-import { withStatics } from "./schema"
-import { Identifier } from "./util/identifier"
 import { LayerNode } from "./effect/layer-node"
 import { isDeepStrictEqual } from "node:util"
+import { EventManifest } from "./event-manifest"
 
-export const ID = Schema.String.check(Schema.isStartsWith("evt_")).pipe(
-  Schema.brand("Event.ID"),
-  withStatics((schema) => ({
-    create: () => schema.make("evt_" + Identifier.ascending()),
-  })),
-)
-export type ID = typeof ID.Type
-
-export type Definition<Type extends string = string, DataSchema extends Schema.Top = Schema.Top> = {
-  readonly type: Type
-  readonly durable?: {
-    readonly version: number
-    readonly aggregate: string
-  }
-  readonly data: DataSchema
-}
-
-export type Data<D extends Definition> = Schema.Schema.Type<D["data"]>
-
-export type Payload<D extends Definition = Definition> = {
-  readonly id: ID
-  readonly type: D["type"]
-  readonly data: Data<D>
-  readonly durable?: {
-    readonly aggregateID: string
-    readonly seq: number
-    readonly version: number
-  }
-  readonly location?: Location.Ref
-  readonly metadata?: Record<string, unknown>
-}
+export const ID = Event.ID
+export type ID = import("@opencode-ai/schema/event").ID
+export type { Data, Definition, Payload } from "@opencode-ai/schema/event"
 
 export type Subscriber<D extends Definition = Definition> = (event: Payload<D>) => Effect.Effect<void>
 export type Unsubscribe = Effect.Effect<void>
@@ -74,52 +47,8 @@ export class InvalidDurableEventError extends Schema.TaggedErrorClass<InvalidDur
   },
 ) {}
 
-export function versionedType(type: string, version: number) {
-  return `${type}.${version}`
-}
-
-export const registry = new Map<string, Definition>()
-const durableRegistry = new Map<string, Definition>()
-
-export function define<const Type extends string, Fields extends Schema.Struct.Fields>(input: {
-  readonly type: Type
-  readonly durable?: {
-    readonly version: number
-    readonly aggregate: string
-  }
-  readonly schema: Fields
-}): Schema.Schema<Payload<Definition<Type, Schema.Struct<Fields>>>> & Definition<Type, Schema.Struct<Fields>> {
-  const Data = Schema.Struct(input.schema)
-  const Payload = Schema.Struct({
-    id: ID,
-    metadata: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
-    type: Schema.Literal(input.type),
-    durable: Schema.optional(Schema.Struct({ aggregateID: Schema.String, seq: Schema.Number, version: Schema.Number })),
-    location: Schema.optional(Location.Ref),
-    data: Data,
-  }).annotate({ identifier: input.type })
-
-  const definition = Object.assign(Payload, {
-    type: input.type,
-    ...(input.durable === undefined ? {} : { durable: input.durable }),
-    data: Data,
-  })
-  const existing = registry.get(input.type)
-  if (
-    input.durable === undefined ||
-    existing?.durable === undefined ||
-    input.durable.version >= existing.durable.version
-  ) {
-    registry.set(input.type, definition)
-  }
-  if (input.durable) durableRegistry.set(versionedType(input.type, input.durable.version), definition)
-  return definition as Schema.Schema<Payload<Definition<Type, Schema.Struct<Fields>>>> &
-    Definition<Type, Schema.Struct<Fields>>
-}
-
-export function definitions() {
-  return registry.values().toArray()
-}
+export const define = Event.define
+export const versionedType = Event.versionedType
 
 export interface PublishOptions {
   readonly id?: ID
@@ -157,18 +86,21 @@ export class Service extends Context.Service<Service, Interface>()("@opencode/Ev
 
 export interface LayerOptions {
   readonly beforeAggregateRead?: (aggregateID: string) => Effect.Effect<void>
+  readonly definitions?: ReadonlyArray<Definition>
 }
 
 export const layerWith = (options?: LayerOptions) =>
   Layer.effect(
     Service,
     Effect.gen(function* () {
+      const durableDefinitions = Event.durable([...EventManifest.Definitions, ...(options?.definitions ?? [])])
       const pubsub = {
         all: yield* PubSub.unbounded<Payload>(),
         durable: new Map<string, Set<PubSub.PubSub<void>>>(),
         typed: new Map<string, PubSub.PubSub<Payload>>(),
       }
       const projectors = new Map<string, Subscriber[]>()
+      // Projectors intentionally retain type-only dispatch. Exact type+version dispatch is a separate replay design.
       const listeners = new Array<Subscriber>()
       const { db } = yield* Database.Service
 
@@ -194,6 +126,7 @@ export const layerWith = (options?: LayerOptions) =>
       )
 
       function commitDurableEvent(
+        definition: Definition,
         event: Payload,
         input?: {
           readonly seq: number
@@ -204,7 +137,6 @@ export const layerWith = (options?: LayerOptions) =>
         commit?: (seq: number) => Effect.Effect<void>,
       ) {
         return Effect.gen(function* () {
-          const definition = registry.get(event.type)
           const durable = definition?.durable
           if (durable) {
             const aggregateID = (event.data as Record<string, unknown>)[durable.aggregate]
@@ -238,9 +170,10 @@ export const layerWith = (options?: LayerOptions) =>
                             .get()
                             .pipe(Effect.orDie)
                           const latest = row?.seq ?? -1
-                          const encoded = Schema.encodeUnknownSync(
-                            definition.data as Schema.Codec<unknown, unknown, never, never>,
-                          )(event.data) as Record<string, unknown>
+                          const encoded = Schema.encodeUnknownSync(definition.data)(event.data) as Record<
+                            string,
+                            unknown
+                          >
                           if (input?.strictOwner && row?.ownerID && row.ownerID !== input.ownerID) {
                             yield* Effect.die(
                               new InvalidDurableEventError({
@@ -356,9 +289,8 @@ export const layerWith = (options?: LayerOptions) =>
         })
       }
 
-      function publishEvent<D extends Definition>(event: Payload<D>, commit?: PublishOptions["commit"]) {
+      function publishEvent<D extends Definition>(definition: D, event: Payload<D>, commit?: PublishOptions["commit"]) {
         return Effect.gen(function* () {
-          const definition = registry.get(event.type)
           if (!definition?.durable && commit)
             return yield* Effect.die(
               new InvalidDurableEventError({
@@ -367,7 +299,7 @@ export const layerWith = (options?: LayerOptions) =>
               }),
             )
           if (definition?.durable) {
-            const committed = yield* commitDurableEvent(event as Payload, undefined, commit)
+            const committed = yield* commitDurableEvent(definition, event as Payload, undefined, commit)
             if (committed) {
               event = {
                 ...event,
@@ -416,6 +348,7 @@ export const layerWith = (options?: LayerOptions) =>
               ? { directory: serviceLocation.directory, workspaceID: serviceLocation.workspaceID }
               : undefined)
           return yield* publishEvent(
+            definition,
             {
               id: options?.id ?? ID.create(),
               ...(options?.metadata ? { metadata: options.metadata } : {}),
@@ -433,7 +366,7 @@ export const layerWith = (options?: LayerOptions) =>
         options?: { readonly publish?: boolean; readonly ownerID?: string; readonly strictOwner?: boolean },
       ) {
         return Effect.gen(function* () {
-          const definition = durableRegistry.get(event.type)
+          const definition = durableDefinitions.get(event.type)
           if (!definition?.durable) {
             yield* Effect.die(
               new InvalidDurableEventError({ type: event.type, message: `Unknown durable event type ${event.type}` }),
@@ -442,11 +375,9 @@ export const layerWith = (options?: LayerOptions) =>
             const payload = {
               id: event.id,
               type: definition.type,
-              data: Schema.decodeUnknownSync(definition.data as Schema.Codec<unknown, unknown, never, never>)(
-                event.data,
-              ),
+              data: Schema.decodeUnknownSync(definition.data)(event.data),
             } as Payload
-            const committed = yield* commitDurableEvent(payload, {
+            const committed = yield* commitDurableEvent(definition, payload, {
               seq: event.seq,
               aggregateID: event.aggregateID,
               ownerID: options?.ownerID,
@@ -530,8 +461,8 @@ export const layerWith = (options?: LayerOptions) =>
 
       const streamAll = (): Stream.Stream<Payload> => Stream.fromPubSub(pubsub.all)
 
-      const decodeSerializedEvent = (event: SerializedEvent): Payload => {
-        const definition = durableRegistry.get(event.type)
+      const decodeSerializedEvent = (event: SerializedEvent) => {
+        const definition = durableDefinitions.get(event.type)
         if (!definition?.durable) {
           throw new InvalidDurableEventError({ type: event.type, message: `Unknown durable event type ${event.type}` })
         }
@@ -539,7 +470,7 @@ export const layerWith = (options?: LayerOptions) =>
           id: event.id,
           type: definition.type,
           durable: { aggregateID: event.aggregateID, seq: event.seq, version: definition.durable.version },
-          data: Schema.decodeUnknownSync(definition.data as Schema.Codec<unknown, unknown, never, never>)(event.data),
+          data: Schema.decodeUnknownSync(definition.data)(event.data),
         }
       }
 

packages/core/src/public-event-manifest.ts

@@ -0,0 +1,47 @@
+export * as PublicEventManifest from "./public-event-manifest"
+
+import { Event } from "@opencode-ai/schema/event"
+import { Todo } from "@opencode-ai/schema/todo"
+import { Catalog } from "./catalog"
+import { FileSystem } from "./filesystem"
+import { Watcher } from "./filesystem/watcher"
+import { Integration } from "./integration"
+import { ModelsDev } from "./models-dev"
+import { PermissionV2 } from "./permission"
+import { PluginV2 } from "./plugin"
+import { ProjectCopy } from "./project/copy"
+import { Pty } from "./pty"
+import { QuestionV2 } from "./question"
+import { Reference } from "./reference"
+import { EventManifest } from "./event-manifest"
+
+export const FoundationDefinitions = Event.inventory(
+  ModelsDev.Event.Refreshed,
+  Integration.Event.Updated,
+  Integration.Event.ConnectionUpdated,
+  Catalog.Event.Updated,
+  ...EventManifest.Definitions,
+)
+
+export const FeatureDefinitions = Event.inventory(
+  FileSystem.Event.Edited,
+  Reference.Event.Updated,
+  PermissionV2.Event.Asked,
+  PermissionV2.Event.Replied,
+  PluginV2.Event.Added,
+  ProjectCopy.Event.Updated,
+  Watcher.Event.Updated,
+  Pty.Event.Created,
+  Pty.Event.Updated,
+  Pty.Event.Exited,
+  Pty.Event.Deleted,
+  QuestionV2.Event.Asked,
+  QuestionV2.Event.Replied,
+  QuestionV2.Event.Rejected,
+  Todo.Event.Updated,
+)
+
+export const Definitions = Event.inventory(...FoundationDefinitions, ...FeatureDefinitions)
+
+export const Latest = Event.latest(Definitions)
+export const Durable = Event.durable(Definitions)

packages/core/src/session/event.ts

@@ -1,468 +1,2 @@
-import { Schema } from "effect"
-import { ProviderMetadata, ToolContent } from "@opencode-ai/schema/llm"
-import { Delivery } from "@opencode-ai/schema/session-delivery"
-import { EventV2 } from "../event"
-import { ModelV2 } from "../model"
-import { DateTimeUtcFromMillis, NonNegativeInt, RelativePath } from "../schema"
-import { FileAttachment, Prompt } from "./prompt"
-import { SessionSchema } from "./schema"
-import { Location } from "../location"
-import { SessionMessageID } from "./message-id"
-import { SessionMessage } from "./message"
-
-export { FileAttachment }
-
-export const Source = Schema.Struct({
-  start: NonNegativeInt,
-  end: NonNegativeInt,
-  text: Schema.String,
-}).annotate({
-  identifier: "session.next.event.source",
-})
-export type Source = typeof Source.Type
-
-const Base = {
-  timestamp: DateTimeUtcFromMillis,
-  sessionID: SessionSchema.ID,
-}
-const PromptFields = {
-  ...Base,
-  messageID: SessionMessageID.ID,
-  prompt: Prompt,
-  delivery: Delivery,
-}
-
-const options = {
-  durable: {
-    aggregate: "sessionID",
-    version: 1,
-  },
-} as const
-const stepSettlementOptions = {
-  durable: {
-    aggregate: "sessionID",
-    version: 2,
-  },
-} as const
-
-export const UnknownError = SessionMessage.UnknownError
-export type UnknownError = SessionMessage.UnknownError
-
-export const AgentSwitched = EventV2.define({
-  type: "session.next.agent.switched",
-  ...options,
-  schema: {
-    ...Base,
-    messageID: SessionMessageID.ID,
-    agent: Schema.String,
-  },
-})
-export type AgentSwitched = typeof AgentSwitched.Type
-
-export const ModelSwitched = EventV2.define({
-  type: "session.next.model.switched",
-  ...options,
-  schema: {
-    ...Base,
-    messageID: SessionMessageID.ID,
-    model: ModelV2.Ref,
-  },
-})
-export type ModelSwitched = typeof ModelSwitched.Type
-
-export const Moved = EventV2.define({
-  type: "session.next.moved",
-  ...options,
-  schema: {
-    ...Base,
-    location: Location.Ref,
-    subdirectory: RelativePath.pipe(Schema.optional),
-  },
-})
-export type Moved = typeof Moved.Type
-
-export const Prompted = EventV2.define({
-  type: "session.next.prompted",
-  ...options,
-  schema: PromptFields,
-})
-export type Prompted = typeof Prompted.Type
-
-export const PromptAdmitted = EventV2.define({
-  type: "session.next.prompt.admitted",
-  ...options,
-  schema: PromptFields,
-})
-export type PromptAdmitted = typeof PromptAdmitted.Type
-
-export const ContextUpdated = EventV2.define({
-  type: "session.next.context.updated",
-  ...options,
-  schema: {
-    ...Base,
-    messageID: SessionMessageID.ID,
-    text: Schema.String,
-  },
-})
-export type ContextUpdated = typeof ContextUpdated.Type
-
-export const Synthetic = EventV2.define({
-  type: "session.next.synthetic",
-  ...options,
-  schema: {
-    ...Base,
-    messageID: SessionMessageID.ID,
-    text: Schema.String,
-  },
-})
-export type Synthetic = typeof Synthetic.Type
-
-export namespace Shell {
-  export const Started = EventV2.define({
-    type: "session.next.shell.started",
-    ...options,
-    schema: {
-      ...Base,
-      messageID: SessionMessageID.ID,
-      callID: Schema.String,
-      command: Schema.String,
-    },
-  })
-  export type Started = typeof Started.Type
-
-  export const Ended = EventV2.define({
-    type: "session.next.shell.ended",
-    ...options,
-    schema: {
-      ...Base,
-      callID: Schema.String,
-      output: Schema.String,
-    },
-  })
-  export type Ended = typeof Ended.Type
-}
-
-export namespace Step {
-  export const Started = EventV2.define({
-    type: "session.next.step.started",
-    ...options,
-    schema: {
-      ...Base,
-      assistantMessageID: SessionMessageID.ID,
-      agent: Schema.String,
-      model: ModelV2.Ref,
-      snapshot: Schema.String.pipe(Schema.optional),
-    },
-  })
-  export type Started = typeof Started.Type
-
-  export const Ended = EventV2.define({
-    type: "session.next.step.ended",
-    ...stepSettlementOptions,
-    schema: {
-      ...Base,
-      assistantMessageID: SessionMessageID.ID,
-      finish: Schema.String,
-      cost: Schema.Finite,
-      tokens: Schema.Struct({
-        input: Schema.Finite,
-        output: Schema.Finite,
-        reasoning: Schema.Finite,
-        cache: Schema.Struct({
-          read: Schema.Finite,
-          write: Schema.Finite,
-        }),
-      }),
-      snapshot: Schema.String.pipe(Schema.optional),
-    },
-  })
-  export type Ended = typeof Ended.Type
-
-  export const Failed = EventV2.define({
-    type: "session.next.step.failed",
-    ...stepSettlementOptions,
-    schema: {
-      ...Base,
-      assistantMessageID: SessionMessageID.ID,
-      error: UnknownError,
-    },
-  })
-  export type Failed = typeof Failed.Type
-}
-
-export namespace Text {
-  export const Started = EventV2.define({
-    type: "session.next.text.started",
-    ...options,
-    schema: {
-      ...Base,
-      assistantMessageID: SessionMessageID.ID,
-      textID: Schema.String,
-    },
-  })
-  export type Started = typeof Started.Type
-
-  // Stream fragments are live-only; Text.Ended is the replayable full-value boundary.
-  export const Delta = EventV2.define({
-    type: "session.next.text.delta",
-    schema: {
-      ...Base,
-      assistantMessageID: SessionMessageID.ID,
-      textID: Schema.String,
-      delta: Schema.String,
-    },
-  })
-  export type Delta = typeof Delta.Type
-
-  export const Ended = EventV2.define({
-    type: "session.next.text.ended",
-    ...options,
-    schema: {
-      ...Base,
-      assistantMessageID: SessionMessageID.ID,
-      textID: Schema.String,
-      text: Schema.String,
-    },
-  })
-  export type Ended = typeof Ended.Type
-}
-
-export namespace Reasoning {
-  export const Started = EventV2.define({
-    type: "session.next.reasoning.started",
-    ...options,
-    schema: {
-      ...Base,
-      assistantMessageID: SessionMessageID.ID,
-      reasoningID: Schema.String,
-      providerMetadata: ProviderMetadata.pipe(Schema.optional),
-    },
-  })
-  export type Started = typeof Started.Type
-
-  // Stream fragments are live-only; Reasoning.Ended is the replayable full-value boundary.
-  export const Delta = EventV2.define({
-    type: "session.next.reasoning.delta",
-    schema: {
-      ...Base,
-      assistantMessageID: SessionMessageID.ID,
-      reasoningID: Schema.String,
-      delta: Schema.String,
-    },
-  })
-  export type Delta = typeof Delta.Type
-
-  export const Ended = EventV2.define({
-    type: "session.next.reasoning.ended",
-    ...options,
-    schema: {
-      ...Base,
-      assistantMessageID: SessionMessageID.ID,
-      reasoningID: Schema.String,
-      text: Schema.String,
-      providerMetadata: ProviderMetadata.pipe(Schema.optional),
-    },
-  })
-  export type Ended = typeof Ended.Type
-}
-
-export namespace Tool {
-  const ToolBase = {
-    ...Base,
-    assistantMessageID: SessionMessageID.ID,
-    callID: Schema.String,
-  }
-
-  export namespace Input {
-    export const Started = EventV2.define({
-      type: "session.next.tool.input.started",
-      ...options,
-      schema: {
-        ...ToolBase,
-        name: Schema.String,
-      },
-    })
-    export type Started = typeof Started.Type
-
-    // Stream fragments are live-only; Input.Ended is the replayable raw-input boundary.
-    export const Delta = EventV2.define({
-      type: "session.next.tool.input.delta",
-      schema: {
-        ...ToolBase,
-        delta: Schema.String,
-      },
-    })
-    export type Delta = typeof Delta.Type
-
-    export const Ended = EventV2.define({
-      type: "session.next.tool.input.ended",
-      ...options,
-      schema: {
-        ...ToolBase,
-        text: Schema.String,
-      },
-    })
-    export type Ended = typeof Ended.Type
-  }
-
-  export const Called = EventV2.define({
-    type: "session.next.tool.called",
-    ...options,
-    schema: {
-      ...ToolBase,
-      tool: Schema.String,
-      input: Schema.Record(Schema.String, Schema.Unknown),
-      provider: Schema.Struct({
-        executed: Schema.Boolean,
-        metadata: ProviderMetadata.pipe(Schema.optional),
-      }),
-    },
-  })
-  export type Called = typeof Called.Type
-
-  /**
-   * Replayable bounded running-tool state. Tools should checkpoint semantic
-   * transitions or at a bounded cadence, not persist every stdout/stderr chunk.
-   */
-  export const Progress = EventV2.define({
-    type: "session.next.tool.progress",
-    ...options,
-    schema: {
-      ...ToolBase,
-      structured: Schema.Record(Schema.String, Schema.Any),
-      content: Schema.Array(ToolContent),
-    },
-  })
-  export type Progress = typeof Progress.Type
-
-  export const Success = EventV2.define({
-    type: "session.next.tool.success",
-    ...options,
-    schema: {
-      ...ToolBase,
-      structured: Schema.Record(Schema.String, Schema.Any),
-      content: Schema.Array(ToolContent),
-      outputPaths: Schema.Array(Schema.String).pipe(Schema.optional),
-      result: Schema.Unknown.pipe(Schema.optional),
-      provider: Schema.Struct({
-        executed: Schema.Boolean,
-        metadata: ProviderMetadata.pipe(Schema.optional),
-      }),
-    },
-  })
-  export type Success = typeof Success.Type
-
-  export const Failed = EventV2.define({
-    type: "session.next.tool.failed",
-    ...options,
-    schema: {
-      ...ToolBase,
-      error: UnknownError,
-      result: Schema.Unknown.pipe(Schema.optional),
-      provider: Schema.Struct({
-        executed: Schema.Boolean,
-        metadata: ProviderMetadata.pipe(Schema.optional),
-      }),
-    },
-  })
-  export type Failed = typeof Failed.Type
-}
-
-export const RetryError = Schema.Struct({
-  message: Schema.String,
-  statusCode: Schema.Finite.pipe(Schema.optional),
-  isRetryable: Schema.Boolean,
-  responseHeaders: Schema.Record(Schema.String, Schema.String).pipe(Schema.optional),
-  responseBody: Schema.String.pipe(Schema.optional),
-  metadata: Schema.Record(Schema.String, Schema.String).pipe(Schema.optional),
-}).annotate({
-  identifier: "session.next.retry_error",
-})
-export type RetryError = typeof RetryError.Type
-
-export const Retried = EventV2.define({
-  type: "session.next.retried",
-  ...options,
-  schema: {
-    ...Base,
-    attempt: Schema.Finite,
-    error: RetryError,
-  },
-})
-export type Retried = typeof Retried.Type
-
-export namespace Compaction {
-  export const Started = EventV2.define({
-    type: "session.next.compaction.started",
-    ...options,
-    schema: {
-      ...Base,
-      messageID: SessionMessageID.ID,
-      reason: Schema.Union([Schema.Literal("auto"), Schema.Literal("manual")]),
-    },
-  })
-  export type Started = typeof Started.Type
-
-  export const Delta = EventV2.define({
-    type: "session.next.compaction.delta",
-    schema: {
-      ...Base,
-      messageID: SessionMessageID.ID,
-      text: Schema.String,
-    },
-  })
-  export type Delta = typeof Delta.Type
-
-  export const Ended = EventV2.define({
-    type: "session.next.compaction.ended",
-    ...options,
-    schema: {
-      ...Base,
-      messageID: SessionMessageID.ID,
-      reason: Started.data.fields.reason,
-      text: Schema.String,
-      recent: Schema.String,
-    },
-  })
-  export type Ended = typeof Ended.Type
-}
-
-const DurableDefinitions = [
-  AgentSwitched,
-  ModelSwitched,
-  Moved,
-  Prompted,
-  PromptAdmitted,
-  ContextUpdated,
-  Synthetic,
-  Shell.Started,
-  Shell.Ended,
-  Step.Started,
-  Step.Ended,
-  Step.Failed,
-  Text.Started,
-  Text.Ended,
-  Tool.Input.Started,
-  Tool.Input.Ended,
-  Tool.Called,
-  Tool.Progress,
-  Tool.Success,
-  Tool.Failed,
-  Reasoning.Started,
-  Reasoning.Ended,
-  Retried,
-  Compaction.Started,
-  Compaction.Ended,
-] as const
-const EphemeralDefinitions = [Text.Delta, Tool.Input.Delta, Reasoning.Delta, Compaction.Delta] as const
-
-export const Durable = Schema.Union(DurableDefinitions, { mode: "oneOf" }).pipe(Schema.toTaggedUnion("type"))
-export type DurableEvent = typeof Durable.Type
-
-export const All = Schema.Union([...DurableDefinitions, ...EphemeralDefinitions], { mode: "oneOf" }).pipe(
-  Schema.toTaggedUnion("type"),
-)
-export type Event = typeof All.Type
-export type Type = Event["type"]
-
-export * as SessionEvent from "./event"
+export * from "@opencode-ai/schema/session-event"
+export { SessionEvent } from "@opencode-ai/schema/session-event"

packages/core/src/session/todo.ts

@@ -1,30 +1,16 @@
 export * as SessionTodo from "./todo"
 
 import { asc, eq } from "drizzle-orm"
-import { Context, Effect, Layer, Schema } from "effect"
+import { Context, Effect, Layer } from "effect"
+import { Todo } from "@opencode-ai/schema/todo"
 import { Database } from "../database/database"
 import { EventV2 } from "../event"
 import { SessionSchema } from "./schema"
 import { TodoTable } from "./sql"
 
-export const Info = Schema.Struct({
-  content: Schema.String.annotate({ description: "Brief description of the task" }),
-  status: Schema.String.annotate({
-    description: "Current status of the task: pending, in_progress, completed, cancelled",
-  }),
-  priority: Schema.String.annotate({ description: "Priority level of the task: high, medium, low" }),
-}).annotate({ identifier: "SessionTodo.Info" })
-export type Info = typeof Info.Type
-
-export const Event = {
-  Updated: EventV2.define({
-    type: "todo.updated",
-    schema: {
-      sessionID: SessionSchema.ID,
-      todos: Schema.Array(Info),
-    },
-  }),
-}
+export const Info = Todo.Info
+export type Info = Todo.Info
+export const Event = Todo.Event
 
 export interface Interface {
   readonly update: (input: {

packages/core/src/v1/permission.ts

@@ -1,96 +1,2 @@
-export * as PermissionV1 from "./permission"
-
-import { Schema } from "effect"
-import { ProjectV2 } from "../project"
-import { withStatics } from "../schema"
-import { SessionSchema } from "../session/schema"
-import { Identifier } from "../util/identifier"
-
-export const ID = Schema.String.check(Schema.isStartsWith("per")).pipe(
-  Schema.brand("PermissionID"),
-  withStatics((schema) => ({ ascending: (id?: string) => schema.make(id ?? "per_" + Identifier.ascending()) })),
-)
-export type ID = typeof ID.Type
-
-export const Action = Schema.Literals(["allow", "deny", "ask"]).annotate({ identifier: "PermissionAction" })
-export type Action = typeof Action.Type
-
-export const Rule = Schema.Struct({
-  permission: Schema.String,
-  pattern: Schema.String,
-  action: Action,
-}).annotate({ identifier: "PermissionRule" })
-export type Rule = typeof Rule.Type
-
-export const Ruleset = Schema.Array(Rule).annotate({ identifier: "PermissionRuleset" })
-export type Ruleset = typeof Ruleset.Type
-
-export const Request = Schema.Struct({
-  id: ID,
-  sessionID: SessionSchema.ID,
-  permission: Schema.String,
-  patterns: Schema.Array(Schema.String),
-  metadata: Schema.Record(Schema.String, Schema.Unknown),
-  always: Schema.Array(Schema.String),
-  tool: Schema.Struct({
-    messageID: Schema.String,
-    callID: Schema.String,
-  }).pipe(Schema.optional),
-}).annotate({ identifier: "PermissionRequest" })
-export type Request = typeof Request.Type
-
-export const Reply = Schema.Literals(["once", "always", "reject"])
-export type Reply = typeof Reply.Type
-
-export const ReplyBody = Schema.Struct({
-  reply: Reply,
-  message: Schema.String.pipe(Schema.optional),
-}).annotate({ identifier: "PermissionReplyBody" })
-export type ReplyBody = typeof ReplyBody.Type
-
-export const Approval = Schema.Struct({
-  projectID: ProjectV2.ID,
-  patterns: Schema.Array(Schema.String),
-}).annotate({ identifier: "PermissionApproval" })
-export type Approval = typeof Approval.Type
-
-export const AskInput = Schema.Struct({
-  ...Request.fields,
-  id: ID.pipe(Schema.optional),
-  ruleset: Ruleset,
-}).annotate({ identifier: "PermissionAskInput" })
-export type AskInput = typeof AskInput.Type
-
-export const ReplyInput = Schema.Struct({
-  requestID: ID,
-  ...ReplyBody.fields,
-}).annotate({ identifier: "PermissionReplyInput" })
-export type ReplyInput = typeof ReplyInput.Type
-
-export class RejectedError extends Schema.TaggedErrorClass<RejectedError>()("PermissionRejectedError", {}) {
-  override get message() {
-    return "The user rejected permission to use this specific tool call."
-  }
-}
-
-export class CorrectedError extends Schema.TaggedErrorClass<CorrectedError>()("PermissionCorrectedError", {
-  feedback: Schema.String,
-}) {
-  override get message() {
-    return `The user rejected permission to use this specific tool call with the following feedback: ${this.feedback}`
-  }
-}
-
-export class DeniedError extends Schema.TaggedErrorClass<DeniedError>()("PermissionDeniedError", {
-  ruleset: Schema.Any,
-}) {
-  override get message() {
-    return `The user has specified a rule which prevents you from using this specific tool call. Here are some of the relevant rules ${JSON.stringify(this.ruleset)}`
-  }
-}
-
-export class NotFoundError extends Schema.TaggedErrorClass<NotFoundError>()("Permission.NotFoundError", {
-  requestID: ID,
-}) {}
-
-export type Error = DeniedError | RejectedError | CorrectedError
+export * from "@opencode-ai/schema/permission-v1"
+export { PermissionV1 } from "@opencode-ai/schema/permission-v1"

packages/core/src/v1/session.ts

@@ -1,632 +1,2 @@
-export * as SessionV1 from "./session"
-
-import { Effect, Schema, Types } from "effect"
-import { EventV2 } from "../event"
-import { PermissionV1 } from "./permission"
-import { ProjectV2 } from "../project"
-import { ProviderV2 } from "../provider"
-import { ModelV2 } from "../model"
-import { optionalOmitUndefined, withStatics } from "../schema"
-import { Identifier } from "../util/identifier"
-import { NonNegativeInt } from "../schema"
-import { NamedError } from "../util/error"
-import { SessionSchema } from "../session/schema"
-import { WorkspaceV2 } from "../workspace"
-
-const Timestamp = Schema.Finite.check(Schema.isGreaterThanOrEqualTo(0))
-
-export const MessageID = Schema.String.check(Schema.isStartsWith("msg")).pipe(
-  Schema.brand("MessageID"),
-  withStatics((schema) => ({ ascending: (id?: string) => schema.make(id ?? "msg_" + Identifier.ascending()) })),
-)
-export type MessageID = typeof MessageID.Type
-
-export const PartID = Schema.String.check(Schema.isStartsWith("prt")).pipe(
-  Schema.brand("PartID"),
-  withStatics((schema) => ({ ascending: (id?: string) => schema.make(id ?? "prt_" + Identifier.ascending()) })),
-)
-export type PartID = typeof PartID.Type
-
-export const OutputLengthError = NamedError.create("MessageOutputLengthError", {})
-
-export const AuthError = NamedError.create("ProviderAuthError", {
-  providerID: Schema.String,
-  message: Schema.String,
-})
-
-export const AbortedError = NamedError.create("MessageAbortedError", { message: Schema.String })
-export const StructuredOutputError = NamedError.create("StructuredOutputError", {
-  message: Schema.String,
-  retries: NonNegativeInt,
-})
-export const APIError = NamedError.create("APIError", {
-  message: Schema.String,
-  statusCode: Schema.optional(NonNegativeInt),
-  isRetryable: Schema.Boolean,
-  responseHeaders: Schema.optional(Schema.Record(Schema.String, Schema.String)),
-  responseBody: Schema.optional(Schema.String),
-  metadata: Schema.optional(Schema.Record(Schema.String, Schema.String)),
-})
-export type APIError = Schema.Schema.Type<typeof APIError.Schema>
-export const ContextOverflowError = NamedError.create("ContextOverflowError", {
-  message: Schema.String,
-  responseBody: Schema.optional(Schema.String),
-})
-export const ContentFilterError = NamedError.create("ContentFilterError", {
-  message: Schema.String,
-})
-
-export class OutputFormatText extends Schema.Class<OutputFormatText>("OutputFormatText")({
-  type: Schema.Literal("text"),
-}) {}
-
-export class OutputFormatJsonSchema extends Schema.Class<OutputFormatJsonSchema>("OutputFormatJsonSchema")({
-  type: Schema.Literal("json_schema"),
-  schema: Schema.Record(Schema.String, Schema.Any).annotate({ identifier: "JSONSchema" }),
-  retryCount: NonNegativeInt.pipe(Schema.optional, Schema.withDecodingDefault(Effect.succeed(2))),
-}) {}
-
-export const Format = Schema.Union([OutputFormatText, OutputFormatJsonSchema]).annotate({
-  discriminator: "type",
-  identifier: "OutputFormat",
-})
-export type OutputFormat = Schema.Schema.Type<typeof Format>
-
-const partBase = {
-  id: PartID,
-  sessionID: SessionSchema.ID,
-  messageID: MessageID,
-}
-
-export const SnapshotPart = Schema.Struct({
-  ...partBase,
-  type: Schema.Literal("snapshot"),
-  snapshot: Schema.String,
-}).annotate({ identifier: "SnapshotPart" })
-export type SnapshotPart = Types.DeepMutable<Schema.Schema.Type<typeof SnapshotPart>>
-
-export const PatchPart = Schema.Struct({
-  ...partBase,
-  type: Schema.Literal("patch"),
-  hash: Schema.String,
-  files: Schema.Array(Schema.String),
-}).annotate({ identifier: "PatchPart" })
-export type PatchPart = Types.DeepMutable<Schema.Schema.Type<typeof PatchPart>>
-
-export const TextPart = Schema.Struct({
-  ...partBase,
-  type: Schema.Literal("text"),
-  text: Schema.String,
-  synthetic: Schema.optional(Schema.Boolean),
-  ignored: Schema.optional(Schema.Boolean),
-  time: Schema.optional(
-    Schema.Struct({
-      start: NonNegativeInt,
-      end: Schema.optional(NonNegativeInt),
-    }),
-  ),
-  metadata: Schema.optional(Schema.Record(Schema.String, Schema.Any)),
-}).annotate({ identifier: "TextPart" })
-export type TextPart = Types.DeepMutable<Schema.Schema.Type<typeof TextPart>>
-
-export const ReasoningPart = Schema.Struct({
-  ...partBase,
-  type: Schema.Literal("reasoning"),
-  text: Schema.String,
-  metadata: Schema.optional(Schema.Record(Schema.String, Schema.Any)),
-  time: Schema.Struct({
-    start: NonNegativeInt,
-    end: Schema.optional(NonNegativeInt),
-  }),
-}).annotate({ identifier: "ReasoningPart" })
-export type ReasoningPart = Types.DeepMutable<Schema.Schema.Type<typeof ReasoningPart>>
-
-const filePartSourceBase = {
-  text: Schema.Struct({
-    value: Schema.String,
-    start: Schema.Finite,
-    end: Schema.Finite,
-  }).annotate({ identifier: "FilePartSourceText" }),
-}
-
-export const Range = Schema.Struct({
-  start: Schema.Struct({ line: NonNegativeInt, character: NonNegativeInt }),
-  end: Schema.Struct({ line: NonNegativeInt, character: NonNegativeInt }),
-}).annotate({ identifier: "Range" })
-export type Range = typeof Range.Type
-
-export const FileSource = Schema.Struct({
-  ...filePartSourceBase,
-  type: Schema.Literal("file"),
-  path: Schema.String,
-}).annotate({ identifier: "FileSource" })
-
-export const SymbolSource = Schema.Struct({
-  ...filePartSourceBase,
-  type: Schema.Literal("symbol"),
-  path: Schema.String,
-  range: Range,
-  name: Schema.String,
-  kind: NonNegativeInt,
-}).annotate({ identifier: "SymbolSource" })
-
-export const ResourceSource = Schema.Struct({
-  ...filePartSourceBase,
-  type: Schema.Literal("resource"),
-  clientName: Schema.String,
-  uri: Schema.String,
-}).annotate({ identifier: "ResourceSource" })
-
-export const FilePartSource = Schema.Union([FileSource, SymbolSource, ResourceSource]).annotate({
-  discriminator: "type",
-  identifier: "FilePartSource",
-})
-
-export const FilePart = Schema.Struct({
-  ...partBase,
-  type: Schema.Literal("file"),
-  mime: Schema.String,
-  filename: Schema.optional(Schema.String),
-  url: Schema.String,
-  source: Schema.optional(FilePartSource),
-}).annotate({ identifier: "FilePart" })
-export type FilePart = Types.DeepMutable<Schema.Schema.Type<typeof FilePart>>
-
-export const AgentPart = Schema.Struct({
-  ...partBase,
-  type: Schema.Literal("agent"),
-  name: Schema.String,
-  source: Schema.optional(
-    Schema.Struct({
-      value: Schema.String,
-      start: NonNegativeInt,
-      end: NonNegativeInt,
-    }),
-  ),
-}).annotate({ identifier: "AgentPart" })
-export type AgentPart = Types.DeepMutable<Schema.Schema.Type<typeof AgentPart>>
-
-export const CompactionPart = Schema.Struct({
-  ...partBase,
-  type: Schema.Literal("compaction"),
-  auto: Schema.Boolean,
-  overflow: Schema.optional(Schema.Boolean),
-  tail_start_id: Schema.optional(MessageID),
-}).annotate({ identifier: "CompactionPart" })
-export type CompactionPart = Types.DeepMutable<Schema.Schema.Type<typeof CompactionPart>>
-
-export const SubtaskPart = Schema.Struct({
-  ...partBase,
-  type: Schema.Literal("subtask"),
-  prompt: Schema.String,
-  description: Schema.String,
-  agent: Schema.String,
-  model: Schema.optional(
-    Schema.Struct({
-      providerID: ProviderV2.ID,
-      modelID: ModelV2.ID,
-    }),
-  ),
-  command: Schema.optional(Schema.String),
-}).annotate({ identifier: "SubtaskPart" })
-export type SubtaskPart = Types.DeepMutable<Schema.Schema.Type<typeof SubtaskPart>>
-
-export const RetryPart = Schema.Struct({
-  ...partBase,
-  type: Schema.Literal("retry"),
-  attempt: NonNegativeInt,
-  error: APIError.EffectSchema,
-  time: Schema.Struct({
-    created: NonNegativeInt,
-  }),
-}).annotate({ identifier: "RetryPart" })
-export type RetryPart = Omit<Types.DeepMutable<Schema.Schema.Type<typeof RetryPart>>, "error"> & {
-  error: APIError
-}
-
-export const StepStartPart = Schema.Struct({
-  ...partBase,
-  type: Schema.Literal("step-start"),
-  snapshot: Schema.optional(Schema.String),
-}).annotate({ identifier: "StepStartPart" })
-export type StepStartPart = Types.DeepMutable<Schema.Schema.Type<typeof StepStartPart>>
-
-export const StepFinishPart = Schema.Struct({
-  ...partBase,
-  type: Schema.Literal("step-finish"),
-  reason: Schema.String,
-  snapshot: Schema.optional(Schema.String),
-  cost: Schema.Finite,
-  tokens: Schema.Struct({
-    total: Schema.optional(Schema.Finite),
-    input: Schema.Finite,
-    output: Schema.Finite,
-    reasoning: Schema.Finite,
-    cache: Schema.Struct({
-      read: Schema.Finite,
-      write: Schema.Finite,
-    }),
-  }),
-}).annotate({ identifier: "StepFinishPart" })
-export type StepFinishPart = Types.DeepMutable<Schema.Schema.Type<typeof StepFinishPart>>
-
-export const ToolStatePending = Schema.Struct({
-  status: Schema.Literal("pending"),
-  input: Schema.Record(Schema.String, Schema.Any),
-  raw: Schema.String,
-}).annotate({ identifier: "ToolStatePending" })
-export type ToolStatePending = Types.DeepMutable<Schema.Schema.Type<typeof ToolStatePending>>
-
-export const ToolStateRunning = Schema.Struct({
-  status: Schema.Literal("running"),
-  input: Schema.Record(Schema.String, Schema.Any),
-  title: Schema.optional(Schema.String),
-  metadata: Schema.optional(Schema.Record(Schema.String, Schema.Any)),
-  time: Schema.Struct({
-    start: NonNegativeInt,
-  }),
-}).annotate({ identifier: "ToolStateRunning" })
-export type ToolStateRunning = Types.DeepMutable<Schema.Schema.Type<typeof ToolStateRunning>>
-
-export const ToolStateCompleted = Schema.Struct({
-  status: Schema.Literal("completed"),
-  input: Schema.Record(Schema.String, Schema.Any),
-  output: Schema.String,
-  title: Schema.String,
-  metadata: Schema.Record(Schema.String, Schema.Any),
-  time: Schema.Struct({
-    start: NonNegativeInt,
-    end: NonNegativeInt,
-    compacted: Schema.optional(NonNegativeInt),
-  }),
-  attachments: Schema.optional(Schema.Array(FilePart)),
-}).annotate({ identifier: "ToolStateCompleted" })
-export type ToolStateCompleted = Types.DeepMutable<Schema.Schema.Type<typeof ToolStateCompleted>>
-
-export const ToolStateError = Schema.Struct({
-  status: Schema.Literal("error"),
-  input: Schema.Record(Schema.String, Schema.Any),
-  error: Schema.String,
-  metadata: Schema.optional(Schema.Record(Schema.String, Schema.Any)),
-  time: Schema.Struct({
-    start: NonNegativeInt,
-    end: NonNegativeInt,
-  }),
-}).annotate({ identifier: "ToolStateError" })
-export type ToolStateError = Types.DeepMutable<Schema.Schema.Type<typeof ToolStateError>>
-
-export const ToolState = Schema.Union([
-  ToolStatePending,
-  ToolStateRunning,
-  ToolStateCompleted,
-  ToolStateError,
-]).annotate({
-  discriminator: "status",
-  identifier: "ToolState",
-})
-export type ToolState = ToolStatePending | ToolStateRunning | ToolStateCompleted | ToolStateError
-
-export const ToolPart = Schema.Struct({
-  ...partBase,
-  type: Schema.Literal("tool"),
-  callID: Schema.String,
-  tool: Schema.String,
-  state: ToolState,
-  metadata: Schema.optional(Schema.Record(Schema.String, Schema.Any)),
-}).annotate({ identifier: "ToolPart" })
-export type ToolPart = Omit<Types.DeepMutable<Schema.Schema.Type<typeof ToolPart>>, "state"> & {
-  state: ToolState
-}
-
-const messageBase = {
-  id: MessageID,
-  sessionID: partBase.sessionID,
-}
-
-const FileDiff = Schema.Struct({
-  file: Schema.optional(Schema.String),
-  patch: Schema.optional(Schema.String),
-  additions: Schema.Finite,
-  deletions: Schema.Finite,
-  status: Schema.optional(Schema.Literals(["added", "deleted", "modified"])),
-}).annotate({ identifier: "SnapshotFileDiff" })
-
-export const User = Schema.Struct({
-  ...messageBase,
-  role: Schema.Literal("user"),
-  time: Schema.Struct({
-    created: Timestamp,
-  }),
-  format: Schema.optional(Format),
-  summary: Schema.optional(
-    Schema.Struct({
-      title: Schema.optional(Schema.String),
-      body: Schema.optional(Schema.String),
-      diffs: Schema.Array(FileDiff),
-    }),
-  ),
-  agent: Schema.String,
-  model: Schema.Struct({
-    providerID: ProviderV2.ID,
-    modelID: ModelV2.ID,
-    variant: Schema.optional(Schema.String),
-  }),
-  system: Schema.optional(Schema.String),
-  tools: Schema.optional(Schema.Record(Schema.String, Schema.Boolean)),
-}).annotate({ identifier: "UserMessage" })
-export type User = Types.DeepMutable<Schema.Schema.Type<typeof User>>
-
-export const Part = Schema.Union([
-  TextPart,
-  SubtaskPart,
-  ReasoningPart,
-  FilePart,
-  ToolPart,
-  StepStartPart,
-  StepFinishPart,
-  SnapshotPart,
-  PatchPart,
-  AgentPart,
-  RetryPart,
-  CompactionPart,
-]).annotate({ discriminator: "type", identifier: "Part" })
-export type Part =
-  | TextPart
-  | SubtaskPart
-  | ReasoningPart
-  | FilePart
-  | ToolPart
-  | StepStartPart
-  | StepFinishPart
-  | SnapshotPart
-  | PatchPart
-  | AgentPart
-  | RetryPart
-  | CompactionPart
-
-const AssistantErrorSchema = Schema.Union([
-  AuthError.EffectSchema,
-  NamedError.Unknown.EffectSchema,
-  OutputLengthError.EffectSchema,
-  AbortedError.EffectSchema,
-  StructuredOutputError.EffectSchema,
-  ContextOverflowError.EffectSchema,
-  ContentFilterError.EffectSchema,
-  APIError.EffectSchema,
-]).annotate({ discriminator: "name" })
-type AssistantError = Schema.Schema.Type<typeof AssistantErrorSchema>
-
-export const TextPartInput = Schema.Struct({
-  id: Schema.optional(PartID),
-  type: Schema.Literal("text"),
-  text: Schema.String,
-  synthetic: Schema.optional(Schema.Boolean),
-  ignored: Schema.optional(Schema.Boolean),
-  time: Schema.optional(
-    Schema.Struct({
-      start: NonNegativeInt,
-      end: Schema.optional(NonNegativeInt),
-    }),
-  ),
-  metadata: Schema.optional(Schema.Record(Schema.String, Schema.Any)),
-}).annotate({ identifier: "TextPartInput" })
-export type TextPartInput = Types.DeepMutable<Schema.Schema.Type<typeof TextPartInput>>
-
-export const FilePartInput = Schema.Struct({
-  id: Schema.optional(PartID),
-  type: Schema.Literal("file"),
-  mime: Schema.String,
-  filename: Schema.optional(Schema.String),
-  url: Schema.String,
-  source: Schema.optional(FilePartSource),
-}).annotate({ identifier: "FilePartInput" })
-export type FilePartInput = Types.DeepMutable<Schema.Schema.Type<typeof FilePartInput>>
-
-export const AgentPartInput = Schema.Struct({
-  id: Schema.optional(PartID),
-  type: Schema.Literal("agent"),
-  name: Schema.String,
-  source: Schema.optional(
-    Schema.Struct({
-      value: Schema.String,
-      start: NonNegativeInt,
-      end: NonNegativeInt,
-    }),
-  ),
-}).annotate({ identifier: "AgentPartInput" })
-export type AgentPartInput = Types.DeepMutable<Schema.Schema.Type<typeof AgentPartInput>>
-
-export const SubtaskPartInput = Schema.Struct({
-  id: Schema.optional(PartID),
-  type: Schema.Literal("subtask"),
-  prompt: Schema.String,
-  description: Schema.String,
-  agent: Schema.String,
-  model: Schema.optional(
-    Schema.Struct({
-      providerID: ProviderV2.ID,
-      modelID: ModelV2.ID,
-    }),
-  ),
-  command: Schema.optional(Schema.String),
-}).annotate({ identifier: "SubtaskPartInput" })
-export type SubtaskPartInput = Types.DeepMutable<Schema.Schema.Type<typeof SubtaskPartInput>>
-
-export const Assistant = Schema.Struct({
-  ...messageBase,
-  role: Schema.Literal("assistant"),
-  time: Schema.Struct({
-    created: NonNegativeInt,
-    completed: Schema.optional(NonNegativeInt),
-  }),
-  error: Schema.optional(AssistantErrorSchema),
-  parentID: MessageID,
-  modelID: ModelV2.ID,
-  providerID: ProviderV2.ID,
-  mode: Schema.String,
-  agent: Schema.String,
-  path: Schema.Struct({
-    cwd: Schema.String,
-    root: Schema.String,
-  }),
-  summary: Schema.optional(Schema.Boolean),
-  cost: Schema.Finite,
-  tokens: Schema.Struct({
-    total: Schema.optional(Schema.Finite),
-    input: Schema.Finite,
-    output: Schema.Finite,
-    reasoning: Schema.Finite,
-    cache: Schema.Struct({
-      read: Schema.Finite,
-      write: Schema.Finite,
-    }),
-  }),
-  structured: Schema.optional(Schema.Any),
-  variant: Schema.optional(Schema.String),
-  finish: Schema.optional(Schema.String),
-}).annotate({ identifier: "AssistantMessage" })
-export type Assistant = Omit<Types.DeepMutable<Schema.Schema.Type<typeof Assistant>>, "error"> & {
-  error?: AssistantError
-}
-
-export const Info = Schema.Union([User, Assistant]).annotate({ discriminator: "role", identifier: "Message" })
-export type Info = User | Assistant
-
-export const WithParts = Schema.Struct({
-  info: Info,
-  parts: Schema.Array(Part),
-})
-export type WithParts = {
-  info: Info
-  parts: Part[]
-}
-
-const options = {
-  durable: {
-    aggregate: "sessionID",
-    version: 1,
-  },
-} as const
-
-const SessionSummary = Schema.Struct({
-  additions: Schema.Finite,
-  deletions: Schema.Finite,
-  files: Schema.Finite,
-  diffs: optionalOmitUndefined(Schema.Array(FileDiff)),
-})
-
-const SessionTokens = Schema.Struct({
-  input: Schema.Finite,
-  output: Schema.Finite,
-  reasoning: Schema.Finite,
-  cache: Schema.Struct({
-    read: Schema.Finite,
-    write: Schema.Finite,
-  }),
-})
-
-const SessionShare = Schema.Struct({
-  url: Schema.String,
-})
-
-const SessionRevert = Schema.Struct({
-  messageID: MessageID,
-  partID: optionalOmitUndefined(PartID),
-  snapshot: optionalOmitUndefined(Schema.String),
-  diff: optionalOmitUndefined(Schema.String),
-})
-
-const SessionModel = Schema.Struct({
-  id: ModelV2.ID,
-  providerID: ProviderV2.ID,
-  variant: optionalOmitUndefined(Schema.String),
-})
-
-export const SessionInfo = Schema.Struct({
-  id: SessionSchema.ID,
-  slug: Schema.String,
-  projectID: ProjectV2.ID,
-  workspaceID: optionalOmitUndefined(WorkspaceV2.ID),
-  directory: Schema.String,
-  path: optionalOmitUndefined(Schema.String),
-  parentID: optionalOmitUndefined(SessionSchema.ID),
-  summary: optionalOmitUndefined(SessionSummary),
-  cost: optionalOmitUndefined(Schema.Finite),
-  tokens: optionalOmitUndefined(SessionTokens),
-  share: optionalOmitUndefined(SessionShare),
-  title: Schema.String,
-  agent: optionalOmitUndefined(Schema.String),
-  model: optionalOmitUndefined(SessionModel),
-  version: Schema.String,
-  metadata: optionalOmitUndefined(Schema.Record(Schema.String, Schema.Any)),
-  time: Schema.Struct({
-    created: NonNegativeInt,
-    updated: NonNegativeInt,
-    compacting: optionalOmitUndefined(NonNegativeInt),
-    archived: optionalOmitUndefined(Schema.Finite),
-  }),
-  permission: optionalOmitUndefined(PermissionV1.Ruleset),
-  revert: optionalOmitUndefined(SessionRevert),
-}).annotate({ identifier: "Session" })
-export type SessionInfo = typeof SessionInfo.Type
-
-export const Event = {
-  Created: EventV2.define({
-    type: "session.created",
-    ...options,
-    schema: {
-      sessionID: SessionSchema.ID,
-      info: SessionInfo,
-    },
-  }),
-  Updated: EventV2.define({
-    type: "session.updated",
-    ...options,
-    schema: {
-      sessionID: SessionSchema.ID,
-      info: SessionInfo,
-    },
-  }),
-  Deleted: EventV2.define({
-    type: "session.deleted",
-    ...options,
-    schema: {
-      sessionID: SessionSchema.ID,
-      info: SessionInfo,
-    },
-  }),
-  MessageUpdated: EventV2.define({
-    type: "message.updated",
-    ...options,
-    schema: {
-      sessionID: SessionSchema.ID,
-      info: Info,
-    },
-  }),
-  MessageRemoved: EventV2.define({
-    type: "message.removed",
-    ...options,
-    schema: {
-      sessionID: SessionSchema.ID,
-      messageID: MessageID,
-    },
-  }),
-  PartUpdated: EventV2.define({
-    type: "message.part.updated",
-    ...options,
-    schema: {
-      sessionID: SessionSchema.ID,
-      part: Part,
-      time: Schema.Finite,
-    },
-  }),
-  PartRemoved: EventV2.define({
-    type: "message.part.removed",
-    ...options,
-    schema: {
-      sessionID: SessionSchema.ID,
-      messageID: MessageID,
-      partID: PartID,
-    },
-  }),
-}
+export * from "@opencode-ai/schema/session-v1"
+export { SessionV1 } from "@opencode-ai/schema/session-v1"

packages/core/test/event.test.ts

@@ -1,6 +1,7 @@
 import { describe, expect } from "bun:test"
 import { Cause, DateTime, Deferred, Effect, Exit, Fiber, Layer, Schema, Stream } from "effect"
 import { EventV2 } from "@opencode-ai/core/event"
+import { Event } from "@opencode-ai/schema/event"
 import { Database } from "@opencode-ai/core/database/database"
 import { EventSequenceTable, EventTable } from "@opencode-ai/core/event/sql"
 import { Location } from "@opencode-ai/core/location"
@@ -16,10 +17,6 @@ const locationLayer = Layer.succeed(
     location({ directory: AbsolutePath.make("project"), workspaceID: WorkspaceV2.ID.make("wrk_test") }),
   ),
 )
-const eventLayer = Layer.mergeAll(EventV2.defaultLayer, Database.defaultLayer)
-const it = testEffect(eventLayer.pipe(Layer.provideMerge(locationLayer)))
-const itWithoutLocation = testEffect(eventLayer)
-
 const Message = EventV2.define({
   type: "test.message",
   schema: {
@@ -82,6 +79,15 @@ const SyncTimestamp = EventV2.define({
   },
 })
 
+const eventLayer = Layer.mergeAll(
+  EventV2.layerWith({
+    definitions: [Message, SyncMessage, SyncSent, GlobalMessage, VersionedMessage, SyncTimestamp],
+  }).pipe(Layer.provide(Database.defaultLayer)),
+  Database.defaultLayer,
+)
+const it = testEffect(eventLayer.pipe(Layer.provideMerge(locationLayer)))
+const itWithoutLocation = testEffect(eventLayer)
+
 describe("EventV2", () => {
   it.effect("publishes events with the current location", () =>
     Effect.gen(function* () {
@@ -122,26 +128,21 @@ describe("EventV2", () => {
     }),
   )
 
-  it.effect("stores definitions in the exported registry", () =>
-    Effect.sync(() => {
-      expect(EventV2.registry.get(Message.type)).toBe(Message)
-    }),
-  )
-
-  it.effect("keeps the latest sync definition in the registry", () =>
+  it.effect("selects the latest durable definition independent of declaration order", () =>
     Effect.sync(() => {
       const latest = EventV2.define({
         type: "test.out-of-order",
         durable: { version: 2, aggregate: "id" },
         schema: { id: Schema.String },
       })
-      EventV2.define({
+      const historical = EventV2.define({
         type: "test.out-of-order",
         durable: { version: 1, aggregate: "id" },
         schema: { id: Schema.String },
       })
 
-      expect(EventV2.registry.get("test.out-of-order")).toBe(latest)
+      expect(Event.latest([latest, historical]).get("test.out-of-order")).toBe(latest)
+      expect(Event.latest([historical, latest]).get("test.out-of-order")).toBe(latest)
     }),
   )
 
@@ -407,6 +408,7 @@ describe("EventV2", () => {
       const continueRead = yield* Deferred.make<void>()
       let pause = true
       const eventLayer = EventV2.layerWith({
+        definitions: [SyncMessage],
         beforeAggregateRead: () =>
           pause
             ? Deferred.succeed(readStarted, undefined).pipe(Effect.andThen(Deferred.await(continueRead)))

packages/opencode/package.json

@@ -34,6 +34,7 @@
     "@opencode-ai/core": "workspace:*",
     "@opencode-ai/http-recorder": "workspace:*",
     "@opencode-ai/script": "workspace:*",
+    "@opencode-ai/schema": "workspace:*",
     "@standard-schema/spec": "1.0.0",
     "@tsconfig/bun": "catalog:",
     "@types/babel__core": "7.20.5",

packages/opencode/src/event-manifest.ts

@@ -0,0 +1,60 @@
+export * as EventManifest from "./event-manifest"
+
+import { Event } from "@opencode-ai/schema/event"
+import { PublicEventManifest } from "@opencode-ai/core/public-event-manifest"
+import { Command } from "@/command"
+import { Workspace } from "@/control-plane/workspace"
+import { Ide } from "@/ide"
+import { Installation } from "@/installation"
+import { LSP } from "@/lsp/lsp"
+import { MCP } from "@/mcp"
+import { Permission } from "@/permission"
+import { Project } from "@/project/project"
+import { Vcs } from "@/project/vcs"
+import { Question } from "@/question"
+import { ServerEvent } from "@/server/event"
+import { TuiEvent } from "@/server/tui-event"
+import { MessageV2 } from "@/session/message-v2"
+import { Session } from "@/session/session"
+import { SessionCompaction } from "@/session/compaction"
+import { SessionStatus } from "@/session/status"
+import { Worktree } from "@/worktree"
+
+export const Definitions = Event.inventory(
+  ...PublicEventManifest.FoundationDefinitions,
+  MessageV2.Event.PartDelta,
+  Session.Event.Diff,
+  Session.Event.Error,
+  Installation.Event.Updated,
+  Installation.Event.UpdateAvailable,
+  ...PublicEventManifest.FeatureDefinitions,
+  LSP.Event.Updated,
+  Permission.Event.Asked,
+  Permission.Event.Replied,
+  TuiEvent.PromptAppend,
+  TuiEvent.CommandExecute,
+  TuiEvent.ToastShow,
+  TuiEvent.SessionSelect,
+  MCP.ToolsChanged,
+  MCP.BrowserOpenFailed,
+  Command.Event.Executed,
+  Project.Event.Updated,
+  SessionStatus.Event.Status,
+  SessionStatus.Event.Idle,
+  Question.Event.Asked,
+  Question.Event.Replied,
+  Question.Event.Rejected,
+  SessionCompaction.Event.Compacted,
+  Vcs.Event.BranchUpdated,
+  Workspace.Event.Ready,
+  Workspace.Event.Failed,
+  Workspace.Event.Status,
+  Worktree.Event.Ready,
+  Worktree.Event.Failed,
+  Ide.Event.Installed,
+  ServerEvent.Event.Connected,
+  ServerEvent.Event.Disposed,
+)
+
+export const Latest = Event.latest(Definitions)
+export const Durable = Event.durable(Definitions)

packages/opencode/src/event-v2-bridge.ts

@@ -7,9 +7,6 @@ import { EventV2 } from "@opencode-ai/core/event"
 import { Location } from "@opencode-ai/core/location"
 import { Project } from "@opencode-ai/core/project"
 import { AbsolutePath } from "@opencode-ai/core/schema"
-import "@opencode-ai/core/account"
-import "@opencode-ai/core/catalog"
-import "@opencode-ai/core/session/event"
 import { Context, Effect, Layer } from "effect"
 
 export class Service extends Context.Service<Service, EventV2.Interface>()("@opencode/EventV2Bridge") {}
@@ -45,10 +42,7 @@ export const layer = Layer.effect(
           workspace: workspaceID,
           payload: { id: event.id, type: event.type, properties: event.data },
         })
-        const durable = EventV2.registry.get(event.type)?.durable
-        if (durable === undefined || event.durable === undefined) return
-        const aggregateID = (event.data as Record<string, unknown>)[durable.aggregate]
-        if (typeof aggregateID !== "string") return
+        if (event.durable === undefined) return
         GlobalBus.emit("event", {
           directory: event.location?.directory ?? ctx?.directory,
           project: ctx?.project.id,
@@ -59,7 +53,7 @@ export const layer = Layer.effect(
               id: event.id,
               type: EventV2.versionedType(event.type, event.durable.version),
               seq: event.durable.seq,
-              aggregateID,
+              aggregateID: event.durable.aggregateID,
               data: event.data,
             },
           },

packages/opencode/src/server/event.ts

@@ -11,3 +11,5 @@ export const InstanceDisposed = Schema.Struct({
   type: Schema.Literal("server.instance.disposed"),
   properties: Schema.Struct({ directory: Schema.String }),
 }).annotate({ identifier: "Event.server.instance.disposed" })
+
+export * as ServerEvent from "./event"

packages/opencode/src/server/routes/instance/httpapi/api.ts

@@ -1,6 +1,7 @@
 import { Schema } from "effect"
 import { HttpApi } from "effect/unstable/httpapi"
 import { EventV2 } from "@opencode-ai/core/event"
+import { EventManifest } from "@/event-manifest"
 import { Credential } from "@opencode-ai/core/credential"
 import { Integration } from "@opencode-ai/core/integration"
 import { SkillV2 } from "@opencode-ai/core/skill"
@@ -24,15 +25,13 @@ import { SessionApi } from "./groups/session"
 import { SyncApi } from "./groups/sync"
 import { TuiApi } from "./groups/tui"
 import { WorkspaceApi } from "./groups/workspace"
-import { Api } from "@opencode-ai/server/api"
-// GlobalEventSchema snapshots the registry after event-producing groups register their variants.
+import { makeApi } from "@opencode-ai/server/api"
 import { GlobalApi } from "./groups/global"
 import { Authorization } from "./middleware/authorization"
 import { SchemaErrorMiddleware } from "./middleware/schema-error"
 
 const EventSchema = Schema.Union([
-  ...EventV2.registry
-    .values()
+  ...EventManifest.Latest.values()
     .map((definition) =>
       Schema.Struct({
         id: EventV2.ID,
@@ -44,6 +43,8 @@ const EventSchema = Schema.Union([
   InstanceDisposed,
 ]).annotate({ identifier: "Event" })
 
+export const ServerApi = makeApi(EventManifest.Latest.values().toArray())
+
 export const RootHttpApi = HttpApi.make("opencode-root")
   .addHttpApi(ControlApi)
   .addHttpApi(ControlPlaneApi)
@@ -73,7 +74,7 @@ export const OpenCodeHttpApi = HttpApi.make("opencode")
   .addHttpApi(RootHttpApi)
   .addHttpApi(EventApi)
   .addHttpApi(InstanceHttpApi)
-  .addHttpApi(Api)
+  .addHttpApi(ServerApi)
   .addHttpApi(PtyConnectApi)
   .annotate(HttpApi.AdditionalSchemas, [
     EventSchema,

packages/opencode/src/server/routes/instance/httpapi/groups/global.ts

@@ -1,6 +1,6 @@
-import { Config } from "@/config/config"
 import { ConfigV1 } from "@opencode-ai/core/v1/config/config"
 import { EventV2 } from "@opencode-ai/core/event"
+import { EventManifest } from "@/event-manifest"
 import { InstanceDisposed } from "@/server/event"
 import "@opencode-ai/core/account"
 import "@/server/event"
@@ -13,8 +13,7 @@ const GlobalHealth = Schema.Struct({
   version: Schema.String,
 })
 
-const SyncEventSchemas = EventV2.registry
-  .values()
+const SyncEventSchemas = EventManifest.Latest.values()
   .flatMap((definition) => {
     if (!definition.durable) return []
     return [
@@ -38,8 +37,7 @@ const GlobalEventSchema = Schema.Struct({
   project: Schema.optional(Schema.String),
   workspace: Schema.optional(Schema.String),
   payload: Schema.Union([
-    ...EventV2.registry
-      .values()
+    ...EventManifest.Latest.values()
       .map((definition) =>
         Schema.Struct({ id: EventV2.ID, type: Schema.Literal(definition.type), properties: definition.data }),
       )

packages/opencode/src/session/todo.ts

@@ -1,31 +1,16 @@
 import { LayerNode } from "@opencode-ai/core/effect/layer-node"
 import { SessionID } from "./schema"
-import { Effect, Layer, Context, Schema } from "effect"
+import { Effect, Layer, Context } from "effect"
+import { Todo as TodoSchema } from "@opencode-ai/schema/todo"
 import { Database } from "@opencode-ai/core/database/database"
 import { eq } from "drizzle-orm"
 import { asc } from "drizzle-orm"
 import { TodoTable } from "@opencode-ai/core/session/sql"
 import { EventV2Bridge } from "@/event-v2-bridge"
-import { EventV2 } from "@opencode-ai/core/event"
 
-export const Info = Schema.Struct({
-  content: Schema.String.annotate({ description: "Brief description of the task" }),
-  status: Schema.String.annotate({
-    description: "Current status of the task: pending, in_progress, completed, cancelled",
-  }),
-  priority: Schema.String.annotate({ description: "Priority level of the task: high, medium, low" }),
-}).annotate({ identifier: "Todo" })
-export type Info = Schema.Schema.Type<typeof Info>
-
-export const Event = {
-  Updated: EventV2.define({
-    type: "todo.updated",
-    schema: {
-      sessionID: SessionID,
-      todos: Schema.Array(Info),
-    },
-  }),
-}
+export const Info = TodoSchema.Info
+export type Info = TodoSchema.Info
+export const Event = TodoSchema.Event
 
 export interface Interface {
   readonly update: (input: { sessionID: SessionID; todos: Info[] }) => Effect.Effect<void>

packages/opencode/test/event-manifest.test.ts

@@ -0,0 +1,20 @@
+import { describe, expect, test } from "bun:test"
+import { SessionEvent } from "@opencode-ai/schema/session-event"
+import { EventManifest } from "@/event-manifest"
+
+describe("public event manifest", () => {
+  test("contains every latest public wire type once", () => {
+    expect(EventManifest.Latest.size).toBe(86)
+    expect(EventManifest.Latest.get("session.next.step.ended")).toBe(SessionEvent.Step.Ended)
+    expect(EventManifest.Latest.has("ide.installed")).toBe(true)
+    expect(EventManifest.Latest.has("server.connected")).toBe(true)
+    expect(EventManifest.Latest.has("global.disposed")).toBe(true)
+  })
+
+  test("keeps historical durable versions out of the latest manifest", () => {
+    expect(EventManifest.Latest.values().toArray()).not.toContain(SessionEvent.Step.EndedV1)
+    expect(EventManifest.Latest.values().toArray()).not.toContain(SessionEvent.Step.FailedV1)
+    expect(EventManifest.Durable.get("session.next.step.ended.1")).toBe(SessionEvent.Step.EndedV1)
+    expect(EventManifest.Durable.get("session.next.step.ended.2")).toBe(SessionEvent.Step.Ended)
+  })
+})

packages/schema/src/event.ts

@@ -0,0 +1,125 @@
+export * as Event from "./event"
+
+import { Schema } from "effect"
+import { ascending } from "./identifier"
+import { Location } from "./location"
+import { withStatics } from "./schema"
+
+export const ID = Schema.String.check(Schema.isStartsWith("evt_")).pipe(
+  Schema.brand("Event.ID"),
+  withStatics((schema) => ({ create: () => schema.make("evt_" + ascending()) })),
+)
+export type ID = typeof ID.Type
+
+export type Definition<
+  Type extends string = string,
+  DataSchema extends Schema.Codec<unknown, unknown> = Schema.Codec<unknown, unknown>,
+> = Schema.Top & {
+  readonly type: Type
+  readonly durable?: {
+    readonly version: number
+    readonly aggregate: string
+  }
+  readonly data: DataSchema
+}
+
+export type Data<D extends Definition> = Schema.Schema.Type<D["data"]>
+
+export type Payload<D extends Definition = Definition> = {
+  readonly id: ID
+  readonly type: D["type"]
+  readonly data: Data<D>
+  readonly durable?: {
+    readonly aggregateID: string
+    readonly seq: number
+    readonly version: number
+  }
+  readonly location?: Location.Ref
+  readonly metadata?: Record<string, unknown>
+}
+
+export function define<
+  const Type extends string,
+  Fields extends Readonly<Record<PropertyKey, Schema.Codec<unknown, unknown>>>,
+>(input: {
+  readonly type: Type
+  readonly durable?: {
+    readonly version: number
+    readonly aggregate: string
+  }
+  readonly schema: Fields
+}): Schema.Schema<Payload<Definition<Type, Schema.Struct<Fields>>>> & Definition<Type, Schema.Struct<Fields>> {
+  const data = Schema.Struct(input.schema)
+  return Object.assign(
+    Schema.Struct({
+      id: ID,
+      metadata: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
+      type: Schema.Literal(input.type),
+      durable: Schema.optional(
+        Schema.Struct({ aggregateID: Schema.String, seq: Schema.Number, version: Schema.Number }),
+      ),
+      location: Schema.optional(Location.Ref),
+      data,
+    }).annotate({ identifier: input.type }),
+    {
+      type: input.type,
+      ...(input.durable === undefined ? {} : { durable: input.durable }),
+      data,
+    },
+  ) as Schema.Schema<Payload<Definition<Type, Schema.Struct<Fields>>>> & Definition<Type, Schema.Struct<Fields>>
+}
+
+export function inventory<const Definitions extends ReadonlyArray<Definition>>(...definitions: Definitions) {
+  return Object.freeze(definitions)
+}
+
+export function latest(definitions: ReadonlyArray<Definition>) {
+  return readonlyMap(
+    definitions.reduce((result, definition) => {
+      const existing = result.get(definition.type)
+      if (!existing) {
+        result.set(definition.type, definition)
+        return result
+      }
+      if (definition.durable && existing.durable && definition.durable.version !== existing.durable.version) {
+        if (definition.durable.version > existing.durable.version) result.set(definition.type, definition)
+        return result
+      }
+      if (definition !== existing) throw new Error(`Duplicate latest event definition for ${definition.type}`)
+      return result
+    }, new Map<string, Definition>()),
+  )
+}
+
+export function versionedType(type: string, version: number) {
+  return `${type}.${version}`
+}
+
+export function durable(definitions: ReadonlyArray<Definition>) {
+  return readonlyMap(
+    definitions.reduce((result, definition) => {
+      if (!definition.durable) return result
+      const key = versionedType(definition.type, definition.durable.version)
+      if (result.has(key)) throw new Error(`Duplicate durable event definition for ${key}`)
+      result.set(key, definition)
+      return result
+    }, new Map<string, Definition>()),
+  )
+}
+
+function readonlyMap<Key, Value>(map: Map<Key, Value>): ReadonlyMap<Key, Value> {
+  const result: ReadonlyMap<Key, Value> = Object.freeze({
+    get size() {
+      return map.size
+    },
+    entries: () => map.entries(),
+    forEach: (callback: (value: Value, key: Key, map: ReadonlyMap<Key, Value>) => void, thisArg?: unknown) =>
+      map.forEach((value, key) => callback.call(thisArg, value, key, result)),
+    get: (key: Key) => map.get(key),
+    has: (key: Key) => map.has(key),
+    keys: () => map.keys(),
+    values: () => map.values(),
+    [Symbol.iterator]: () => map[Symbol.iterator](),
+  })
+  return result
+}

packages/schema/src/index.ts

@@ -2,6 +2,7 @@ export { Agent } from "./agent"
 export { Command } from "./command"
 export { Connection } from "./connection"
 export { Credential } from "./credential"
+export { Event } from "./event"
 export { FileSystem } from "./filesystem"
 export { Integration } from "./integration"
 export { LLM } from "./llm"
@@ -9,13 +10,16 @@ export { Location } from "./location"
 export { Model } from "./model"
 export { ModelRequest } from "./model-request"
 export { Permission } from "./permission"
+export { PermissionV1 } from "./permission-v1"
 export { Project } from "./project"
 export { Provider } from "./provider"
 export { Reference } from "./reference"
 export { Session } from "./session"
+export { SessionV1 } from "./session-v1"
 export { SessionInput } from "./session-input"
 export { SessionMessage } from "./session-message"
 export { Skill } from "./skill"
+export { Todo } from "./todo"
 export { Workspace } from "./workspace"
 export { Prompt, Source, FileAttachment, AgentAttachment } from "./prompt"
 export * from "./schema"

packages/schema/src/named-error.ts

@@ -0,0 +1,62 @@
+import { Schema } from "effect"
+
+export abstract class NamedError extends Error {
+  abstract schema(): Schema.Top
+  abstract toObject(): { name: string; data: unknown }
+
+  static hasName(error: unknown, name: string): boolean {
+    return (
+      typeof error === "object" && error !== null && "name" in error && (error as Record<string, unknown>).name === name
+    )
+  }
+
+  static create<Name extends string, Fields extends Schema.Struct.Fields>(
+    name: Name,
+    fields: Fields,
+  ): ReturnType<typeof NamedError.createSchemaClass<Name, Schema.Struct<Fields>>>
+  static create<Name extends string, DataSchema extends Schema.Top>(
+    name: Name,
+    data: DataSchema,
+  ): ReturnType<typeof NamedError.createSchemaClass<Name, DataSchema>>
+  static create<Name extends string>(name: Name, data: Schema.Top | Schema.Struct.Fields) {
+    return NamedError.createSchemaClass(name, Schema.isSchema(data) ? data : Schema.Struct(data))
+  }
+
+  private static createSchemaClass<Name extends string, DataSchema extends Schema.Top>(name: Name, data: DataSchema) {
+    const schema = Schema.Struct({ name: Schema.Literal(name), data }).annotate({ identifier: name })
+    type Data = Schema.Schema.Type<DataSchema>
+    const result = class extends NamedError {
+      public static readonly Schema = schema
+      public static readonly EffectSchema = schema
+      public static readonly tag = name
+      public override readonly name = name
+
+      constructor(
+        public readonly data: Data,
+        options?: ErrorOptions,
+      ) {
+        super(name, options)
+        this.name = name
+      }
+
+      static isInstance(input: unknown): input is InstanceType<typeof result> {
+        return NamedError.hasName(input, name)
+      }
+
+      schema() {
+        return schema
+      }
+
+      toObject() {
+        return { name, data: this.data }
+      }
+    }
+    Object.defineProperty(result, "name", { value: name })
+    return result
+  }
+
+  public static readonly Unknown = NamedError.create("UnknownError", {
+    message: Schema.String,
+    ref: Schema.optional(Schema.String),
+  })
+}

packages/schema/src/permission-v1.ts

@@ -0,0 +1,96 @@
+export * as PermissionV1 from "./permission-v1"
+
+import { Schema } from "effect"
+import { Project } from "./project"
+import { withStatics } from "./schema"
+import { SessionID } from "./session-id"
+import { ascending } from "./identifier"
+
+export const ID = Schema.String.check(Schema.isStartsWith("per")).pipe(
+  Schema.brand("PermissionID"),
+  withStatics((schema) => ({ ascending: (id?: string) => schema.make(id ?? "per_" + ascending()) })),
+)
+export type ID = typeof ID.Type
+
+export const Action = Schema.Literals(["allow", "deny", "ask"]).annotate({ identifier: "PermissionAction" })
+export type Action = typeof Action.Type
+
+export const Rule = Schema.Struct({
+  permission: Schema.String,
+  pattern: Schema.String,
+  action: Action,
+}).annotate({ identifier: "PermissionRule" })
+export type Rule = typeof Rule.Type
+
+export const Ruleset = Schema.Array(Rule).annotate({ identifier: "PermissionRuleset" })
+export type Ruleset = typeof Ruleset.Type
+
+export const Request = Schema.Struct({
+  id: ID,
+  sessionID: SessionID.ID,
+  permission: Schema.String,
+  patterns: Schema.Array(Schema.String),
+  metadata: Schema.Record(Schema.String, Schema.Unknown),
+  always: Schema.Array(Schema.String),
+  tool: Schema.Struct({
+    messageID: Schema.String,
+    callID: Schema.String,
+  }).pipe(Schema.optional),
+}).annotate({ identifier: "PermissionRequest" })
+export type Request = typeof Request.Type
+
+export const Reply = Schema.Literals(["once", "always", "reject"])
+export type Reply = typeof Reply.Type
+
+export const ReplyBody = Schema.Struct({
+  reply: Reply,
+  message: Schema.String.pipe(Schema.optional),
+}).annotate({ identifier: "PermissionReplyBody" })
+export type ReplyBody = typeof ReplyBody.Type
+
+export const Approval = Schema.Struct({
+  projectID: Project.ID,
+  patterns: Schema.Array(Schema.String),
+}).annotate({ identifier: "PermissionApproval" })
+export type Approval = typeof Approval.Type
+
+export const AskInput = Schema.Struct({
+  ...Request.fields,
+  id: ID.pipe(Schema.optional),
+  ruleset: Ruleset,
+}).annotate({ identifier: "PermissionAskInput" })
+export type AskInput = typeof AskInput.Type
+
+export const ReplyInput = Schema.Struct({
+  requestID: ID,
+  ...ReplyBody.fields,
+}).annotate({ identifier: "PermissionReplyInput" })
+export type ReplyInput = typeof ReplyInput.Type
+
+export class RejectedError extends Schema.TaggedErrorClass<RejectedError>()("PermissionRejectedError", {}) {
+  override get message() {
+    return "The user rejected permission to use this specific tool call."
+  }
+}
+
+export class CorrectedError extends Schema.TaggedErrorClass<CorrectedError>()("PermissionCorrectedError", {
+  feedback: Schema.String,
+}) {
+  override get message() {
+    return `The user rejected permission to use this specific tool call with the following feedback: ${this.feedback}`
+  }
+}
+
+export class DeniedError extends Schema.TaggedErrorClass<DeniedError>()("PermissionDeniedError", {
+  ruleset: Schema.Any,
+}) {
+  override get message() {
+    return `The user has specified a rule which prevents you from using this specific tool call. Here are some of the relevant rules ${JSON.stringify(this.ruleset)}`
+  }
+}
+
+export class NotFoundError extends Schema.TaggedErrorClass<NotFoundError>()("Permission.NotFoundError", {
+  requestID: ID,
+}) {}
+
+export type Error = DeniedError | RejectedError | CorrectedError

packages/schema/src/session-event.ts

@@ -0,0 +1,529 @@
+import { Schema } from "effect"
+import { Event } from "./event"
+import { ProviderMetadata, ToolContent } from "./llm"
+import { Delivery } from "./session-delivery"
+import { Model } from "./model"
+import { DateTimeUtcFromMillis, NonNegativeInt, RelativePath } from "./schema"
+import { FileAttachment, Prompt } from "./prompt"
+import { SessionID } from "./session-id"
+import { Location } from "./location"
+import { SessionMessageID } from "./session-message-id"
+import { SessionMessage } from "./session-message"
+
+export { FileAttachment }
+
+export const Source = Schema.Struct({
+  start: NonNegativeInt,
+  end: NonNegativeInt,
+  text: Schema.String,
+}).annotate({
+  identifier: "session.next.event.source",
+})
+export type Source = typeof Source.Type
+
+const Base = {
+  timestamp: DateTimeUtcFromMillis,
+  sessionID: SessionID.ID,
+}
+const PromptFields = {
+  ...Base,
+  messageID: SessionMessageID.ID,
+  prompt: Prompt,
+  delivery: Delivery,
+}
+
+const options = {
+  durable: {
+    aggregate: "sessionID",
+    version: 1,
+  },
+} as const
+const stepSettlementOptions = {
+  durable: {
+    aggregate: "sessionID",
+    version: 2,
+  },
+} as const
+
+export const UnknownError = SessionMessage.UnknownError
+export type UnknownError = SessionMessage.UnknownError
+
+export const AgentSwitched = Event.define({
+  type: "session.next.agent.switched",
+  ...options,
+  schema: {
+    ...Base,
+    messageID: SessionMessageID.ID,
+    agent: Schema.String,
+  },
+})
+export type AgentSwitched = typeof AgentSwitched.Type
+
+export const ModelSwitched = Event.define({
+  type: "session.next.model.switched",
+  ...options,
+  schema: {
+    ...Base,
+    messageID: SessionMessageID.ID,
+    model: Model.Ref,
+  },
+})
+export type ModelSwitched = typeof ModelSwitched.Type
+
+export const Moved = Event.define({
+  type: "session.next.moved",
+  ...options,
+  schema: {
+    ...Base,
+    location: Location.Ref,
+    subdirectory: RelativePath.pipe(Schema.optional),
+  },
+})
+export type Moved = typeof Moved.Type
+
+export const Prompted = Event.define({
+  type: "session.next.prompted",
+  ...options,
+  schema: PromptFields,
+})
+export type Prompted = typeof Prompted.Type
+
+export const PromptAdmitted = Event.define({
+  type: "session.next.prompt.admitted",
+  ...options,
+  schema: PromptFields,
+})
+export type PromptAdmitted = typeof PromptAdmitted.Type
+
+export const ContextUpdated = Event.define({
+  type: "session.next.context.updated",
+  ...options,
+  schema: {
+    ...Base,
+    messageID: SessionMessageID.ID,
+    text: Schema.String,
+  },
+})
+export type ContextUpdated = typeof ContextUpdated.Type
+
+export const Synthetic = Event.define({
+  type: "session.next.synthetic",
+  ...options,
+  schema: {
+    ...Base,
+    messageID: SessionMessageID.ID,
+    text: Schema.String,
+  },
+})
+export type Synthetic = typeof Synthetic.Type
+
+export namespace Shell {
+  export const Started = Event.define({
+    type: "session.next.shell.started",
+    ...options,
+    schema: {
+      ...Base,
+      messageID: SessionMessageID.ID,
+      callID: Schema.String,
+      command: Schema.String,
+    },
+  })
+  export type Started = typeof Started.Type
+
+  export const Ended = Event.define({
+    type: "session.next.shell.ended",
+    ...options,
+    schema: {
+      ...Base,
+      callID: Schema.String,
+      output: Schema.String,
+    },
+  })
+  export type Ended = typeof Ended.Type
+}
+
+export namespace Step {
+  export const Started = Event.define({
+    type: "session.next.step.started",
+    ...options,
+    schema: {
+      ...Base,
+      assistantMessageID: SessionMessageID.ID,
+      agent: Schema.String,
+      model: Model.Ref,
+      snapshot: Schema.String.pipe(Schema.optional),
+    },
+  })
+  export type Started = typeof Started.Type
+
+  export const EndedV1 = Event.define({
+    type: "session.next.step.ended",
+    ...options,
+    schema: {
+      ...Base,
+      finish: Schema.String,
+      cost: Schema.Finite,
+      tokens: Schema.Struct({
+        input: Schema.Finite,
+        output: Schema.Finite,
+        reasoning: Schema.Finite,
+        cache: Schema.Struct({
+          read: Schema.Finite,
+          write: Schema.Finite,
+        }),
+      }),
+      snapshot: Schema.String.pipe(Schema.optional),
+    },
+  })
+  export type EndedV1 = typeof EndedV1.Type
+
+  export const Ended = Event.define({
+    type: "session.next.step.ended",
+    ...stepSettlementOptions,
+    schema: {
+      ...Base,
+      assistantMessageID: SessionMessageID.ID,
+      finish: Schema.String,
+      cost: Schema.Finite,
+      tokens: Schema.Struct({
+        input: Schema.Finite,
+        output: Schema.Finite,
+        reasoning: Schema.Finite,
+        cache: Schema.Struct({
+          read: Schema.Finite,
+          write: Schema.Finite,
+        }),
+      }),
+      snapshot: Schema.String.pipe(Schema.optional),
+    },
+  })
+  export type Ended = typeof Ended.Type
+
+  export const FailedV1 = Event.define({
+    type: "session.next.step.failed",
+    ...options,
+    schema: {
+      ...Base,
+      error: UnknownError,
+    },
+  })
+  export type FailedV1 = typeof FailedV1.Type
+
+  export const Failed = Event.define({
+    type: "session.next.step.failed",
+    ...stepSettlementOptions,
+    schema: {
+      ...Base,
+      assistantMessageID: SessionMessageID.ID,
+      error: UnknownError,
+    },
+  })
+  export type Failed = typeof Failed.Type
+}
+
+export namespace Text {
+  export const Started = Event.define({
+    type: "session.next.text.started",
+    ...options,
+    schema: {
+      ...Base,
+      assistantMessageID: SessionMessageID.ID,
+      textID: Schema.String,
+    },
+  })
+  export type Started = typeof Started.Type
+
+  // Stream fragments are live-only; Text.Ended is the replayable full-value boundary.
+  export const Delta = Event.define({
+    type: "session.next.text.delta",
+    schema: {
+      ...Base,
+      assistantMessageID: SessionMessageID.ID,
+      textID: Schema.String,
+      delta: Schema.String,
+    },
+  })
+  export type Delta = typeof Delta.Type
+
+  export const Ended = Event.define({
+    type: "session.next.text.ended",
+    ...options,
+    schema: {
+      ...Base,
+      assistantMessageID: SessionMessageID.ID,
+      textID: Schema.String,
+      text: Schema.String,
+    },
+  })
+  export type Ended = typeof Ended.Type
+}
+
+export namespace Reasoning {
+  export const Started = Event.define({
+    type: "session.next.reasoning.started",
+    ...options,
+    schema: {
+      ...Base,
+      assistantMessageID: SessionMessageID.ID,
+      reasoningID: Schema.String,
+      providerMetadata: ProviderMetadata.pipe(Schema.optional),
+    },
+  })
+  export type Started = typeof Started.Type
+
+  // Stream fragments are live-only; Reasoning.Ended is the replayable full-value boundary.
+  export const Delta = Event.define({
+    type: "session.next.reasoning.delta",
+    schema: {
+      ...Base,
+      assistantMessageID: SessionMessageID.ID,
+      reasoningID: Schema.String,
+      delta: Schema.String,
+    },
+  })
+  export type Delta = typeof Delta.Type
+
+  export const Ended = Event.define({
+    type: "session.next.reasoning.ended",
+    ...options,
+    schema: {
+      ...Base,
+      assistantMessageID: SessionMessageID.ID,
+      reasoningID: Schema.String,
+      text: Schema.String,
+      providerMetadata: ProviderMetadata.pipe(Schema.optional),
+    },
+  })
+  export type Ended = typeof Ended.Type
+}
+
+export namespace Tool {
+  const ToolBase = {
+    ...Base,
+    assistantMessageID: SessionMessageID.ID,
+    callID: Schema.String,
+  }
+
+  export namespace Input {
+    export const Started = Event.define({
+      type: "session.next.tool.input.started",
+      ...options,
+      schema: {
+        ...ToolBase,
+        name: Schema.String,
+      },
+    })
+    export type Started = typeof Started.Type
+
+    // Stream fragments are live-only; Input.Ended is the replayable raw-input boundary.
+    export const Delta = Event.define({
+      type: "session.next.tool.input.delta",
+      schema: {
+        ...ToolBase,
+        delta: Schema.String,
+      },
+    })
+    export type Delta = typeof Delta.Type
+
+    export const Ended = Event.define({
+      type: "session.next.tool.input.ended",
+      ...options,
+      schema: {
+        ...ToolBase,
+        text: Schema.String,
+      },
+    })
+    export type Ended = typeof Ended.Type
+  }
+
+  export const Called = Event.define({
+    type: "session.next.tool.called",
+    ...options,
+    schema: {
+      ...ToolBase,
+      tool: Schema.String,
+      input: Schema.Record(Schema.String, Schema.Unknown),
+      provider: Schema.Struct({
+        executed: Schema.Boolean,
+        metadata: ProviderMetadata.pipe(Schema.optional),
+      }),
+    },
+  })
+  export type Called = typeof Called.Type
+
+  /**
+   * Replayable bounded running-tool state. Tools should checkpoint semantic
+   * transitions or at a bounded cadence, not persist every stdout/stderr chunk.
+   */
+  export const Progress = Event.define({
+    type: "session.next.tool.progress",
+    ...options,
+    schema: {
+      ...ToolBase,
+      structured: Schema.Record(Schema.String, Schema.Any),
+      content: Schema.Array(ToolContent),
+    },
+  })
+  export type Progress = typeof Progress.Type
+
+  export const Success = Event.define({
+    type: "session.next.tool.success",
+    ...options,
+    schema: {
+      ...ToolBase,
+      structured: Schema.Record(Schema.String, Schema.Any),
+      content: Schema.Array(ToolContent),
+      outputPaths: Schema.Array(Schema.String).pipe(Schema.optional),
+      result: Schema.Unknown.pipe(Schema.optional),
+      provider: Schema.Struct({
+        executed: Schema.Boolean,
+        metadata: ProviderMetadata.pipe(Schema.optional),
+      }),
+    },
+  })
+  export type Success = typeof Success.Type
+
+  export const Failed = Event.define({
+    type: "session.next.tool.failed",
+    ...options,
+    schema: {
+      ...ToolBase,
+      error: UnknownError,
+      result: Schema.Unknown.pipe(Schema.optional),
+      provider: Schema.Struct({
+        executed: Schema.Boolean,
+        metadata: ProviderMetadata.pipe(Schema.optional),
+      }),
+    },
+  })
+  export type Failed = typeof Failed.Type
+}
+
+export const RetryError = Schema.Struct({
+  message: Schema.String,
+  statusCode: Schema.Finite.pipe(Schema.optional),
+  isRetryable: Schema.Boolean,
+  responseHeaders: Schema.Record(Schema.String, Schema.String).pipe(Schema.optional),
+  responseBody: Schema.String.pipe(Schema.optional),
+  metadata: Schema.Record(Schema.String, Schema.String).pipe(Schema.optional),
+}).annotate({
+  identifier: "session.next.retry_error",
+})
+export type RetryError = typeof RetryError.Type
+
+export const Retried = Event.define({
+  type: "session.next.retried",
+  ...options,
+  schema: {
+    ...Base,
+    attempt: Schema.Finite,
+    error: RetryError,
+  },
+})
+export type Retried = typeof Retried.Type
+
+export namespace Compaction {
+  export const Started = Event.define({
+    type: "session.next.compaction.started",
+    ...options,
+    schema: {
+      ...Base,
+      messageID: SessionMessageID.ID,
+      reason: Schema.Union([Schema.Literal("auto"), Schema.Literal("manual")]),
+    },
+  })
+  export type Started = typeof Started.Type
+
+  export const Delta = Event.define({
+    type: "session.next.compaction.delta",
+    schema: {
+      ...Base,
+      messageID: SessionMessageID.ID,
+      text: Schema.String,
+    },
+  })
+  export type Delta = typeof Delta.Type
+
+  export const Ended = Event.define({
+    type: "session.next.compaction.ended",
+    ...options,
+    schema: {
+      ...Base,
+      messageID: SessionMessageID.ID,
+      reason: Started.data.fields.reason,
+      text: Schema.String,
+      recent: Schema.String,
+    },
+  })
+  export type Ended = typeof Ended.Type
+}
+
+export const CurrentDefinitions = Event.inventory(
+  AgentSwitched,
+  ModelSwitched,
+  Moved,
+  Prompted,
+  PromptAdmitted,
+  ContextUpdated,
+  Synthetic,
+  Shell.Started,
+  Shell.Ended,
+  Step.Started,
+  Step.Ended,
+  Step.Failed,
+  Text.Started,
+  Text.Delta,
+  Text.Ended,
+  Reasoning.Started,
+  Reasoning.Delta,
+  Reasoning.Ended,
+  Tool.Input.Started,
+  Tool.Input.Delta,
+  Tool.Input.Ended,
+  Tool.Called,
+  Tool.Progress,
+  Tool.Success,
+  Tool.Failed,
+  Retried,
+  Compaction.Started,
+  Compaction.Delta,
+  Compaction.Ended,
+)
+export const DurableDefinitions = Event.inventory(
+  AgentSwitched,
+  ModelSwitched,
+  Moved,
+  Prompted,
+  PromptAdmitted,
+  ContextUpdated,
+  Synthetic,
+  Shell.Started,
+  Shell.Ended,
+  Step.Started,
+  Step.Ended,
+  Step.Failed,
+  Text.Started,
+  Text.Ended,
+  Tool.Input.Started,
+  Tool.Input.Ended,
+  Tool.Called,
+  Tool.Progress,
+  Tool.Success,
+  Tool.Failed,
+  Reasoning.Started,
+  Reasoning.Ended,
+  Retried,
+  Compaction.Started,
+  Compaction.Ended,
+)
+export const HistoricalDefinitions = Event.inventory(Step.EndedV1, Step.FailedV1)
+export const Definitions = Event.inventory(...CurrentDefinitions, ...HistoricalDefinitions)
+
+export const Durable = Schema.Union(DurableDefinitions, { mode: "oneOf" }).pipe(Schema.toTaggedUnion("type"))
+export type DurableEvent = typeof Durable.Type
+
+export const All = Schema.Union(CurrentDefinitions, { mode: "oneOf" }).pipe(Schema.toTaggedUnion("type"))
+export type Event = typeof All.Type
+export type Type = Event["type"]
+
+export * as SessionEvent from "./session-event"

packages/schema/src/session-v1.ts

@@ -0,0 +1,633 @@
+export * as SessionV1 from "./session-v1"
+
+import { Effect, Schema, Types } from "effect"
+import { define } from "./event"
+import { PermissionV1 } from "./permission-v1"
+import { Project } from "./project"
+import { Provider } from "./provider"
+import { Model } from "./model"
+import { NonNegativeInt, optionalOmitUndefined, withStatics } from "./schema"
+import { ascending } from "./identifier"
+import { NamedError } from "./named-error"
+import { SessionID } from "./session-id"
+import { Workspace } from "./workspace"
+
+const Timestamp = Schema.Finite.check(Schema.isGreaterThanOrEqualTo(0))
+
+export const MessageID = Schema.String.check(Schema.isStartsWith("msg")).pipe(
+  Schema.brand("MessageID"),
+  withStatics((schema) => ({ ascending: (id?: string) => schema.make(id ?? "msg_" + ascending()) })),
+)
+export type MessageID = typeof MessageID.Type
+
+export const PartID = Schema.String.check(Schema.isStartsWith("prt")).pipe(
+  Schema.brand("PartID"),
+  withStatics((schema) => ({ ascending: (id?: string) => schema.make(id ?? "prt_" + ascending()) })),
+)
+export type PartID = typeof PartID.Type
+
+export const OutputLengthError = NamedError.create("MessageOutputLengthError", {})
+
+export const AuthError = NamedError.create("ProviderAuthError", {
+  providerID: Schema.String,
+  message: Schema.String,
+})
+
+export const AbortedError = NamedError.create("MessageAbortedError", { message: Schema.String })
+export const StructuredOutputError = NamedError.create("StructuredOutputError", {
+  message: Schema.String,
+  retries: NonNegativeInt,
+})
+export const APIError = NamedError.create("APIError", {
+  message: Schema.String,
+  statusCode: Schema.optional(NonNegativeInt),
+  isRetryable: Schema.Boolean,
+  responseHeaders: Schema.optional(Schema.Record(Schema.String, Schema.String)),
+  responseBody: Schema.optional(Schema.String),
+  metadata: Schema.optional(Schema.Record(Schema.String, Schema.String)),
+})
+export type APIError = Schema.Schema.Type<typeof APIError.Schema>
+export const ContextOverflowError = NamedError.create("ContextOverflowError", {
+  message: Schema.String,
+  responseBody: Schema.optional(Schema.String),
+})
+export const ContentFilterError = NamedError.create("ContentFilterError", {
+  message: Schema.String,
+})
+
+export class OutputFormatText extends Schema.Class<OutputFormatText>("OutputFormatText")({
+  type: Schema.Literal("text"),
+}) {}
+
+export class OutputFormatJsonSchema extends Schema.Class<OutputFormatJsonSchema>("OutputFormatJsonSchema")({
+  type: Schema.Literal("json_schema"),
+  schema: Schema.Record(Schema.String, Schema.Any).annotate({ identifier: "JSONSchema" }),
+  retryCount: NonNegativeInt.pipe(Schema.optional, Schema.withDecodingDefault(Effect.succeed(2))),
+}) {}
+
+export const Format = Schema.Union([OutputFormatText, OutputFormatJsonSchema]).annotate({
+  discriminator: "type",
+  identifier: "OutputFormat",
+})
+export type OutputFormat = Schema.Schema.Type<typeof Format>
+
+const partBase = {
+  id: PartID,
+  sessionID: SessionID.ID,
+  messageID: MessageID,
+}
+
+export const SnapshotPart = Schema.Struct({
+  ...partBase,
+  type: Schema.Literal("snapshot"),
+  snapshot: Schema.String,
+}).annotate({ identifier: "SnapshotPart" })
+export type SnapshotPart = Types.DeepMutable<Schema.Schema.Type<typeof SnapshotPart>>
+
+export const PatchPart = Schema.Struct({
+  ...partBase,
+  type: Schema.Literal("patch"),
+  hash: Schema.String,
+  files: Schema.Array(Schema.String),
+}).annotate({ identifier: "PatchPart" })
+export type PatchPart = Types.DeepMutable<Schema.Schema.Type<typeof PatchPart>>
+
+export const TextPart = Schema.Struct({
+  ...partBase,
+  type: Schema.Literal("text"),
+  text: Schema.String,
+  synthetic: Schema.optional(Schema.Boolean),
+  ignored: Schema.optional(Schema.Boolean),
+  time: Schema.optional(
+    Schema.Struct({
+      start: NonNegativeInt,
+      end: Schema.optional(NonNegativeInt),
+    }),
+  ),
+  metadata: Schema.optional(Schema.Record(Schema.String, Schema.Any)),
+}).annotate({ identifier: "TextPart" })
+export type TextPart = Types.DeepMutable<Schema.Schema.Type<typeof TextPart>>
+
+export const ReasoningPart = Schema.Struct({
+  ...partBase,
+  type: Schema.Literal("reasoning"),
+  text: Schema.String,
+  metadata: Schema.optional(Schema.Record(Schema.String, Schema.Any)),
+  time: Schema.Struct({
+    start: NonNegativeInt,
+    end: Schema.optional(NonNegativeInt),
+  }),
+}).annotate({ identifier: "ReasoningPart" })
+export type ReasoningPart = Types.DeepMutable<Schema.Schema.Type<typeof ReasoningPart>>
+
+const filePartSourceBase = {
+  text: Schema.Struct({
+    value: Schema.String,
+    start: Schema.Finite,
+    end: Schema.Finite,
+  }).annotate({ identifier: "FilePartSourceText" }),
+}
+
+export const Range = Schema.Struct({
+  start: Schema.Struct({ line: NonNegativeInt, character: NonNegativeInt }),
+  end: Schema.Struct({ line: NonNegativeInt, character: NonNegativeInt }),
+}).annotate({ identifier: "Range" })
+export type Range = typeof Range.Type
+
+export const FileSource = Schema.Struct({
+  ...filePartSourceBase,
+  type: Schema.Literal("file"),
+  path: Schema.String,
+}).annotate({ identifier: "FileSource" })
+
+export const SymbolSource = Schema.Struct({
+  ...filePartSourceBase,
+  type: Schema.Literal("symbol"),
+  path: Schema.String,
+  range: Range,
+  name: Schema.String,
+  kind: NonNegativeInt,
+}).annotate({ identifier: "SymbolSource" })
+
+export const ResourceSource = Schema.Struct({
+  ...filePartSourceBase,
+  type: Schema.Literal("resource"),
+  clientName: Schema.String,
+  uri: Schema.String,
+}).annotate({ identifier: "ResourceSource" })
+
+export const FilePartSource = Schema.Union([FileSource, SymbolSource, ResourceSource]).annotate({
+  discriminator: "type",
+  identifier: "FilePartSource",
+})
+
+export const FilePart = Schema.Struct({
+  ...partBase,
+  type: Schema.Literal("file"),
+  mime: Schema.String,
+  filename: Schema.optional(Schema.String),
+  url: Schema.String,
+  source: Schema.optional(FilePartSource),
+}).annotate({ identifier: "FilePart" })
+export type FilePart = Types.DeepMutable<Schema.Schema.Type<typeof FilePart>>
+
+export const AgentPart = Schema.Struct({
+  ...partBase,
+  type: Schema.Literal("agent"),
+  name: Schema.String,
+  source: Schema.optional(
+    Schema.Struct({
+      value: Schema.String,
+      start: NonNegativeInt,
+      end: NonNegativeInt,
+    }),
+  ),
+}).annotate({ identifier: "AgentPart" })
+export type AgentPart = Types.DeepMutable<Schema.Schema.Type<typeof AgentPart>>
+
+export const CompactionPart = Schema.Struct({
+  ...partBase,
+  type: Schema.Literal("compaction"),
+  auto: Schema.Boolean,
+  overflow: Schema.optional(Schema.Boolean),
+  tail_start_id: Schema.optional(MessageID),
+}).annotate({ identifier: "CompactionPart" })
+export type CompactionPart = Types.DeepMutable<Schema.Schema.Type<typeof CompactionPart>>
+
+export const SubtaskPart = Schema.Struct({
+  ...partBase,
+  type: Schema.Literal("subtask"),
+  prompt: Schema.String,
+  description: Schema.String,
+  agent: Schema.String,
+  model: Schema.optional(
+    Schema.Struct({
+      providerID: Provider.ID,
+      modelID: Model.ID,
+    }),
+  ),
+  command: Schema.optional(Schema.String),
+}).annotate({ identifier: "SubtaskPart" })
+export type SubtaskPart = Types.DeepMutable<Schema.Schema.Type<typeof SubtaskPart>>
+
+export const RetryPart = Schema.Struct({
+  ...partBase,
+  type: Schema.Literal("retry"),
+  attempt: NonNegativeInt,
+  error: APIError.EffectSchema,
+  time: Schema.Struct({
+    created: NonNegativeInt,
+  }),
+}).annotate({ identifier: "RetryPart" })
+export type RetryPart = Omit<Types.DeepMutable<Schema.Schema.Type<typeof RetryPart>>, "error"> & {
+  error: APIError
+}
+
+export const StepStartPart = Schema.Struct({
+  ...partBase,
+  type: Schema.Literal("step-start"),
+  snapshot: Schema.optional(Schema.String),
+}).annotate({ identifier: "StepStartPart" })
+export type StepStartPart = Types.DeepMutable<Schema.Schema.Type<typeof StepStartPart>>
+
+export const StepFinishPart = Schema.Struct({
+  ...partBase,
+  type: Schema.Literal("step-finish"),
+  reason: Schema.String,
+  snapshot: Schema.optional(Schema.String),
+  cost: Schema.Finite,
+  tokens: Schema.Struct({
+    total: Schema.optional(Schema.Finite),
+    input: Schema.Finite,
+    output: Schema.Finite,
+    reasoning: Schema.Finite,
+    cache: Schema.Struct({
+      read: Schema.Finite,
+      write: Schema.Finite,
+    }),
+  }),
+}).annotate({ identifier: "StepFinishPart" })
+export type StepFinishPart = Types.DeepMutable<Schema.Schema.Type<typeof StepFinishPart>>
+
+export const ToolStatePending = Schema.Struct({
+  status: Schema.Literal("pending"),
+  input: Schema.Record(Schema.String, Schema.Any),
+  raw: Schema.String,
+}).annotate({ identifier: "ToolStatePending" })
+export type ToolStatePending = Types.DeepMutable<Schema.Schema.Type<typeof ToolStatePending>>
+
+export const ToolStateRunning = Schema.Struct({
+  status: Schema.Literal("running"),
+  input: Schema.Record(Schema.String, Schema.Any),
+  title: Schema.optional(Schema.String),
+  metadata: Schema.optional(Schema.Record(Schema.String, Schema.Any)),
+  time: Schema.Struct({
+    start: NonNegativeInt,
+  }),
+}).annotate({ identifier: "ToolStateRunning" })
+export type ToolStateRunning = Types.DeepMutable<Schema.Schema.Type<typeof ToolStateRunning>>
+
+export const ToolStateCompleted = Schema.Struct({
+  status: Schema.Literal("completed"),
+  input: Schema.Record(Schema.String, Schema.Any),
+  output: Schema.String,
+  title: Schema.String,
+  metadata: Schema.Record(Schema.String, Schema.Any),
+  time: Schema.Struct({
+    start: NonNegativeInt,
+    end: NonNegativeInt,
+    compacted: Schema.optional(NonNegativeInt),
+  }),
+  attachments: Schema.optional(Schema.Array(FilePart)),
+}).annotate({ identifier: "ToolStateCompleted" })
+export type ToolStateCompleted = Types.DeepMutable<Schema.Schema.Type<typeof ToolStateCompleted>>
+
+export const ToolStateError = Schema.Struct({
+  status: Schema.Literal("error"),
+  input: Schema.Record(Schema.String, Schema.Any),
+  error: Schema.String,
+  metadata: Schema.optional(Schema.Record(Schema.String, Schema.Any)),
+  time: Schema.Struct({
+    start: NonNegativeInt,
+    end: NonNegativeInt,
+  }),
+}).annotate({ identifier: "ToolStateError" })
+export type ToolStateError = Types.DeepMutable<Schema.Schema.Type<typeof ToolStateError>>
+
+export const ToolState = Schema.Union([
+  ToolStatePending,
+  ToolStateRunning,
+  ToolStateCompleted,
+  ToolStateError,
+]).annotate({
+  discriminator: "status",
+  identifier: "ToolState",
+})
+export type ToolState = ToolStatePending | ToolStateRunning | ToolStateCompleted | ToolStateError
+
+export const ToolPart = Schema.Struct({
+  ...partBase,
+  type: Schema.Literal("tool"),
+  callID: Schema.String,
+  tool: Schema.String,
+  state: ToolState,
+  metadata: Schema.optional(Schema.Record(Schema.String, Schema.Any)),
+}).annotate({ identifier: "ToolPart" })
+export type ToolPart = Omit<Types.DeepMutable<Schema.Schema.Type<typeof ToolPart>>, "state"> & {
+  state: ToolState
+}
+
+const messageBase = {
+  id: MessageID,
+  sessionID: partBase.sessionID,
+}
+
+const FileDiff = Schema.Struct({
+  file: Schema.optional(Schema.String),
+  patch: Schema.optional(Schema.String),
+  additions: Schema.Finite,
+  deletions: Schema.Finite,
+  status: Schema.optional(Schema.Literals(["added", "deleted", "modified"])),
+}).annotate({ identifier: "SnapshotFileDiff" })
+
+export const User = Schema.Struct({
+  ...messageBase,
+  role: Schema.Literal("user"),
+  time: Schema.Struct({
+    created: Timestamp,
+  }),
+  format: Schema.optional(Format),
+  summary: Schema.optional(
+    Schema.Struct({
+      title: Schema.optional(Schema.String),
+      body: Schema.optional(Schema.String),
+      diffs: Schema.Array(FileDiff),
+    }),
+  ),
+  agent: Schema.String,
+  model: Schema.Struct({
+    providerID: Provider.ID,
+    modelID: Model.ID,
+    variant: Schema.optional(Schema.String),
+  }),
+  system: Schema.optional(Schema.String),
+  tools: Schema.optional(Schema.Record(Schema.String, Schema.Boolean)),
+}).annotate({ identifier: "UserMessage" })
+export type User = Types.DeepMutable<Schema.Schema.Type<typeof User>>
+
+export const Part = Schema.Union([
+  TextPart,
+  SubtaskPart,
+  ReasoningPart,
+  FilePart,
+  ToolPart,
+  StepStartPart,
+  StepFinishPart,
+  SnapshotPart,
+  PatchPart,
+  AgentPart,
+  RetryPart,
+  CompactionPart,
+]).annotate({ discriminator: "type", identifier: "Part" })
+export type Part =
+  | TextPart
+  | SubtaskPart
+  | ReasoningPart
+  | FilePart
+  | ToolPart
+  | StepStartPart
+  | StepFinishPart
+  | SnapshotPart
+  | PatchPart
+  | AgentPart
+  | RetryPart
+  | CompactionPart
+
+const AssistantErrorSchema = Schema.Union([
+  AuthError.EffectSchema,
+  NamedError.Unknown.EffectSchema,
+  OutputLengthError.EffectSchema,
+  AbortedError.EffectSchema,
+  StructuredOutputError.EffectSchema,
+  ContextOverflowError.EffectSchema,
+  ContentFilterError.EffectSchema,
+  APIError.EffectSchema,
+]).annotate({ discriminator: "name" })
+type AssistantError = Schema.Schema.Type<typeof AssistantErrorSchema>
+
+export const TextPartInput = Schema.Struct({
+  id: Schema.optional(PartID),
+  type: Schema.Literal("text"),
+  text: Schema.String,
+  synthetic: Schema.optional(Schema.Boolean),
+  ignored: Schema.optional(Schema.Boolean),
+  time: Schema.optional(
+    Schema.Struct({
+      start: NonNegativeInt,
+      end: Schema.optional(NonNegativeInt),
+    }),
+  ),
+  metadata: Schema.optional(Schema.Record(Schema.String, Schema.Any)),
+}).annotate({ identifier: "TextPartInput" })
+export type TextPartInput = Types.DeepMutable<Schema.Schema.Type<typeof TextPartInput>>
+
+export const FilePartInput = Schema.Struct({
+  id: Schema.optional(PartID),
+  type: Schema.Literal("file"),
+  mime: Schema.String,
+  filename: Schema.optional(Schema.String),
+  url: Schema.String,
+  source: Schema.optional(FilePartSource),
+}).annotate({ identifier: "FilePartInput" })
+export type FilePartInput = Types.DeepMutable<Schema.Schema.Type<typeof FilePartInput>>
+
+export const AgentPartInput = Schema.Struct({
+  id: Schema.optional(PartID),
+  type: Schema.Literal("agent"),
+  name: Schema.String,
+  source: Schema.optional(
+    Schema.Struct({
+      value: Schema.String,
+      start: NonNegativeInt,
+      end: NonNegativeInt,
+    }),
+  ),
+}).annotate({ identifier: "AgentPartInput" })
+export type AgentPartInput = Types.DeepMutable<Schema.Schema.Type<typeof AgentPartInput>>
+
+export const SubtaskPartInput = Schema.Struct({
+  id: Schema.optional(PartID),
+  type: Schema.Literal("subtask"),
+  prompt: Schema.String,
+  description: Schema.String,
+  agent: Schema.String,
+  model: Schema.optional(
+    Schema.Struct({
+      providerID: Provider.ID,
+      modelID: Model.ID,
+    }),
+  ),
+  command: Schema.optional(Schema.String),
+}).annotate({ identifier: "SubtaskPartInput" })
+export type SubtaskPartInput = Types.DeepMutable<Schema.Schema.Type<typeof SubtaskPartInput>>
+
+export const Assistant = Schema.Struct({
+  ...messageBase,
+  role: Schema.Literal("assistant"),
+  time: Schema.Struct({
+    created: NonNegativeInt,
+    completed: Schema.optional(NonNegativeInt),
+  }),
+  error: Schema.optional(AssistantErrorSchema),
+  parentID: MessageID,
+  modelID: Model.ID,
+  providerID: Provider.ID,
+  mode: Schema.String,
+  agent: Schema.String,
+  path: Schema.Struct({
+    cwd: Schema.String,
+    root: Schema.String,
+  }),
+  summary: Schema.optional(Schema.Boolean),
+  cost: Schema.Finite,
+  tokens: Schema.Struct({
+    total: Schema.optional(Schema.Finite),
+    input: Schema.Finite,
+    output: Schema.Finite,
+    reasoning: Schema.Finite,
+    cache: Schema.Struct({
+      read: Schema.Finite,
+      write: Schema.Finite,
+    }),
+  }),
+  structured: Schema.optional(Schema.Any),
+  variant: Schema.optional(Schema.String),
+  finish: Schema.optional(Schema.String),
+}).annotate({ identifier: "AssistantMessage" })
+export type Assistant = Omit<Types.DeepMutable<Schema.Schema.Type<typeof Assistant>>, "error"> & {
+  error?: AssistantError
+}
+
+export const Info = Schema.Union([User, Assistant]).annotate({ discriminator: "role", identifier: "Message" })
+export type Info = User | Assistant
+
+export const WithParts = Schema.Struct({
+  info: Info,
+  parts: Schema.Array(Part),
+})
+export type WithParts = {
+  info: Info
+  parts: Part[]
+}
+
+const options = {
+  durable: {
+    aggregate: "sessionID",
+    version: 1,
+  },
+} as const
+
+const SessionSummary = Schema.Struct({
+  additions: Schema.Finite,
+  deletions: Schema.Finite,
+  files: Schema.Finite,
+  diffs: optionalOmitUndefined(Schema.Array(FileDiff)),
+})
+
+const SessionTokens = Schema.Struct({
+  input: Schema.Finite,
+  output: Schema.Finite,
+  reasoning: Schema.Finite,
+  cache: Schema.Struct({
+    read: Schema.Finite,
+    write: Schema.Finite,
+  }),
+})
+
+const SessionShare = Schema.Struct({
+  url: Schema.String,
+})
+
+const SessionRevert = Schema.Struct({
+  messageID: MessageID,
+  partID: optionalOmitUndefined(PartID),
+  snapshot: optionalOmitUndefined(Schema.String),
+  diff: optionalOmitUndefined(Schema.String),
+})
+
+const SessionModel = Schema.Struct({
+  id: Model.ID,
+  providerID: Provider.ID,
+  variant: optionalOmitUndefined(Schema.String),
+})
+
+export const SessionInfo = Schema.Struct({
+  id: SessionID.ID,
+  slug: Schema.String,
+  projectID: Project.ID,
+  workspaceID: optionalOmitUndefined(Workspace.ID),
+  directory: Schema.String,
+  path: optionalOmitUndefined(Schema.String),
+  parentID: optionalOmitUndefined(SessionID.ID),
+  summary: optionalOmitUndefined(SessionSummary),
+  cost: optionalOmitUndefined(Schema.Finite),
+  tokens: optionalOmitUndefined(SessionTokens),
+  share: optionalOmitUndefined(SessionShare),
+  title: Schema.String,
+  agent: optionalOmitUndefined(Schema.String),
+  model: optionalOmitUndefined(SessionModel),
+  version: Schema.String,
+  metadata: optionalOmitUndefined(Schema.Record(Schema.String, Schema.Any)),
+  time: Schema.Struct({
+    created: NonNegativeInt,
+    updated: NonNegativeInt,
+    compacting: optionalOmitUndefined(NonNegativeInt),
+    archived: optionalOmitUndefined(Schema.Finite),
+  }),
+  permission: optionalOmitUndefined(PermissionV1.Ruleset),
+  revert: optionalOmitUndefined(SessionRevert),
+}).annotate({ identifier: "Session" })
+export type SessionInfo = typeof SessionInfo.Type
+
+export const Event = {
+  Created: define({
+    type: "session.created",
+    ...options,
+    schema: {
+      sessionID: SessionID.ID,
+      info: SessionInfo,
+    },
+  }),
+  Updated: define({
+    type: "session.updated",
+    ...options,
+    schema: {
+      sessionID: SessionID.ID,
+      info: SessionInfo,
+    },
+  }),
+  Deleted: define({
+    type: "session.deleted",
+    ...options,
+    schema: {
+      sessionID: SessionID.ID,
+      info: SessionInfo,
+    },
+  }),
+  MessageUpdated: define({
+    type: "message.updated",
+    ...options,
+    schema: {
+      sessionID: SessionID.ID,
+      info: Info,
+    },
+  }),
+  MessageRemoved: define({
+    type: "message.removed",
+    ...options,
+    schema: {
+      sessionID: SessionID.ID,
+      messageID: MessageID,
+    },
+  }),
+  PartUpdated: define({
+    type: "message.part.updated",
+    ...options,
+    schema: {
+      sessionID: SessionID.ID,
+      part: Part,
+      time: Schema.Finite,
+    },
+  }),
+  PartRemoved: define({
+    type: "message.part.removed",
+    ...options,
+    schema: {
+      sessionID: SessionID.ID,
+      messageID: MessageID,
+      partID: PartID,
+    },
+  }),
+}
+
+export const Events = Object.freeze(Object.values(Event))

packages/schema/src/session.ts

@@ -7,6 +7,7 @@ import { Model } from "./model"
 import { Project } from "./project"
 import { DateTimeUtcFromMillis, optionalOmitUndefined, RelativePath } from "./schema"
 import { SessionID } from "./session-id"
+import { SessionEvent } from "./session-event"
 
 export const ID = SessionID.ID
 export type ID = SessionID.ID
@@ -44,3 +45,5 @@ export const ListAnchor = Schema.Struct({
   direction: Schema.Literals(["previous", "next"]),
 })
 export type ListAnchor = typeof ListAnchor.Type
+
+export const Event = SessionEvent

packages/schema/src/todo.ts

@@ -0,0 +1,22 @@
+export * as Todo from "./todo"
+
+import { Schema } from "effect"
+import { define, inventory } from "./event"
+import { SessionID } from "./session-id"
+
+export const Info = Schema.Struct({
+  content: Schema.String.annotate({ description: "Brief description of the task" }),
+  status: Schema.String.annotate({
+    description: "Current status of the task: pending, in_progress, completed, cancelled",
+  }),
+  priority: Schema.String.annotate({ description: "Priority level of the task: high, medium, low" }),
+}).annotate({ identifier: "Todo" })
+export type Info = typeof Info.Type
+
+export const Event = {
+  Updated: define({
+    type: "todo.updated",
+    schema: { sessionID: SessionID.ID, todos: Schema.Array(Info) },
+  }),
+}
+export const Events = inventory(Event.Updated)

packages/schema/test/event.test.ts

@@ -0,0 +1,71 @@
+import { describe, expect, test } from "bun:test"
+import { Schema } from "effect"
+import { Event } from "../src/event"
+import { SessionEvent } from "../src/session-event"
+import { SessionV1 } from "../src/session-v1"
+import { Todo } from "../src/todo"
+
+describe("public event schemas", () => {
+  test("definition is pure", () => {
+    const definitions = Event.inventory()
+    Event.define({ type: "test.pure", schema: { value: Schema.String } })
+    expect(definitions).toEqual([])
+  })
+
+  test("latest selection is independent of declaration order", () => {
+    const historical = Event.define({
+      type: "test.versioned",
+      durable: { aggregate: "id", version: 1 },
+      schema: { id: Schema.String },
+    })
+    const current = Event.define({
+      type: "test.versioned",
+      durable: { aggregate: "id", version: 2 },
+      schema: { id: Schema.String, value: Schema.String },
+    })
+
+    expect(Event.latest([historical, current]).get(current.type)).toBe(current)
+    expect(Event.latest([current, historical]).get(current.type)).toBe(current)
+  })
+
+  test("indexes every durable session type and version", () => {
+    const durable = Event.durable([...SessionV1.Events, ...SessionEvent.Definitions])
+    expect(durable.size).toBe(
+      SessionV1.Events.length + SessionEvent.DurableDefinitions.length + SessionEvent.HistoricalDefinitions.length,
+    )
+    for (const definition of [
+      ...SessionV1.Events,
+      ...SessionEvent.DurableDefinitions,
+      ...SessionEvent.HistoricalDefinitions,
+    ]) {
+      expect(durable.get(Event.versionedType(definition.type, definition.durable!.version))).toBe(definition)
+    }
+  })
+
+  test("latest aggregate excludes historical versions", () => {
+    const latest = Event.latest(SessionEvent.Definitions)
+    expect(latest.get(SessionEvent.Step.Ended.type)).toBe(SessionEvent.Step.Ended)
+    expect(latest.get(SessionEvent.Step.Failed.type)).toBe(SessionEvent.Step.Failed)
+    expect(latest.values().toArray()).not.toContain(SessionEvent.Step.EndedV1)
+    expect(latest.values().toArray()).not.toContain(SessionEvent.Step.FailedV1)
+  })
+
+  test("historical and current step shapes decode incompatibly", () => {
+    const historical = {
+      timestamp: 0,
+      sessionID: "ses_test",
+      finish: "stop",
+      cost: 0,
+      tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+    }
+    expect(Schema.decodeUnknownSync(SessionEvent.Step.EndedV1.data)(historical)).toBeDefined()
+    expect(() => Schema.decodeUnknownSync(SessionEvent.Step.Ended.data)(historical)).toThrow()
+  })
+
+  test("domain inventories are explicit and complete", () => {
+    expect(SessionEvent.Definitions.length).toBe(31)
+    expect(Todo.Events).toEqual([Todo.Event.Updated])
+    expect(Object.isFrozen(SessionEvent.Definitions)).toBe(true)
+    expect(Object.isFrozen(Todo.Events)).toBe(true)
+  })
+})

packages/sdk/js/src/v2/gen/types.gen.ts

@@ -88,6 +88,7 @@ export type Event =
   | EventWorkspaceStatus
   | EventWorktreeReady
   | EventWorktreeFailed
+  | EventIdeInstalled
   | EventServerConnected
   | EventGlobalDisposed
   | EventServerInstanceDisposed
@@ -1597,6 +1598,13 @@ export type GlobalEvent = {
           message: string
         }
       }
+    | {
+        id: string
+        type: "ide.installed"
+        properties: {
+          ide: string
+        }
+      }
     | {
         id: string
         type: "server.connected"
@@ -2833,6 +2841,7 @@ export type V2Event =
   | V2EventWorkspaceStatus
   | V2EventWorktreeReady
   | V2EventWorktreeFailed
+  | V2EventIdeInstalled
   | V2EventServerConnected
   | V2EventGlobalDisposed
 
@@ -5928,6 +5937,23 @@ export type V2EventWorktreeFailed = {
   }
 }
 
+export type V2EventIdeInstalled = {
+  id: string
+  metadata?: {
+    [key: string]: unknown
+  }
+  durable?: {
+    aggregateID: string
+    seq: number
+    version: number
+  }
+  location?: LocationRef
+  type: "ide.installed"
+  data: {
+    ide: string
+  }
+}
+
 export type V2EventServerConnected = {
   id: string
   metadata?: {
@@ -6902,6 +6928,14 @@ export type EventWorktreeFailed = {
   }
 }
 
+export type EventIdeInstalled = {
+  id: string
+  type: "ide.installed"
+  properties: {
+    ide: string
+  }
+}
+
 export type EventServerConnected = {
   id: string
   type: "server.connected"

packages/server/package.json

@@ -13,6 +13,7 @@
   },
   "dependencies": {
     "@opencode-ai/core": "workspace:*",
+    "@opencode-ai/schema": "workspace:*",
     "drizzle-orm": "catalog:",
     "effect": "catalog:"
   },

packages/server/src/api.ts

@@ -1,4 +1,4 @@
-import { HttpApi, OpenApi } from "effect/unstable/httpapi"
+import { HttpApi, HttpApiGroup, OpenApi } from "effect/unstable/httpapi"
 import { SchemaErrorMiddleware } from "./middleware/schema-error"
 import { MessageGroup } from "./groups/message"
 import { ModelGroup } from "./groups/model"
@@ -8,7 +8,8 @@ import { PermissionGroup } from "./groups/permission"
 import { FileSystemGroup } from "./groups/fs"
 import { CommandGroup } from "./groups/command"
 import { SkillGroup } from "./groups/skill"
-import { EventGroup } from "./groups/event"
+import { EventGroup, makeEventGroup } from "./groups/event"
+import type { Definition } from "@opencode-ai/schema/event"
 import { AgentGroup } from "./groups/agent"
 import { HealthGroup } from "./groups/health"
 import { PtyGroup } from "./groups/pty"
@@ -20,31 +21,36 @@ import { IntegrationGroup } from "./groups/integration"
 import { CredentialGroup } from "./groups/credential"
 import { ProjectCopyGroup } from "./groups/project-copy"
 
-export const Api = HttpApi.make("server")
-  .add(HealthGroup)
-  .add(LocationGroup)
-  .add(AgentGroup)
-  .add(SessionGroup)
-  .add(MessageGroup)
-  .add(ModelGroup)
-  .add(ProviderGroup)
-  .add(IntegrationGroup)
-  .add(CredentialGroup)
-  .add(PermissionGroup)
-  .add(FileSystemGroup)
-  .add(CommandGroup)
-  .add(SkillGroup)
-  .add(EventGroup)
-  .add(PtyGroup)
-  .add(QuestionGroup)
-  .add(ReferenceGroup)
-  .add(ProjectCopyGroup)
-  .annotateMerge(
-    OpenApi.annotations({
-      title: "opencode HttpApi",
-      version: "0.0.1",
-      description: "Experimental HttpApi surface for selected instance routes.",
-    }),
-  )
-  .middleware(Authorization)
-  .middleware(SchemaErrorMiddleware)
+const makeApiFromGroup = <const Group extends HttpApiGroup.Any>(eventGroup: Group) =>
+  HttpApi.make("server")
+    .add(HealthGroup)
+    .add(LocationGroup)
+    .add(AgentGroup)
+    .add(SessionGroup)
+    .add(MessageGroup)
+    .add(ModelGroup)
+    .add(ProviderGroup)
+    .add(IntegrationGroup)
+    .add(CredentialGroup)
+    .add(PermissionGroup)
+    .add(FileSystemGroup)
+    .add(CommandGroup)
+    .add(SkillGroup)
+    .add(eventGroup)
+    .add(PtyGroup)
+    .add(QuestionGroup)
+    .add(ReferenceGroup)
+    .add(ProjectCopyGroup)
+    .annotateMerge(
+      OpenApi.annotations({
+        title: "opencode HttpApi",
+        version: "0.0.1",
+        description: "Experimental HttpApi surface for selected instance routes.",
+      }),
+    )
+    .middleware(Authorization)
+    .middleware(SchemaErrorMiddleware)
+
+export const makeApi = (definitions: ReadonlyArray<Definition>) => makeApiFromGroup(makeEventGroup(definitions))
+
+export const Api = makeApiFromGroup(EventGroup)

packages/server/src/groups/event.ts

@@ -1,5 +1,7 @@
 import { EventV2 } from "@opencode-ai/core/event"
+import { PublicEventManifest } from "@opencode-ai/core/public-event-manifest"
 import { Location } from "@opencode-ai/core/location"
+import type { Definition } from "@opencode-ai/schema/event"
 import { Schema } from "effect"
 import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi"
 
@@ -10,33 +12,40 @@ const fields = {
   location: Schema.optional(Location.Ref),
 }
 
-const Event = Schema.Union([
-  ...EventV2.definitions().map((definition) =>
-    Schema.Struct({
-      ...fields,
-      type: Schema.Literal(definition.type),
-      data: definition.data as Schema.Struct<{}>,
-    }).annotate({ identifier: `V2Event.${definition.type}` }),
-  ),
-  Schema.Struct({
-    ...fields,
-    type: Schema.Literal("server.connected"),
-    data: Schema.Struct({}),
-  }).annotate({ identifier: "V2Event.server.connected" }),
-]).annotate({ identifier: "V2Event" })
-
-export const EventGroup = HttpApiGroup.make("server.event")
-  .add(
-    HttpApiEndpoint.get("event.subscribe", "/api/event", {
-      success: Event,
-    }).annotateMerge(
-      OpenApi.annotations({
-        identifier: "v2.event.subscribe",
-        summary: "Subscribe to events",
-        description: "Subscribe to native event payloads for the server.",
-      }),
+const schema = (definitions: ReadonlyArray<Definition>) =>
+  Schema.Union([
+    ...definitions.map((definition) =>
+      Schema.Struct({
+        ...fields,
+        type: Schema.Literal(definition.type),
+        data: definition.data,
+      }).annotate({ identifier: `V2Event.${definition.type}` }),
     ),
-  )
-  .annotateMerge(OpenApi.annotations({ title: "events", description: "Experimental event stream route." }))
+    ...(definitions.some((definition) => definition.type === "server.connected")
+      ? []
+      : [
+          Schema.Struct({
+            ...fields,
+            type: Schema.Literal("server.connected"),
+            data: Schema.Struct({}),
+          }).annotate({ identifier: "V2Event.server.connected" }),
+        ]),
+  ]).annotate({ identifier: "V2Event" })
 
-export type Event = typeof Event.Type
+export const makeEventGroup = (definitions: ReadonlyArray<Definition>) =>
+  HttpApiGroup.make("server.event")
+    .add(
+      HttpApiEndpoint.get("event.subscribe", "/api/event", {
+        success: schema(definitions),
+      }).annotateMerge(
+        OpenApi.annotations({
+          identifier: "v2.event.subscribe",
+          summary: "Subscribe to events",
+          description: "Subscribe to native event payloads for the server.",
+        }),
+      ),
+    )
+    .annotateMerge(OpenApi.annotations({ title: "events", description: "Experimental event stream route." }))
+
+export const EventGroup = makeEventGroup(PublicEventManifest.Latest.values().toArray())
+export type Event = Schema.Schema.Type<ReturnType<typeof schema>>