refactor(schema): extract public event definitions (#33579)

packages/core/src/question.ts

@@ -1,83 +1,35 @@
 export * as QuestionV2 from "./question"
 
 import { Context, Deferred, Effect, Layer, Schema } from "effect"
+import { Question } from "@opencode-ai/schema/question"
 import { EventV2 } from "./event"
-import { Identifier } from "./id/id"
-import { withStatics } from "./schema"
 import { SessionSchema } from "./session/schema"
 
-export const ID = Schema.String.check(Schema.isStartsWith("que")).pipe(
-  Schema.brand("QuestionV2.ID"),
-  withStatics((schema) => ({ ascending: (id?: string) => schema.make(Identifier.ascending("question", id)) })),
-)
+export const ID = Question.ID
 export type ID = typeof ID.Type
 
-export const Option = Schema.Struct({
-  label: Schema.String.annotate({ description: "Display text (1-5 words, concise)" }),
-  description: Schema.String.annotate({ description: "Explanation of choice" }),
-}).annotate({ identifier: "QuestionV2.Option" })
+export const Option = Question.Option
 export type Option = typeof Option.Type
 
-const base = {
-  question: Schema.String.annotate({ description: "Complete question" }),
-  header: Schema.String.annotate({ description: "Very short label (max 30 chars)" }),
-  options: Schema.Array(Option).annotate({ description: "Available choices" }),
-  multiple: Schema.Boolean.pipe(Schema.optional).annotate({ description: "Allow selecting multiple choices" }),
-}
-
-export const Info = Schema.Struct({
-  ...base,
-  custom: Schema.Boolean.pipe(Schema.optional).annotate({
-    description: "Allow typing a custom answer (default: true)",
-  }),
-}).annotate({ identifier: "QuestionV2.Info" })
+export const Info = Question.Info
 export type Info = typeof Info.Type
 
-export const Prompt = Schema.Struct(base).annotate({ identifier: "QuestionV2.Prompt" })
+export const Prompt = Question.Prompt
 export type Prompt = typeof Prompt.Type
 
-export const Tool = Schema.Struct({
-  messageID: Schema.String,
-  callID: Schema.String,
-}).annotate({ identifier: "QuestionV2.Tool" })
+export const Tool = Question.Tool
 export type Tool = typeof Tool.Type
 
-export const Request = Schema.Struct({
-  id: ID,
-  sessionID: SessionSchema.ID,
-  questions: Schema.Array(Info).annotate({ description: "Questions to ask" }),
-  tool: Tool.pipe(Schema.optional),
-}).annotate({ identifier: "QuestionV2.Request" })
+export const Request = Question.Request
 export type Request = typeof Request.Type
 
-export const Answer = Schema.Array(Schema.String).annotate({ identifier: "QuestionV2.Answer" })
+export const Answer = Question.Answer
 export type Answer = typeof Answer.Type
 
-export const Reply = Schema.Struct({
-  answers: Schema.Array(Answer).annotate({
-    description: "User answers in order of questions (each answer is an array of selected labels)",
-  }),
-}).annotate({ identifier: "QuestionV2.Reply" })
+export const Reply = Question.Reply
 export type Reply = typeof Reply.Type
 
-export const Event = {
-  Asked: EventV2.define({ type: "question.v2.asked", schema: Request.fields }),
-  Replied: EventV2.define({
-    type: "question.v2.replied",
-    schema: {
-      sessionID: SessionSchema.ID,
-      requestID: ID,
-      answers: Schema.Array(Answer),
-    },
-  }),
-  Rejected: EventV2.define({
-    type: "question.v2.rejected",
-    schema: {
-      sessionID: SessionSchema.ID,
-      requestID: ID,
-    },
-  }),
-}
+export const Event = Question.Event
 
 export class RejectedError extends Schema.TaggedErrorClass<RejectedError>()("QuestionV2.RejectedError", {}) {
   override get message() {