liminal 0.15.0 → 0.17.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # 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
+
+- 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

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

@@ -0,0 +1,16 @@
+import { Thread } from "./Thread.ts"
+
+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.ts → L/L.ts}

@@ -4,12 +4,17 @@ 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 "./handle.ts"
+export * from "./line.ts"
+export * from "./listen.ts"
 export * from "./messages.ts"
-export * from "./sequence.ts"
-export * from "./strand_.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 "./toolkit.ts"
 export * from "./user.ts"
-export * from "./userJson.ts"

package/L/append.ts

@@ -0,0 +1,14 @@
+import type { Message } from "@effect/ai/AiInput"
+import * as Effect from "effect/Effect"
+import { MessagesAppendedEvent } 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(MessagesAppendedEvent.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.make(...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.make(...tools),
+      prompt,
+      toolkit,
     })
   }),
 )

package/L/branch.ts

@@ -0,0 +1,20 @@
+import * as Effect from "effect/Effect"
+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 { self } from "./self.ts"
+
+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({
+      system: parent.state.system,
+      messages: [...parent.state.messages ?? []],
+    }),
+    tools: parent.tools.pipe(Option.map((v) => new Set(v))),
+  })
+})

package/L/clear.ts

@@ -0,0 +1,14 @@
+import type { Message } from "@effect/ai/AiInput"
+import * as Effect from "effect/Effect"
+import { ThreadClearedEvent } 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(ThreadClearedEvent.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/json.ts

@@ -0,0 +1,12 @@
+import * as Effect from "effect/Effect"
+import type * as Schema from "effect/Schema"
+import { encodeJsonc, type JsonValue } from "../util/JsonValue.ts"
+
+/** Stringify and append some JSON as a user message to the conversation. */
+export const json: <A, I extends JsonValue>(
+  value: A,
+  schema?: Schema.Schema<A, I>,
+) => Effect.Effect<string> = Effect.fnUntraced(function*(value, schema) {
+  const encoded = schema ? encodeJsonc(schema)(value) : JSON.stringify(value, null, 2)
+  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/{handle.ts → L/listen.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/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

@@ -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/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

@@ -0,0 +1,25 @@
+import * as Effect from "effect/Effect"
+import * as Option from "effect/Option"
+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 = 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* normalize(a0, ...aRest)) : Option.none()
+  yield* events.publish(new SystemSetEvent({ system: state.system }))
+  return system
+})

package/L/thread.ts

@@ -0,0 +1,16 @@
+import * as Effect from "effect/Effect"
+import * as Option from "effect/Option"
+import * as PubSub from "effect/PubSub"
+import type { LEvent } from "../LEvent.ts"
+import { Thread, ThreadId, ThreadState } from "../Thread.ts"
+import { self } from "./self.ts"
+
+export const thread: Effect.Effect<Thread> = Effect.gen(function*() {
+  return Thread({
+    id: ThreadId.make(crypto.randomUUID()),
+    parent: yield* Effect.serviceOption(self),
+    events: yield* PubSub.unbounded<LEvent>(),
+    state: ThreadState.default(),
+    tools: Option.none(),
+  })
+})

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

package/L/user.ts

@@ -0,0 +1,32 @@
+import { TextPart, UserMessage } from "@effect/ai/AiInput"
+import * as Effect from "effect/Effect"
+import type { Thread } from "../Thread.ts"
+import type { ExtractE, ExtractR } from "../util/extract.ts"
+import { normalize, type TaggableArg0, type TaggableArgRest } from "../util/Taggable.ts"
+import { append } from "./append.ts"
+
+/** 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(
+          UserMessage.make({
+            parts: [
+              TextPart.make({ text }),
+            ],
+          }),
+        )
+        : Effect.succeed(undefined)
+    ),
+  )

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 current strand's message list. */
-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 current strand's message list is cleared. */
-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)