liminal 0.17.0 → 0.17.2

package/errors.ts

@@ -0,0 +1,22 @@
+import { Schema as S } from "effect"
+
+import type { MethodDefinition } from "./Method.ts"
+
+export class AuditionError extends S.TaggedErrorClass<AuditionError>()("AuditionError", {
+  value: S.Struct({
+    client: S.String,
+    routed: S.String,
+  }).pipe(S.optional),
+}) {}
+
+export class ConnectionError extends S.TaggedErrorClass<ConnectionError>()("ConnectionError", {
+  cause: S.Unknown,
+}) {}
+
+export type ClientError = AuditionError | ConnectionError
+
+export class UnresolvedError extends S.TaggedErrorClass<UnresolvedError>()("UnresolvedError", {}) {}
+
+export type FError<MethodDefinitions extends Record<string, MethodDefinition.Any>> = [
+  MethodDefinitions[keyof MethodDefinitions]["failure"]["Type"] | ClientError | UnresolvedError,
+][0]

package/experimental/BranchLive.ts

@@ -0,0 +1,6 @@
+import { Effect, Layer } from "effect"
+import { Chat } from "effect/unstable/ai"
+
+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 { Effect, flow, Ref } from "effect"
+import { Prompt, Chat } from "effect/unstable/ai"
+
+export const append = (message: Prompt.Message) =>
+  Chat.Chat.asEffect().pipe(
+    Effect.flatMap(
+      flow(
+        ({ history }) => history,
+        Ref.update(({ content }) => Prompt.fromMessages([...content, message])),
+      ),
+    ),
+  )

package/experimental/L/assistant.ts

@@ -0,0 +1,16 @@
+import { Effect } from "effect"
+import { Prompt, LanguageModel } from "effect/unstable/ai"
+
+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 { Effect, Schema as S } from "effect"
+import { Prompt, LanguageModel } from "effect/unstable/ai"
+
+import { append } from "./append.ts"
+import { history } from "./history.ts"
+
+export const assistantSchema = Effect.fnUntraced(function* <A, I extends Record<string, unknown>>(
+  schema: S.Codec<A, I>,
+) {
+  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 { Effect, Stream } from "effect"
+import { LanguageModel } from "effect/unstable/ai"
+
+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 { Ref, Effect } from "effect"
+import { Chat, Prompt } from "effect/unstable/ai"
+
+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 { flow, Effect, Ref } from "effect"
+import { Chat } from "effect/unstable/ai"
+
+export const history = Chat.Chat.asEffect().pipe(Effect.flatMap(flow(({ history }) => history, Ref.get)))

package/experimental/L/init.ts

@@ -0,0 +1,4 @@
+import { Effect } from "effect"
+import { Chat } from "effect/unstable/ai"
+
+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.Any>
+
+export type MatrixEffect<A, E, R, Layers extends LayerRecord> = Effect.Effect<
+  {
+    readonly [K in keyof Layers]: A
+  },
+  E | Layer.Error<Layers[keyof Layers]>,
+  R | Layer.Services<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/unstable/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/unstable/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"
+import { Option, Layer, Effect, Data, Context } from "effect"
+
+export class LoaderError extends Data.TaggedError("LoaderError")<{
+  readonly url: string
+}> {}
+
+export class Loader extends Context.Service<
+  Loader,
+  {
+    readonly load: (key: string) => Effect.Effect<Option.Option<string>, LoaderError>
+  }
+>()("liminal/Loader") {}
+
+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.Error<Extract<T, Effect.Effect<any, any, any>>>
+
+type ExtractR<T> = [Extract<T, Effect.Effect<any, any, any>>] extends [never]
+  ? never
+  : Effect.Services<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,85 @@
+import { Layer, Effect, Schema as S, Data, 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.Service<Self, Template<A>> {
+  new (_: never): Context.ServiceClass.Shape<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 const Service =
+  <Self>() =>
+  <const Id extends string, const P extends S.Struct.Fields>(
+    _id: Id,
+    _config: {
+      readonly url: string
+      readonly payload: P
+    },
+  ): TemplateClass<Self, Id, S.Struct<P>["Type"]> => {
+    throw 0
+  }
+
+// type Make_ = Template<Payload.FromDefinition<P>>
+// type Self_ = TemplateClass<Self, Id, Payload.FromDefinition<P>>
+// const tag = Context.Service<Self, Make_>()(id)
+// const 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)
+//     for (const field of schema.ast.propertySignatures) {
+//       if (!SchemaAST.isOptional(field.type) && !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(tag))
+
+// const synthesize = (...args) => tag.pipe(Effect.map((make) => make(...args)))
+
+// return Object.assign(tag, { synthesize })

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,7 +1,9 @@
-export * from "./Digest.ts"
-export * from "./Envelope.ts"
-export * as F from "./F/F.ts"
-export * as L from "./L/L.ts"
-export * from "./LEvent.ts"
-export * from "./Thread.ts"
-export * as messageCodec from "./util/messageCodec.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,43 +1,30 @@
 {
   "name": "liminal",
-  "version": "0.17.0",
+  "version": "0.17.2",
+  "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"
   },
+  "type": "module",
+  "sideEffects": false,
   "exports": {
     ".": {
-      "import": "./dist/index.js",
-      "bun": "./index.ts"
-    },
-    "./package.json": "./package.json",
-    "./patterns/Route": {
-      "import": "./dist/patterns/Route.js",
-      "bun": "./patterns/Route.ts"
+      "types": "./index.ts",
+      "default": "./dist/index.js"
     },
-    "./patterns/Model": {
-      "import": "./dist/patterns/Model.js",
-      "bun": "./patterns/Model.ts"
+    "./*": {
+      "types": "./*.ts",
+      "default": "./dist/*.js"
     },
-    "./patterns/Debate": {
-      "import": "./dist/patterns/Debate.js",
-      "bun": "./patterns/Debate.ts"
-    }
+    "./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/ai": "^0.25.2",
-    "effect": "^3.17.7"
+    "effect": "4.0.0-beta.50"
   }
-}
+}

package/tsconfig.json

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

package/Digest.ts

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

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

package/L/L.ts

@@ -1,20 +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 "./line.ts"
-export * from "./listen.ts"
-export * from "./messages.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"

package/L/append.ts

@@ -1,14 +0,0 @@
-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/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,
-    })
-  }),
-)