liminal 0.14.0 → 0.16.0

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # liminal
 
+## 0.16.0
+
+### Minor Changes
+
+- 2e96076: Refactoring "strands" into "threads", which can provide a handle with which to operate on the thread context outside of the thread's sequencers arguments.
+
+## 0.15.0
+
+### Minor Changes
+
+- 3b4ec1a: - Instead of providing `AiToolkit` to `L.enable`/`L.disable`, we now provide tools directly.
+  - Also includes the beginnings of a `coalesceModels` pattern.
+
 ## 0.14.0
 
 ### Minor Changes

package/Envelope.ts

@@ -0,0 +1,48 @@
+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"
+
+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,
+  )

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

@@ -4,12 +4,18 @@ export * from "./assistantSchema.ts"
 export * from "./assistantStream.ts"
 export * from "./branch.ts"
 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 "./messages.ts"
+export * from "./raw.ts"
+export * from "./Self.ts"
 export * from "./sequence.ts"
-export * from "./strand_.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/Self.ts

@@ -0,0 +1,5 @@
+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"))

package/L/append.ts

@@ -0,0 +1,14 @@
+import type { Message } from "@effect/ai/AiInput"
+import * as Effect from "effect/Effect"
+import { MessagesAppended } from "../LEvent.ts"
+import type { Thread } from "../Thread.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
+  state.messages.push(...messages)
+  yield* events.publish(MessagesAppended.make({ messages }))
+})

package/{assistant.ts → L/assistant.ts}

@@ -1,28 +1,29 @@
 import type { AiError } from "@effect/ai/AiError"
 import { AssistantMessage, TextPart } from "@effect/ai/AiInput"
 import { AiLanguageModel } from "@effect/ai/AiLanguageModel"
-import * as AiToolkit from "@effect/ai/AiToolkit"
 import * as Effect from "effect/Effect"
 import * as Option from "effect/Option"
+import type { Thread } from "../Thread.ts"
 import { append } from "./append.ts"
-import { Strand } from "./Strand.ts"
+import { Self } from "./Self.ts"
+import { toolkit } from "./toolkit.ts"
 
-/** Infer an assistant message and append it to the conversation. */
-export const assistant: Effect.Effect<string, AiError, AiLanguageModel | Strand> = Effect.gen(function*() {
+/** 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 { system, messages, tools } = yield* Strand
+  const { state: { system, messages: prompt } } = yield* Self
   let { text, results } = yield* model.generateText({
     system: Option.getOrUndefined(system),
-    prompt: messages,
-    toolkit: AiToolkit.merge(...tools) as never,
+    prompt,
+    toolkit,
   })
   // TODO: this shouldn't be necessary. Bug in Effect AI?
   if (!text.trim()) {
     text = results.values().next().value?.result as never as string
   }
   yield* append(
-    new AssistantMessage({
-      parts: [new TextPart({ text })],
+    AssistantMessage.make({
+      parts: [TextPart.make({ text })],
     }),
   )
   return text

package/{assistantSchema.ts → L/assistantSchema.ts}

@@ -5,21 +5,22 @@ import * as Effect from "effect/Effect"
 import * as Option from "effect/Option"
 import * as Schema from "effect/Schema"
 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 { Strand } from "./Strand.ts"
-import { encodeJsonc, type JsonValue } from "./util/JsonValue.ts"
+import { Self } from "./Self.ts"
 
 /** Infer a structured assistant message and append its JSON representation to the conversation. */
 export const assistantSchema: {
   <F extends Record<string, Schema.Schema.AnyNoContext>>(
     fields: F,
-  ): Effect.Effect<{ [K in keyof F]: Schema.Schema.Type<F[K]> }, AiError, AiLanguageModel | Strand>
+  ): Effect.Effect<{ [K in keyof F]: Schema.Schema.Type<F[K]> }, AiError, AiLanguageModel | Thread>
   <O, I extends JsonValue>(
     schema: Schema.Schema<O, I, never>,
-  ): Effect.Effect<O, AiError, AiLanguageModel | Strand>
+  ): Effect.Effect<O, AiError, AiLanguageModel | Thread>
 } = Effect.fnUntraced(function*(schema) {
   const model = yield* AiLanguageModel
-  const { system, messages } = yield* Strand
+  const { state: { system, messages } } = yield* Self
 
   const isSchema = Schema.isSchema(schema)
   const schema_ = isSchema ? schema : Schema.Struct(schema) as Schema.Schema.AnyNoContext
@@ -35,9 +36,9 @@ export const assistantSchema: {
   )
 
   yield* append(
-    new AssistantMessage({
+    AssistantMessage.make({
       parts: [
-        new TextPart({
+        TextPart.make({
           text: yield* encodeJsonc(schema_)(value),
         }),
       ],

package/{assistantStream.ts → L/assistantStream.ts}

@@ -1,25 +1,22 @@
 import type { AiError } from "@effect/ai/AiError"
 import { AiLanguageModel } from "@effect/ai/AiLanguageModel"
 import type { AiResponse } from "@effect/ai/AiResponse"
-import * as AiToolkit from "@effect/ai/AiToolkit"
 import * as Effect from "effect/Effect"
 import * as Option from "effect/Option"
 import * as Stream from "effect/Stream"
-import { Strand } from "./Strand"
+import type { Thread } from "../Thread.ts"
+import { Self } from "./Self.ts"
+import { toolkit } from "./toolkit.ts"
 
-/** Get a streamed inference from the assistant without appending it to the strand's messages. */
-export const assistantStream: Stream.Stream<
-  AiResponse,
-  AiError,
-  AiLanguageModel | Strand
-> = Stream.unwrap(
+/** 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 { system, messages, tools } = yield* Strand
+    const { state: { system, messages: prompt } } = yield* Self
     return model.streamText({
       system: Option.getOrUndefined(system),
-      prompt: messages,
-      toolkit: AiToolkit.merge(...tools) as never,
+      prompt,
+      toolkit,
     })
   }),
 )

package/L/branch.ts

@@ -0,0 +1,33 @@
+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"
+
+export interface branch extends Sequencer<never, Thread>, Effect.Effect<Thread, never, Thread> {}
+
+const branch_ = Effect.gen(function*() {
+  const parent = yield* Self
+  return Thread({
+    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

@@ -0,0 +1,14 @@
+import type { Message } from "@effect/ai/AiInput"
+import * as Effect from "effect/Effect"
+import { MessagesCleared } from "../LEvent.ts"
+import type { Thread } from "../Thread.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 cleared = state.messages
+  state.messages = []
+  yield* events.publish(MessagesCleared.make({ cleared }))
+  return cleared
+})

package/L/disable.ts

@@ -0,0 +1,13 @@
+import * as AiTool from "@effect/ai/AiTool"
+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"
+
+export const disable = (tool: AiTool.Any): Effect.Effect<void, never, Thread> =>
+  Effect.map(Self, ({ tools }) => {
+    if (Option.isSome(tools)) {
+      tools.value.delete(tool as NeverTool)
+    }
+  })

package/L/enable.ts

@@ -0,0 +1,24 @@
+import type { AiTool, AnyStructSchema, Handler } from "@effect/ai/AiTool"
+import * as Effect from "effect/Effect"
+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"
+
+export const enable = <
+  K extends string,
+  E extends Schema.All,
+  R,
+>(
+  tool: AiTool<K, AnyStructSchema, Schema.Any, E, R>,
+): Effect.Effect<void, E, Handler<K> | Thread | R> =>
+  Effect.map(Self, (thread) => {
+    const tool_: NeverTool = tool as never
+    Option.match(thread.tools, {
+      onSome: (value) => value.add(tool_),
+      onNone: () => {
+        thread.tools = Option.some(new Set([tool_]))
+      },
+    })
+  })

package/L/events.ts

@@ -0,0 +1,11 @@
+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"
+
+/** A stream of thread events. */
+export const events: Stream.Stream<LEvent, never, Thread> = Self.pipe(
+  Effect.map(({ events }) => Stream.fromPubSub(events)),
+  Stream.unwrap,
+)

package/L/fqn.ts

@@ -0,0 +1,9 @@
+import * as Effect from "effect/Effect"
+import * as Option from "effect/Option"
+import { type Thread, ThreadFqn } from "../Thread.ts"
+import { Self } from "./Self.ts"
+
+export const fqn = (id: string): Effect.Effect<void, never, Thread> =>
+  Effect.map(Self, (thread) => {
+    thread.state.fqn = Option.some(ThreadFqn.make(id))
+  })

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

@@ -2,15 +2,16 @@ import * as Effect from "effect/Effect"
 import type { RuntimeFiber } from "effect/Fiber"
 import * as Scope from "effect/Scope"
 import * as Stream from "effect/Stream"
-import type { LEvent } from "./LEvent.ts"
-import { Strand } from "./Strand.ts"
+import type { LEvent } from "../LEvent.ts"
+import type { Thread } from "../Thread.ts"
+import { Self } from "./Self.ts"
 
-/** Attach an event handler to process the events of the current strand. */
+/** 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, Strand | R | Scope.Scope> = Effect.fnUntraced(function*(f) {
+) => Effect.Effect<RuntimeFiber<void, E>, never, Thread | R | Scope.Scope> = Effect.fnUntraced(function*(f) {
   const latch = yield* Effect.makeLatch(false)
-  const { events } = yield* Strand
+  const { events } = yield* Self
   const dequeue = yield* events.subscribe
   const fiber = yield* latch.open.pipe(
     Effect.zipRight(

package/L/messages.ts

@@ -0,0 +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"
+
+/** Get a copy of the current list of messages. */
+export const messages: Effect.Effect<Array<Message>, never, Thread> = Effect.map(
+  Self,
+  ({ state: { messages: [...messages] } }) => messages,
+)

package/L/raw.ts

@@ -0,0 +1,30 @@
+import * as Effect from "effect/Effect"
+import { normalizeRaw } from "../util/normalizeRaw.ts"
+import type { TaggableArg0 } from "../util/Taggable.ts"
+
+export const raw: <
+  A0 extends TaggableArg0 | Effect.Effect<string | undefined, any, any>,
+  L extends Array<unknown>,
+>(
+  a0: A0,
+  ...aRest: L
+) => Effect.Effect<
+  string | (undefined extends A0 ? undefined : never)
+> = Effect.fnUntraced(function*(a0, ...aRest) {
+  const a0_: TaggableArg0 = Effect.isEffect(a0)
+    ? yield* a0 as Effect.Effect<TaggableArg0>
+    : a0
+  if (!a0_) return undefined as never
+  const aRest_ = yield* Effect.all(
+    aRest.map((v) =>
+      Effect.isEffect(v)
+        ? v
+        : Effect.succeed(v)
+    ),
+  ) as never as Effect.Effect<Array<unknown>>
+  return typeof a0_ === "string"
+    ? aRest_.length === 0
+      ? a0_
+      : [a0_, ...aRest_].join("")
+    : normalizeRaw(a0_, aRest_)
+})

package/{sequence.ts → L/sequence.ts}

@@ -1,7 +1,7 @@
 import * as Effect from "effect/Effect"
-import type { Sequence } from "./util/Sequence"
+import type { Sequencer } from "../util/Sequencer.ts"
 
-export const sequence: Sequence = (...steps) =>
+export const sequence: Sequencer = (...steps) =>
   Effect.all(steps, {
     concurrency: 1,
   }).pipe(

package/L/system.ts

@@ -0,0 +1,14 @@
+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"
+
+/** Set the thread's system instruction. */
+export const system: Taggable<Option.Option<string>, never, Thread> = Effect.fnUntraced(function*(a0, ...aRest) {
+  const { state } = yield* Self
+  const { system } = state
+  state.system = a0 ? Option.some(yield* raw(a0, ...aRest)) : Option.none()
+  return system
+})

package/L/thread.ts

@@ -0,0 +1,28 @@
+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"
+
+export interface thread extends Sequencer<Thread>, Effect.Effect<Thread> {}
+
+const thread_ = Effect.gen(function*() {
+  return Thread({
+    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/to.ts

@@ -0,0 +1,4 @@
+import { Envelope } from "../Envelope.ts"
+import type { Thread } from "../Thread.ts"
+
+export const to = (...to: Array<Thread>): Envelope => Envelope({ to })

package/L/toolkit.ts

@@ -0,0 +1,14 @@
+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"
+
+export const toolkit = Self.pipe(
+  Effect.flatMap(({ tools }) =>
+    Option.match(tools, {
+      onSome: (tools) => AiToolkit.make(...tools),
+      onNone: () => AiToolkit.make<ReadonlyArray<NeverTool>>(),
+    })
+  ),
+)

package/{user.test.ts → L/user.test.ts}

@@ -2,7 +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 { strand } from "./strand_.ts"
+import { thread } from "./thread.ts"
 import { user } from "./user.ts"
 
 it.effect("test success", () =>
@@ -26,5 +26,5 @@ it.effect("test success", () =>
       }),
     ])
   }).pipe(
-    strand,
+    thread,
   ))

package/{user.ts → L/user.ts}

@@ -1,12 +1,13 @@
 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 { append } from "./append.ts"
-import type { Strand } from "./Strand.ts"
-import { normalize, type Taggable } from "./util/Taggable.ts"
+import { raw } from "./raw.ts"
 
 /** Append a user message to the conversation. */
-export const user: Taggable<void, never, Strand> = (a0, ...aRest) =>
-  normalize(a0, aRest).pipe(
+export const user: Taggable<void, never, Thread> = (a0, ...aRest) =>
+  raw(a0, ...aRest).pipe(
     Effect.flatMap((text) =>
       text
         ? append(

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

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

package/LEvent.ts

@@ -3,12 +3,12 @@ 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 current strand's message list. */
+/** An event in which one or more messages were added to the thread. */
 export class MessagesAppended extends Schema.TaggedClass<MessagesAppended>("MessagesAppended")("MessagesAppended", {
   messages: Messages,
 }) {}
 
-/** An event in which the current strand's message list is cleared. */
+/** An event in which the thread is cleared of messages. */
 export class MessagesCleared extends Schema.TaggedClass<MessagesCleared>("MessagesCleared")("MessagesCleared", {
   cleared: Messages,
 }) {}

package/Thread.ts

@@ -0,0 +1,69 @@
+import { Message } from "@effect/ai/AiInput"
+import * as Effect from "effect/Effect"
+import * as Option from "effect/Option"
+import { type Pipeable, pipeArguments } from "effect/Pipeable"
+import * as PubSub from "effect/PubSub"
+import * as Schema from "effect/Schema"
+import type { Mutable } from "effect/Types"
+import { Self } from "./L/Self.ts"
+import { sequence } from "./L/sequence.ts"
+import type { LEvent } from "./LEvent.ts"
+import type { NeverTool } from "./util/NeverTool.ts"
+import { prefix } from "./util/prefix.ts"
+import type { Sequencer } from "./util/Sequencer.ts"
+
+export const ThreadFqnTypeId: unique symbol = Symbol.for(prefix("ThreadFqn"))
+export const ThreadFqn = Schema.String.pipe(Schema.brand(ThreadFqnTypeId))
+export type ThreadFqn = typeof ThreadFqn["Type"]
+
+export class ThreadState extends Schema.Class<ThreadState>(prefix("ThreadState"))({
+  /** The key with which the thread is referenced by others. */
+  fqn: Schema.Option(ThreadFqn),
+  /** The system prompt to be passed along to the model. */
+  system: Schema.Option(Schema.String),
+  /** The messages based off of which the model infers the next message. */
+  messages: Schema.Array(Message).pipe(Schema.mutable),
+}) {
+  static default = (): ThreadState =>
+    ThreadState.make({
+      fqn: Option.none(),
+      system: Option.none(),
+      messages: [],
+    })
+}
+
+export interface ThreadInit {
+  /** The parent thread. */
+  parent: Option.Option<Thread>
+  /** The pubsub with which thread-specific events are emitted. */
+  events: PubSub.PubSub<LEvent>
+  /** The state of the current thread. */
+  state: Mutable<ThreadState>
+  /** The tools to be made accessible to the model. */
+  tools: Option.Option<Set<NeverTool>>
+}
+
+export const ThreadTypeId: unique symbol = Symbol.for(prefix("Thread"))
+export type ThreadTypeId = typeof ThreadTypeId
+
+interface ThreadMembers extends ThreadInit, Pipeable {
+  readonly [ThreadTypeId]: ThreadTypeId
+}
+
+/** A conversation isolate. */
+export interface Thread extends Sequencer<Thread>, ThreadMembers {}
+
+export const Thread = (init: ThreadInit): Thread => {
+  const members = {
+    [ThreadTypeId]: ThreadTypeId,
+    ...init,
+    pipe() {
+      return pipeArguments(self, arguments)
+    },
+  } satisfies ThreadMembers
+  const self = Object.assign(
+    ((...args) => sequence(...args).pipe(Effect.provideService(Self, self))) satisfies Sequencer<Thread>,
+    members,
+  ) as Thread
+  return self
+}

package/dist/Envelope.d.ts

@@ -0,0 +1,15 @@
+import type { Thread } from "./Thread.ts";
+import { type Taggable } from "./util/Taggable.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 {
+}
+export declare const Envelope: (headers: MessageHeaders) => Envelope;