liminal 0.16.0 → 0.17.1

package/errors.ts

@@ -0,0 +1,14 @@
+import { Schema as S } from "effect"
+
+export class AuditionError extends S.TaggedError<AuditionError>()("AuditionError", {
+  value: S.Struct({
+    actual: S.String,
+    expected: S.String,
+  }).pipe(S.optional),
+}) {}
+
+export class ConnectionError extends S.TaggedError<ConnectionError>()("ConnectionError", {
+  cause: S.Unknown,
+}) {}
+
+export type ClientError = AuditionError | ConnectionError

package/experimental/BranchLive.ts

@@ -0,0 +1,6 @@
+import { Chat } from "@effect/ai"
+import { Effect, Layer } from "effect"
+
+import { history } from "./L/history.ts"
+
+export const BranchLive = Layer.effect(Chat.Chat, history.pipe(Effect.flatMap(Chat.fromPrompt)))

package/experimental/L/L.ts

@@ -0,0 +1,11 @@
+export * from "./append.ts"
+export * from "./assistant.ts"
+export * from "./assistantSchema.ts"
+export * from "./assistantStream.ts"
+export * from "./branch.ts"
+export * from "./clear.ts"
+export * from "./history.ts"
+export * from "./init.ts"
+export * from "./matrix.ts"
+export * from "./system.ts"
+export * from "./user.ts"

package/experimental/L/append.ts

@@ -0,0 +1,12 @@
+import { Prompt, Chat } from "@effect/ai"
+import { Effect, flow, Ref } from "effect"
+
+export const append = (message: Prompt.Message) =>
+  Chat.Chat.pipe(
+    Effect.flatMap(
+      flow(
+        ({ history }) => history,
+        Ref.update(({ content }) => Prompt.fromMessages([...content, message])),
+      ),
+    ),
+  )

package/experimental/L/assistant.ts

@@ -0,0 +1,16 @@
+import { Prompt, LanguageModel } from "@effect/ai"
+import { Effect } from "effect"
+
+import { append } from "./append.ts"
+import { history } from "./history.ts"
+
+export const assistant = Effect.gen(function* () {
+  const prompt = yield* history
+  const { text } = yield* LanguageModel.generateText({ prompt })
+  yield* append(
+    Prompt.assistantMessage({
+      content: [Prompt.textPart({ text })],
+    }),
+  )
+  return text
+})

package/experimental/L/assistantSchema.ts

@@ -0,0 +1,18 @@
+import { Prompt, LanguageModel } from "@effect/ai"
+import { Effect, Schema as S } from "effect"
+
+import { append } from "./append.ts"
+import { history } from "./history.ts"
+
+export const assistantSchema = Effect.fnUntraced(function* <A, I extends Record<string, unknown>, R>(
+  schema: S.Schema<A, I, R>,
+) {
+  const prompt = yield* history
+  const { text, value } = yield* LanguageModel.generateObject({ prompt, schema })
+  yield* append(
+    Prompt.assistantMessage({
+      content: [Prompt.textPart({ text })],
+    }),
+  )
+  return value
+})

package/experimental/L/assistantStream.ts

@@ -0,0 +1,9 @@
+import { LanguageModel } from "@effect/ai"
+import { Effect, Stream } from "effect"
+
+import { history } from "./history.ts"
+
+export const assistantStream = history.pipe(
+  Effect.map((prompt) => LanguageModel.streamText({ prompt })),
+  Stream.unwrap,
+)

package/experimental/L/branch.ts

@@ -0,0 +1,5 @@
+import { Effect } from "effect"
+
+import { BranchLive } from "../BranchLive.ts"
+
+export const branch = Effect.provide(BranchLive)

package/experimental/L/clear.ts

@@ -0,0 +1,7 @@
+import { Chat, Prompt } from "@effect/ai"
+import { Ref, Effect } from "effect"
+
+export const clear = Effect.gen(function* () {
+  const { history } = yield* Chat.Chat
+  yield* Ref.update(history, () => Prompt.empty)
+})

package/experimental/L/history.ts

@@ -0,0 +1,4 @@
+import { Chat } from "@effect/ai"
+import { flow, Effect, Ref } from "effect"
+
+export const history = Chat.Chat.pipe(Effect.flatMap(flow(({ history }) => history, Ref.get)))

package/experimental/L/init.ts

@@ -0,0 +1,4 @@
+import { Chat } from "@effect/ai"
+import { Effect } from "effect"
+
+export const init = Effect.provideServiceEffect(Chat.Chat, Chat.empty)

package/experimental/L/matrix.ts

@@ -0,0 +1,26 @@
+import { Effect, Function, Layer } from "effect"
+
+import { branch } from "./branch.ts"
+
+type LayerRecord = Record<string, Layer.Layer.Any>
+
+export type MatrixEffect<A, E, R, Layers extends LayerRecord> = Effect.Effect<
+  {
+    readonly [K in keyof Layers]: A
+  },
+  E | Layer.Layer.Error<Layers[keyof Layers]>,
+  R | Layer.Layer.Context<Layers[keyof Layers]>
+>
+
+export const matrix: {
+  <Layers extends LayerRecord>(
+    layers: Layers,
+  ): <A, E, R>(effect: Effect.Effect<A, E, R>) => MatrixEffect<A, E, R, Layers>
+  <Layers extends LayerRecord, A, E, R>(effect: Effect.Effect<A, E, R>, layers: Layers): MatrixEffect<A, E, R, Layers>
+} = Function.dual(2, <Layers extends LayerRecord, A, E, R>(effect: Effect.Effect<A, E, R>, layers: Layers) => {
+  return Effect.all(
+    Object.fromEntries(
+      Object.entries(layers).map(([key, Live]) => [key, effect.pipe(branch, Effect.provide(Live as never))]),
+    ),
+  )
+})

package/experimental/L/system.ts

@@ -0,0 +1,5 @@
+import { Prompt } from "@effect/ai"
+
+import { append } from "./append.ts"
+
+export const system = (text: string) => append(Prompt.systemMessage({ content: text }))

package/experimental/L/user.ts

@@ -0,0 +1,10 @@
+import { Prompt } from "@effect/ai"
+
+import { append } from "./append.ts"
+
+export const user = (text: string) =>
+  append(
+    Prompt.userMessage({
+      content: [Prompt.textPart({ text })],
+    }),
+  )

package/experimental/Loader.ts

@@ -0,0 +1,35 @@
+import { Path, FileSystem } from "@effect/platform"
+import { Option, Layer, Effect, Data, Context } from "effect"
+
+export class LoaderError extends Data.TaggedError("LoaderError")<{
+  readonly url: string
+}> {}
+
+export class Loader extends Context.Tag("liminal/Loader")<
+  Loader,
+  {
+    readonly load: (key: string) => Effect.Effect<Option.Option<string>, LoaderError>
+  }
+>() {}
+
+export const layerFs = Layer.effect(
+  Loader,
+  Effect.gen(function* () {
+    const path = yield* Path.Path
+    const fs = yield* FileSystem.FileSystem
+
+    const load = Effect.fnUntraced(function* (url: string) {
+      const { dir, name } = path.parse(new URL(url).pathname)
+      const templatePathname = path.join(dir, `${name}.md`)
+      if (yield* fs.exists(templatePathname).pipe(Effect.mapError(() => new LoaderError({ url })))) {
+        return yield* fs.readFileString(templatePathname).pipe(
+          Effect.map(Option.some),
+          Effect.mapError(() => new LoaderError({ url })),
+        )
+      }
+      return Option.none()
+    })
+
+    return { load }
+  }),
+)

package/experimental/TaggedTemplateFunction.ts

@@ -0,0 +1,44 @@
+import { Effect } from "effect"
+
+export type TemplateStringsArrayLike = {
+  raw: ReadonlyArray<string> | ArrayLike<string>
+}
+
+type ExtractE<T> = [Extract<T, Effect.Effect<any, any, any>>] extends [never]
+  ? never
+  : Effect.Effect.Error<Extract<T, Effect.Effect<any, any, any>>>
+
+type ExtractR<T> = [Extract<T, Effect.Effect<any, any, any>>] extends [never]
+  ? never
+  : Effect.Effect.Context<Extract<T, Effect.Effect<any, any, any>>>
+
+export const raw = Effect.fnUntraced(function* <Substitutions extends Array<unknown>>(
+  template: TemplateStringsArrayLike,
+  ...substitutions: Substitutions
+): Effect.fn.Return<string, ExtractE<Substitutions[number]>, ExtractR<Substitutions[number]>> {
+  return String.raw(
+    template,
+    ...(yield* Effect.all(substitutions.map((v) => (Effect.isEffect(v) ? v : Effect.succeed(v)))) as Effect.Effect<
+      Array<string>,
+      ExtractE<Substitutions[number]>,
+      ExtractR<Substitutions[number]>
+    >),
+  )
+})
+
+export type TaggableHead = TemplateStringsArrayLike | string | Effect.Effect<string, any, any>
+
+export type TaggableRest<H extends TaggableHead> = H extends TemplateStringsArrayLike ? Array<unknown> : []
+
+export const normalize = Effect.fnUntraced(function* <H extends TaggableHead, ARest extends TaggableRest<H>>(
+  a0: H,
+  ...aRest: ARest
+): Effect.fn.Return<string, ExtractE<H | ARest[number]>, ExtractR<H | ARest[number]>> {
+  if (Effect.isEffect(a0)) {
+    return yield* a0
+  }
+  if (typeof a0 === "string") {
+    return a0
+  }
+  return yield* raw(a0, ...aRest)
+})

package/experimental/Template.ts

@@ -0,0 +1,93 @@
+import { Option, Types, Layer, pipe, String, Effect, Schema as S, Data, SchemaAST, Context } from "effect"
+
+import * as Loader from "./Loader.ts"
+
+export type Template<A> = (...[value]: A extends undefined ? [] : [value: A]) => string
+
+export class TemplateMisalignedError extends Data.TaggedError("TemplateMisalignedError")<{
+  readonly url: string
+  readonly keys: ReadonlyArray<string>
+}> {}
+
+export class NoSuchTemplateError extends Data.TaggedError("NoSuchTemplateError")<{ url: string }> {}
+
+export interface TemplateClass<Self, Id extends string, A> extends Context.Tag<Self, Template<A>> {
+  new (_: never): Context.TagClassShape<Id, Template<A>>
+
+  readonly layer: Layer.Layer<Self, NoSuchTemplateError | TemplateMisalignedError | Loader.LoaderError, Loader.Loader>
+
+  readonly synthesize: (...[value]: A extends undefined ? [] : [value: A]) => Effect.Effect<string, never, Self>
+}
+
+export type Payload = Record<string, S.Schema<any, string> | S.optional<S.Schema<any, string>>>
+
+export declare namespace Payload {
+  export type FromDefinition<P extends Payload | undefined> = P extends infer Q extends Payload
+    ? S.Struct<Q>["Type"]
+    : {}
+}
+
+export const Service =
+  <Self>() =>
+  <const Id extends string, const P extends Payload | undefined>(
+    id: Id,
+    {
+      url,
+      payload,
+    }: {
+      readonly url: string
+      readonly payload?: P | undefined
+    },
+  ): TemplateClass<Self, Id, Payload.FromDefinition<P>> => {
+    type Make_ = Template<Payload.FromDefinition<P>>
+    type Self_ = TemplateClass<Self, Id, Payload.FromDefinition<P>>
+    const self = Context.Tag(`liminal/Template/${id}`)<Self, Make_>() as never as Types.Mutable<Self_>
+    self.layer = Effect.gen(function* () {
+      const loader = yield* Loader.Loader
+      const template = yield* loader.load(url).pipe(Effect.map(Option.getOrUndefined))
+      if (!template) {
+        return yield* new NoSuchTemplateError({ url })
+      }
+      const [head, ...rest] = pipe(template, String.trim, String.split("{{"))
+      if ((!payload || !Object.keys(payload).length) && !rest.length) {
+        return () => template
+      }
+      const segments = rest.flatMap((part) => {
+        const i = part.indexOf("}}")
+        if (i === -1) {
+          return []
+        }
+        return {
+          key: part.slice(0, i).trim(),
+          tail: part.slice(i + 2),
+        }
+      })
+      const keys = segments.map(({ key }) => key)
+      if (payload) {
+        const keys_ = new Set(keys)
+        const dne = new Set<string>()
+        const schema = S.Struct(payload)
+        const fields = SchemaAST.getPropertySignatures(SchemaAST.encodedBoundAST(schema.ast))
+        for (const field of fields) {
+          if (!field.isOptional && !keys_.has(field.name.toString())) {
+            dne.add(field.name.toString())
+          }
+        }
+        if (dne.size) {
+          return yield* new TemplateMisalignedError({
+            url,
+            keys: [...dne.values()],
+          })
+        }
+      } else if (segments.length) {
+        return yield* new TemplateMisalignedError({ url, keys })
+      }
+      const make: Make_ = (value?) =>
+        value
+          ? head + segments.map(({ key, tail }) => `${(value as Record<typeof key, string>)[key]}${tail}`).join("")
+          : template
+      return make
+    }).pipe(Layer.effect(self))
+    self.synthesize = (...args) => self.pipe(Effect.map((make) => make(...args)))
+    return self as Self_
+  }

package/experimental/index.ts

@@ -0,0 +1,4 @@
+export * as L from "./L/L.ts"
+export * as Loader from "./Loader.ts"
+export * as Template from "./Template.ts"
+export * from "./BranchLive.ts"

package/index.ts

@@ -1,5 +1,9 @@
-export * from "./Envelope.ts"
-export * as default from "./L/L.ts"
-export * from "./LEvent.ts"
-export * as LPretty from "./LPretty.ts"
-export * from "./Thread.ts"
+export * as Accumulator from "./Accumulator.ts"
+export * as Actor from "./Actor.ts"
+export * as Audition from "./Audition.ts"
+export * as Client from "./Client.ts"
+export * as ClientHandle from "./ClientHandle.ts"
+export * as Method from "./Method.ts"
+export * as Protocol from "./Protocol.ts"
+export * from "./F.ts"
+export * from "./errors.ts"

package/package.json

@@ -1,31 +1,34 @@
 {
   "name": "liminal",
-  "version": "0.16.0",
+  "version": "0.17.1",
+  "description": "Actors x Effects",
+  "bugs": {
+    "url": "https://github.com/crosshatch/liminal/issues"
+  },
+  "license": "Apache-2.0",
   "repository": {
     "type": "git",
-    "url": "https://github.com/harrysolovay/liminal.git",
+    "url": "https://github.com/crosshatch/liminal.git",
     "directory": "liminal"
   },
-  "peerDependencies": {
-    "@effect/ai": "^0.25.2",
-    "effect": "^3.17.7"
-  },
+  "type": "module",
+  "sideEffects": false,
   "exports": {
-    ".": "./index.ts",
-    "./package.json": "./package.json",
-    "./patterns/Route": "./patterns/Route.ts",
-    "./patterns/Model": "./patterns/Model.ts",
-    "./patterns/Debate": "./patterns/Debate.ts"
+    ".": {
+      "types": "./index.ts",
+      "default": "./dist/index.js"
+    },
+    "./*": {
+      "types": "./*.ts",
+      "default": "./dist/*.js"
+    },
+    "./package.json": "./package.json"
   },
-  "description": "An Effect AI toolkit for conversation state management.",
-  "homepage": "https://liminal.land",
-  "license": "Apache-2.0",
-  "llms": "https://liminal.land/llms.txt",
-  "llmsFull": "https://liminal.land/llmsFull.txt",
-  "publishConfig": {
-    "access": "public",
-    "provenance": true
-  },
-  "sideEffects": false,
-  "type": "module"
-}
+  "peerDependencies": {
+    "@effect-atom/atom": "^0.5.2",
+    "@effect/ai": "^0.33.2",
+    "@effect/experimental": "^0.58.0",
+    "@effect/platform": "^0.94.5",
+    "effect": "^3.19.17"
+  }
+}

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../tsconfig.base",
+  "compilerOptions": {
+    "noEmit": false,
+    "outDir": "dist"
+  },
+  "include": ["."],
+  "exclude": ["dist"]
+}

package/Envelope.ts

@@ -1,48 +0,0 @@
-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/L.ts

@@ -1,21 +0,0 @@
-export * from "./append.ts"
-export * from "./assistant.ts"
-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 "./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

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

@@ -1,14 +0,0 @@
-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/L/assistant.ts

@@ -1,30 +0,0 @@
-import type { AiError } from "@effect/ai/AiError"
-import { AssistantMessage, TextPart } from "@effect/ai/AiInput"
-import { AiLanguageModel } from "@effect/ai/AiLanguageModel"
-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 { 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
-  let { text, results } = yield* model.generateText({
-    system: Option.getOrUndefined(system),
-    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(
-    AssistantMessage.make({
-      parts: [TextPart.make({ text })],
-    }),
-  )
-  return text
-})

package/L/assistantSchema.ts

@@ -1,61 +0,0 @@
-import type { AiError } from "@effect/ai/AiError"
-import { AssistantMessage, TextPart } from "@effect/ai/AiInput"
-import { AiLanguageModel } from "@effect/ai/AiLanguageModel"
-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 { 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 | Thread>
-  <O, I extends JsonValue>(
-    schema: Schema.Schema<O, I, never>,
-  ): Effect.Effect<O, AiError, AiLanguageModel | Thread>
-} = Effect.fnUntraced(function*(schema) {
-  const model = yield* AiLanguageModel
-  const { state: { system, messages } } = yield* Self
-
-  const isSchema = Schema.isSchema(schema)
-  const schema_ = isSchema ? schema : Schema.Struct(schema) as Schema.Schema.AnyNoContext
-  const isObject = !isSchema || isObjectSchema(SchemaAST.encodedAST(schema.ast))
-  const wrapped = isObject ? schema_ : Schema.Struct({ inner: schema_ })
-
-  const value = yield* model.generateObject({
-    system: Option.getOrUndefined(system),
-    schema: wrapped,
-    prompt: messages,
-  }).pipe(
-    Effect.map(({ value }) => isObject ? value : value["inner"]),
-  )
-
-  yield* append(
-    AssistantMessage.make({
-      parts: [
-        TextPart.make({
-          text: yield* encodeJsonc(schema_)(value),
-        }),
-      ],
-    }),
-  )
-  return value
-})
-
-const isObjectSchema = (ast: SchemaAST.AST): boolean => {
-  switch (ast._tag) {
-    case "TypeLiteral": {
-      return true
-    }
-    case "Refinement":
-    case "Transformation": {
-      return isObjectSchema(ast.from)
-    }
-  }
-  return false
-}

package/L/assistantStream.ts

@@ -1,22 +0,0 @@
-import type { AiError } from "@effect/ai/AiError"
-import { AiLanguageModel } from "@effect/ai/AiLanguageModel"
-import type { AiResponse } from "@effect/ai/AiResponse"
-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 { 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
-    return model.streamText({
-      system: Option.getOrUndefined(system),
-      prompt,
-      toolkit,
-    })
-  }),
-)