liminal 0.16.0 → 0.17.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # liminal
 
+## 0.17.0
+
+### Minor Changes
+
+- 8212083: Refactor L.sequence -> L.line. Decouple thread effects from the providing of effects via L.provide.
+
 ## 0.16.0
 
 ### Minor Changes

package/Digest.ts

@@ -0,0 +1,30 @@
+import * as Effect from "effect/Effect"
+import * as Layer from "effect/Layer"
+import * as Option from "effect/Option"
+import * as Schema from "effect/Schema"
+import type { Thread } from "./Thread.ts"
+import { prefix } from "./util/prefix.ts"
+
+export const DigestTypeId: unique symbol = Symbol.for(prefix("Digest"))
+export type DigestTypeId = typeof DigestTypeId
+
+export declare const Digest: <const K extends string, A = string, I = string>(
+  key: K,
+  schema?: Schema.Schema<A, I>,
+) => <Self>() => DigestClass<K, A, I, Self>
+
+export interface DigestClass<K extends string, A, I, Self> extends Effect.Effect<A, never, Self> {
+  new(_: never): this
+
+  readonly Type: A
+  readonly Encoded: I
+  readonly [DigestTypeId]: DigestTypeId
+  readonly key: K
+  readonly digest: Effect.Effect<void, never, Self>
+  readonly layer: <E, R>(
+    f: (
+      state: Option.Option<A>,
+      inbox: Thread,
+    ) => Effect.Effect<A, E, R>,
+  ) => Layer.Layer<Self, E, Exclude<R, Self | Thread>>
+}

package/Envelope.ts

@@ -1,48 +1,16 @@
-import * as AiInput from "@effect/ai/AiInput"
-import * as Effect from "effect/Effect"
-import * as Option from "effect/Option"
-import { append } from "./L/append.ts"
-import { raw } from "./L/raw.ts"
-import { Self } from "./L/Self.ts"
-import type { Thread } from "./Thread.ts"
-import { type Taggable } from "./util/Taggable.ts"
+import { Thread } from "./Thread.ts"
 
-export interface MessageHeaders {
-  readonly to: Array<Thread>
-  readonly cc?: Array<Thread> | undefined
-  readonly bcc?: Array<Thread> | undefined
-}
-
-export interface EnvelopeMembers {
-  readonly headers: MessageHeaders
-  readonly cc: (...cc: Array<Thread>) => Envelope
-  readonly bcc: (...bcc: Array<Thread>) => Envelope
-}
-
-export interface Envelope extends Taggable<void, never, Thread>, EnvelopeMembers {}
-
-// TODO: cc, bcc
-export const Envelope = (headers: MessageHeaders): Envelope =>
-  Object.assign(
-    Effect.fnUntraced(function*(a0, ...aRest) {
-      const { state: { fqn } } = yield* Self
-      const name = Option.getOrElse(fqn, () => "anonymous-entity")
-      const text = yield* raw(a0, ...aRest)
-      if (!text) return
-      const { to, cc: _cc, bcc: _bcc } = headers
-      for (const recipient of to) {
-        yield* append(AiInput.UserMessage.make({
-          parts: [
-            AiInput.TextPart.make({
-              text: `[FROM: ${name}]\n${text}`,
-            }),
-          ],
-        })).pipe(Effect.provideService(Self, recipient))
-      }
-    }) satisfies Taggable<void, never, Thread>,
-    {
-      headers,
-      cc: (...cc) => Envelope({ ...headers, cc }),
-      bcc: (...bcc) => Envelope({ ...headers, bcc }),
-    } satisfies EnvelopeMembers,
-  )
+export type Envelope =
+  & ({
+    to: Array<Thread>
+    cc?: never
+  } | {
+    to?: never
+    cc: Array<Thread>
+  } | {
+    to: Array<Thread>
+    cc: Array<Thread>
+  })
+  & {
+    bcc?: Array<Thread>
+  }

package/F/F.ts

@@ -0,0 +1 @@
+export * from "../L/json.ts"

package/L/L.ts

@@ -7,15 +7,14 @@ export * from "./clear.ts"
 export * from "./disable.ts"
 export * from "./enable.ts"
 export * from "./events.ts"
-export * from "./fqn.ts"
-export * from "./handle.ts"
+export * from "./line.ts"
+export * from "./listen.ts"
 export * from "./messages.ts"
-export * from "./raw.ts"
-export * from "./Self.ts"
-export * from "./sequence.ts"
+export * from "./prev.ts"
+export * from "./provide.ts"
+export * from "./self.ts"
+export * from "./send.ts"
 export * from "./system.ts"
 export * from "./thread.ts"
-export * from "./to.ts"
 export * from "./toolkit.ts"
 export * from "./user.ts"
-export * from "./userJson.ts"

package/L/append.ts

@@ -1,14 +1,14 @@
 import type { Message } from "@effect/ai/AiInput"
 import * as Effect from "effect/Effect"
-import { MessagesAppended } from "../LEvent.ts"
+import { MessagesAppendedEvent } from "../LEvent.ts"
 import type { Thread } from "../Thread.ts"
-import { Self } from "./Self.ts"
+import { self } from "./self.ts"
 
 /** Append messages to the thread. */
 export const append: (
   ...messages: Array<Message>
 ) => Effect.Effect<void, never, Thread> = Effect.fnUntraced(function*(...messages) {
-  const { state, events } = yield* Self
+  const { state, events } = yield* self
   state.messages.push(...messages)
-  yield* events.publish(MessagesAppended.make({ messages }))
+  yield* events.publish(MessagesAppendedEvent.make({ messages }))
 })

package/L/assistant.ts

@@ -5,13 +5,13 @@ import * as Effect from "effect/Effect"
 import * as Option from "effect/Option"
 import type { Thread } from "../Thread.ts"
 import { append } from "./append.ts"
-import { Self } from "./Self.ts"
+import { self } from "./self.ts"
 import { toolkit } from "./toolkit.ts"
 
 /** Infer an assistant message and append it to the thread. */
 export const assistant: Effect.Effect<string, AiError, AiLanguageModel | Thread> = Effect.gen(function*() {
   const model = yield* AiLanguageModel
-  const { state: { system, messages: prompt } } = yield* Self
+  const { state: { system, messages: prompt } } = yield* self
   let { text, results } = yield* model.generateText({
     system: Option.getOrUndefined(system),
     prompt,

package/L/assistantSchema.ts

@@ -8,7 +8,7 @@ import * as SchemaAST from "effect/SchemaAST"
 import type { Thread } from "../Thread.ts"
 import { encodeJsonc, type JsonValue } from "../util/JsonValue.ts"
 import { append } from "./append.ts"
-import { Self } from "./Self.ts"
+import { self } from "./self.ts"
 
 /** Infer a structured assistant message and append its JSON representation to the conversation. */
 export const assistantSchema: {
@@ -20,7 +20,7 @@ export const assistantSchema: {
   ): Effect.Effect<O, AiError, AiLanguageModel | Thread>
 } = Effect.fnUntraced(function*(schema) {
   const model = yield* AiLanguageModel
-  const { state: { system, messages } } = yield* Self
+  const { state: { system, messages } } = yield* self
 
   const isSchema = Schema.isSchema(schema)
   const schema_ = isSchema ? schema : Schema.Struct(schema) as Schema.Schema.AnyNoContext

package/L/assistantStream.ts

@@ -5,14 +5,14 @@ import * as Effect from "effect/Effect"
 import * as Option from "effect/Option"
 import * as Stream from "effect/Stream"
 import type { Thread } from "../Thread.ts"
-import { Self } from "./Self.ts"
+import { self } from "./self.ts"
 import { toolkit } from "./toolkit.ts"
 
 /** Get a stream of an assistant message (does not append the message to the thread). */
 export const assistantStream: Stream.Stream<AiResponse, AiError, AiLanguageModel | Thread> = Stream.unwrap(
   Effect.gen(function*() {
     const model = yield* AiLanguageModel
-    const { state: { system, messages: prompt } } = yield* Self
+    const { state: { system, messages: prompt } } = yield* self
     return model.streamText({
       system: Option.getOrUndefined(system),
       prompt,

package/L/branch.ts

@@ -1,33 +1,20 @@
 import * as Effect from "effect/Effect"
-import { flow } from "effect/Function"
 import * as Option from "effect/Option"
 import * as PubSub from "effect/PubSub"
 import type { LEvent } from "../LEvent.ts"
 import { Thread, ThreadState } from "../Thread.ts"
-import type { Sequencer } from "../util/Sequencer.ts"
-import { Self } from "./Self.ts"
-import { sequence } from "./sequence.ts"
+import { self } from "./self.ts"
 
-export interface branch extends Sequencer<never, Thread>, Effect.Effect<Thread, never, Thread> {}
-
-const branch_ = Effect.gen(function*() {
-  const parent = yield* Self
+export const branch: Effect.Effect<Thread, never, Thread> = Effect.gen(function*() {
+  const parent = yield* self
   return Thread({
+    id: parent.id,
     parent: Option.some(parent),
     events: yield* PubSub.unbounded<LEvent>(),
     state: ThreadState.make({
-      fqn: parent.state.fqn,
       system: parent.state.system,
       messages: [...parent.state.messages ?? []],
     }),
     tools: parent.tools.pipe(Option.map((v) => new Set(v))),
   })
 })
-
-export const branch: branch = Object.assign(
-  flow(
-    sequence,
-    Effect.provideServiceEffect(Self, branch_),
-  ),
-  branch_,
-)

package/L/clear.ts

@@ -1,14 +1,14 @@
 import type { Message } from "@effect/ai/AiInput"
 import * as Effect from "effect/Effect"
-import { MessagesCleared } from "../LEvent.ts"
+import { ThreadClearedEvent } from "../LEvent.ts"
 import type { Thread } from "../Thread.ts"
-import { Self } from "./Self.ts"
+import { self } from "./self.ts"
 
 /** Clear the thread of messages. */
 export const clear: Effect.Effect<Array<Message>, never, Thread> = Effect.gen(function*() {
-  const { state, events } = yield* Self
+  const { state, events } = yield* self
   const cleared = state.messages
   state.messages = []
-  yield* events.publish(MessagesCleared.make({ cleared }))
+  yield* events.publish(ThreadClearedEvent.make({ cleared }))
   return cleared
 })

package/L/disable.ts

@@ -3,10 +3,10 @@ import * as Effect from "effect/Effect"
 import * as Option from "effect/Option"
 import type { Thread } from "../Thread.ts"
 import type { NeverTool } from "../util/NeverTool.ts"
-import { Self } from "./Self.ts"
+import { self } from "./self.ts"
 
 export const disable = (tool: AiTool.Any): Effect.Effect<void, never, Thread> =>
-  Effect.map(Self, ({ tools }) => {
+  Effect.map(self, ({ tools }) => {
     if (Option.isSome(tools)) {
       tools.value.delete(tool as NeverTool)
     }

package/L/enable.ts

@@ -4,7 +4,7 @@ import * as Option from "effect/Option"
 import type { Schema } from "effect/Schema"
 import type { Thread } from "../Thread.ts"
 import type { NeverTool } from "../util/NeverTool.ts"
-import { Self } from "./Self.ts"
+import { self } from "./self.ts"
 
 export const enable = <
   K extends string,
@@ -13,7 +13,7 @@ export const enable = <
 >(
   tool: AiTool<K, AnyStructSchema, Schema.Any, E, R>,
 ): Effect.Effect<void, E, Handler<K> | Thread | R> =>
-  Effect.map(Self, (thread) => {
+  Effect.map(self, (thread) => {
     const tool_: NeverTool = tool as never
     Option.match(thread.tools, {
       onSome: (value) => value.add(tool_),

package/L/events.ts

@@ -2,10 +2,10 @@ import * as Effect from "effect/Effect"
 import * as Stream from "effect/Stream"
 import type { LEvent } from "../LEvent.ts"
 import type { Thread } from "../Thread.ts"
-import { Self } from "./Self.ts"
+import { self } from "./self.ts"
 
 /** A stream of thread events. */
-export const events: Stream.Stream<LEvent, never, Thread> = Self.pipe(
+export const events: Stream.Stream<LEvent, never, Thread> = self.pipe(
   Effect.map(({ events }) => Stream.fromPubSub(events)),
   Stream.unwrap,
 )

package/L/{userJson.ts → json.ts}

@@ -1,14 +1,12 @@
 import * as Effect from "effect/Effect"
 import type * as Schema from "effect/Schema"
-import type { Thread } from "../Thread.ts"
 import { encodeJsonc, type JsonValue } from "../util/JsonValue.ts"
-import { user } from "./user.ts"
 
 /** Stringify and append some JSON as a user message to the conversation. */
-export const userJson: <A, I extends JsonValue>(
+export const json: <A, I extends JsonValue>(
   value: A,
   schema?: Schema.Schema<A, I>,
-) => Effect.Effect<void, never, Thread> = Effect.fnUntraced(function*(value, schema) {
+) => Effect.Effect<string> = Effect.fnUntraced(function*(value, schema) {
   const encoded = schema ? encodeJsonc(schema)(value) : JSON.stringify(value, null, 2)
-  return yield* user`\`\`\`json${schema ? "c" : ""}\n${encoded}\n\`\`\``
+  return `\`\`\`json${schema ? "c" : ""}\n${encoded}\n\`\`\``
 })

package/L/line.ts

@@ -0,0 +1,22 @@
+import * as Effect from "effect/Effect"
+import { prev } from "./prev.ts"
+
+export interface line<RIn = never, E = never, ROut = never> {
+  <Arg extends Array<Effect.All.EffectAny>>(
+    ...steps: Arg
+  ): Effect.Effect<
+    Arg extends [] ? void
+      : Arg extends [...infer _0, infer L extends Effect.All.EffectAny] ? Effect.Effect.Success<L>
+      : never,
+    Effect.Effect.Error<Arg[number]> | E,
+    Exclude<Effect.Effect.Context<Arg[number]>, RIn> | ROut
+  >
+}
+export const line: line = Effect.fnUntraced(function*(...steps) {
+  let acc: unknown
+  while (steps.length) {
+    const current = steps.shift()!
+    acc = yield* (current.pipe(Effect.provideService(prev, acc)) as Effect.Effect<any>)
+  }
+  return acc as never
+})

package/L/{handle.ts → listen.ts}

@@ -4,14 +4,14 @@ import * as Scope from "effect/Scope"
 import * as Stream from "effect/Stream"
 import type { LEvent } from "../LEvent.ts"
 import type { Thread } from "../Thread.ts"
-import { Self } from "./Self.ts"
+import { self } from "./self.ts"
 
 /** Attach an event handler to process thread events. */
 export const listen: <A, E, R>(
   f: (event: LEvent) => Effect.Effect<A, E, R>,
 ) => Effect.Effect<RuntimeFiber<void, E>, never, Thread | R | Scope.Scope> = Effect.fnUntraced(function*(f) {
   const latch = yield* Effect.makeLatch(false)
-  const { events } = yield* Self
+  const { events } = yield* self
   const dequeue = yield* events.subscribe
   const fiber = yield* latch.open.pipe(
     Effect.zipRight(

package/L/messages.ts

@@ -1,10 +1,10 @@
 import type { Message } from "@effect/ai/AiInput"
 import * as Effect from "effect/Effect"
 import type { Thread } from "../Thread.ts"
-import { Self } from "./Self.ts"
+import { self } from "./self.ts"
 
 /** Get a copy of the current list of messages. */
 export const messages: Effect.Effect<Array<Message>, never, Thread> = Effect.map(
-  Self,
+  self,
   ({ state: { messages: [...messages] } }) => messages,
 )

package/L/prev.ts

@@ -0,0 +1,4 @@
+import * as Context from "effect/Context"
+import { prefix } from "../util/prefix.ts"
+
+export class prev extends Context.Tag(prefix("prev"))<prev, unknown>() {}

package/L/provide.ts

@@ -0,0 +1,10 @@
+import * as Effect from "effect/Effect"
+import type { Thread } from "../Thread.ts"
+import { self } from "./self.ts"
+
+export const provide = <E, R>(
+  thread: Effect.Effect<Thread, E, R>,
+) =>
+<A1, E1, R1>(
+  a: Effect.Effect<A1, E1, R1>,
+): Effect.Effect<A1, E | E1, R | Exclude<R1, Thread>> => Effect.provideServiceEffect(self, thread)(a)

package/L/{Self.ts → self.ts}

@@ -2,4 +2,4 @@ import * as Context from "effect/Context"
 import type { Thread } from "../Thread.ts"
 import { prefix } from "../util/prefix.ts"
 
-export const Self: Context.Tag<Thread, Thread> = Context.GenericTag<Thread>(prefix("Self"))
+export const self: Context.Tag<Thread, Thread> = Context.GenericTag<Thread>(prefix("Self"))

package/L/send.ts

@@ -0,0 +1,56 @@
+import * as AiInput from "@effect/ai/AiInput"
+import * as Array from "effect/Array"
+import * as Effect from "effect/Effect"
+import type { YieldWrap } from "effect/Utils"
+import type { Envelope } from "../Envelope.ts"
+import type { Thread } from "../Thread.ts"
+import type { ExtractE, ExtractR } from "../util/extract.ts"
+import { raw } from "../util/raw.ts"
+import { normalize, type TaggableArg0, type TaggableArgRest } from "../util/Taggable.ts"
+import { append } from "./append.ts"
+import { self } from "./self.ts"
+
+export const send = (envelope: Envelope) =>
+  Effect.fnUntraced(function*<
+    A0 extends TaggableArg0,
+    ARest extends TaggableArgRest<A0>,
+  >(
+    a0: A0,
+    ...aRest: ARest
+  ): Generator<
+    YieldWrap<
+      Effect.Effect<
+        void,
+        ExtractE<A0 | ARest[number]>,
+        ExtractR<A0 | ARest[number]> | Thread
+      >
+    >,
+    void,
+    never
+  > {
+    const text = yield* normalize(a0, ...aRest)
+    if (!text) return
+    const { to, cc, bcc } = envelope
+    const ccHeader = cc?.length
+      ? yield* raw`; ${Effect.all(cc).pipe(Effect.map(Array.join(", ")))}`
+      : ""
+    const headers = raw`[FROM: ${self}${ccHeader}]`
+    const knownRecipients = [...to ?? [], ...cc ?? []]
+    const program = append(
+      AiInput.UserMessage.make({
+        parts: [
+          AiInput.TextPart.make({
+            text: `${headers}\n${text}`,
+          }),
+        ],
+      }),
+    )
+    for (const recipient of knownRecipients) {
+      yield* program.pipe(Effect.provideService(self, recipient))
+    }
+    if (bcc?.length) {
+      for (const hiddenRecipient of bcc) {
+        yield* program.pipe(Effect.provideService(self, hiddenRecipient))
+      }
+    }
+  })

package/L/system.ts

@@ -1,14 +1,25 @@
 import * as Effect from "effect/Effect"
 import * as Option from "effect/Option"
-import type { Thread } from "../Thread.ts"
-import type { Taggable } from "../util/Taggable.ts"
-import { raw } from "./raw.ts"
-import { Self } from "./Self.ts"
+import type { YieldWrap } from "effect/Utils"
+import { SystemSetEvent } from "../LEvent.ts"
+import { normalize, type TaggableArg0, type TaggableArgRest } from "../util/Taggable.ts"
+import { self } from "./self.ts"
 
 /** Set the thread's system instruction. */
-export const system: Taggable<Option.Option<string>, never, Thread> = Effect.fnUntraced(function*(a0, ...aRest) {
-  const { state } = yield* Self
+export const system = Effect.fnUntraced(function*<
+  A0 extends TaggableArg0,
+  ARest extends TaggableArgRest<A0>,
+>(
+  a0: A0,
+  ...aRest: ARest
+): Generator<
+  YieldWrap<typeof self | ReturnType<typeof normalize<A0, ARest>> | Effect.Effect<boolean>>,
+  Option.Option<string>,
+  never
+> {
+  const { state, events } = yield* self
   const { system } = state
-  state.system = a0 ? Option.some(yield* raw(a0, ...aRest)) : Option.none()
+  state.system = a0 ? Option.some(yield* normalize(a0, ...aRest)) : Option.none()
+  yield* events.publish(new SystemSetEvent({ system: state.system }))
   return system
 })

package/L/thread.ts

@@ -1,28 +1,16 @@
 import * as Effect from "effect/Effect"
-import { flow } from "effect/Function"
 import * as Option from "effect/Option"
 import * as PubSub from "effect/PubSub"
 import type { LEvent } from "../LEvent.ts"
-import { Thread, ThreadState } from "../Thread.ts"
-import type { Sequencer } from "../util/Sequencer.ts"
-import { Self } from "./Self.ts"
-import { sequence } from "./sequence.ts"
+import { Thread, ThreadId, ThreadState } from "../Thread.ts"
+import { self } from "./self.ts"
 
-export interface thread extends Sequencer<Thread>, Effect.Effect<Thread> {}
-
-const thread_ = Effect.gen(function*() {
+export const thread: Effect.Effect<Thread> = Effect.gen(function*() {
   return Thread({
-    parent: yield* Effect.serviceOption(Self),
+    id: ThreadId.make(crypto.randomUUID()),
+    parent: yield* Effect.serviceOption(self),
     events: yield* PubSub.unbounded<LEvent>(),
     state: ThreadState.default(),
     tools: Option.none(),
   })
 })
-
-export const thread: thread = Object.assign(
-  flow(
-    sequence,
-    Effect.provideServiceEffect(Self, thread_),
-  ),
-  thread_,
-)

package/L/toolkit.ts

@@ -2,9 +2,9 @@ import * as AiToolkit from "@effect/ai/AiToolkit"
 import * as Effect from "effect/Effect"
 import * as Option from "effect/Option"
 import type { NeverTool } from "../util/NeverTool.ts"
-import { Self } from "./Self.ts"
+import { self } from "./self.ts"
 
-export const toolkit = Self.pipe(
+export const toolkit = self.pipe(
   Effect.flatMap(({ tools }) =>
     Option.match(tools, {
       onSome: (tools) => AiToolkit.make(...tools),

package/L/user.test.ts

@@ -2,6 +2,7 @@ import { TextPart, UserMessage } from "@effect/ai/AiInput"
 import { expect, it } from "@effect/vitest"
 import * as Effect from "effect/Effect"
 import { messages } from "./messages.ts"
+import { provide } from "./provide.ts"
 import { thread } from "./thread.ts"
 import { user } from "./user.ts"
 
@@ -26,5 +27,7 @@ it.effect("test success", () =>
       }),
     ])
   }).pipe(
-    thread,
+    provide(
+      thread,
+    ),
   ))

package/L/user.ts

@@ -1,13 +1,23 @@
 import { TextPart, UserMessage } from "@effect/ai/AiInput"
 import * as Effect from "effect/Effect"
 import type { Thread } from "../Thread.ts"
-import type { Taggable } from "../util/Taggable.ts"
+import type { ExtractE, ExtractR } from "../util/extract.ts"
+import { normalize, type TaggableArg0, type TaggableArgRest } from "../util/Taggable.ts"
 import { append } from "./append.ts"
-import { raw } from "./raw.ts"
 
-/** Append a user message to the conversation. */
-export const user: Taggable<void, never, Thread> = (a0, ...aRest) =>
-  raw(a0, ...aRest).pipe(
+/** Append a user message to the thread. */
+export const user = <
+  A0 extends TaggableArg0,
+  ARest extends TaggableArgRest<A0>,
+>(
+  a0: A0,
+  ...aRest: ARest
+): Effect.Effect<
+  void,
+  ExtractE<A0 | ARest[number]>,
+  ExtractR<A0 | ARest[number]> | Thread
+> =>
+  normalize(a0, ...aRest).pipe(
     Effect.flatMap((text) =>
       text
         ? append(

package/LEvent.ts

@@ -1,23 +1,33 @@
 import { Message } from "@effect/ai/AiInput"
 import * as Schema from "effect/Schema"
 
-export class Messages extends Schema.Array(Message) {}
-
-/** An event in which one or more messages were added to the thread. */
-export class MessagesAppended extends Schema.TaggedClass<MessagesAppended>("MessagesAppended")("MessagesAppended", {
-  messages: Messages,
+/** Event in which the thread's system is set to a new string. */
+export class SystemSetEvent extends Schema.TaggedClass<SystemSetEvent>("SystemSetEvent")("system_set", {
+  system: Schema.Option(Schema.String),
 }) {}
 
-/** An event in which the thread is cleared of messages. */
-export class MessagesCleared extends Schema.TaggedClass<MessagesCleared>("MessagesCleared")("MessagesCleared", {
-  cleared: Messages,
-}) {}
+/** Event in which one or more messages were added to the thread. */
+export class MessagesAppendedEvent
+  extends Schema.TaggedClass<MessagesAppendedEvent>("MessagesAppendedEvent")("messages_appended", {
+    messages: Schema.Array(Message),
+  })
+{}
+
+/** Event in which the thread is cleared of messages. */
+export class ThreadClearedEvent
+  extends Schema.TaggedClass<ThreadClearedEvent>("MessagesClearedEvent")("messages_cleared", {})
+{}
 
 export type LEvent = typeof LEvent["Type"]
 export const LEvent: Schema.Union<[
-  typeof MessagesAppended,
-  typeof MessagesCleared,
+  typeof SystemSetEvent,
+  typeof MessagesAppendedEvent,
+  typeof ThreadClearedEvent,
 ]> = Schema.Union(
-  MessagesAppended,
-  MessagesCleared,
+  SystemSetEvent,
+  MessagesAppendedEvent,
+  ThreadClearedEvent,
 )
+
+export const encodeLEvent = Schema.encode(LEvent)
+export const decodeLEvent = Schema.decode(LEvent)