liminal 0.17.0 → 0.17.1

package/Accumulator.ts

@@ -0,0 +1,97 @@
+import { Deferred, Types, Option, Ref, PubSub, Stream, Effect, Context, Layer } from "effect"
+
+const TypeId = "~liminal/Accumulator" as const
+
+export interface Service<State> {
+  readonly ref: Ref.Ref<State>
+
+  readonly pubsub: PubSub.PubSub<State>
+}
+
+export interface AccumulatorLayerConfig<Item, E, R, State, E2, R2, E3, R3> {
+  readonly source: Stream.Stream<Item, E, R>
+
+  readonly reduce: (item: Item) => (state: State) => Effect.Effect<State, E2, R2>
+
+  readonly initial: (item: Item) => Effect.Effect<Option.Option<State>, E3, R3>
+}
+
+export type Reduce<State, Item, K extends Types.Tags<Item> = Types.Tags<Item>, E = never, R = never> = (
+  item: Types.ExtractTag<Item, K>,
+) => (accumulator: State) => Effect.Effect<State, E, R>
+
+export interface Accumulator<Self, Id extends string, State> extends Context.Tag<Self, Service<State>> {
+  new (_: never): Context.TagClassShape<Id, Service<State>>
+
+  readonly [TypeId]: typeof TypeId
+
+  readonly get: Effect.Effect<State, never, Self>
+
+  readonly stream: Stream.Stream<State, never, Self>
+
+  readonly reducer: <Item>() => <K extends Types.Tags<Item>, E, R>(
+    _tag: K,
+    f: Reduce<State, Item, K, E, R>,
+  ) => Reduce<State, Item, K, E, R>
+
+  readonly layer: <Item, E, R, E2, R2, E3, R3>(
+    config: AccumulatorLayerConfig<Item, E, R, State, E2, R2, E3, R3>,
+  ) => Layer.Layer<Self, E | E2 | E3, R | R2 | R3>
+}
+
+export const Service =
+  <Self, State>() =>
+  <Id extends string>(id: Id): Accumulator<Self, Id, State> => {
+    const tag = Context.Tag(id)<Self, Service<State>>()
+
+    const get = tag.pipe(
+      Effect.map(({ ref }) => ref),
+      Effect.flatMap(Ref.get),
+    )
+
+    const stream = tag.pipe(
+      Effect.map(({ pubsub }) => Stream.fromPubSub(pubsub)),
+      Stream.unwrap,
+    )
+
+    const reducer =
+      <Item>() =>
+      <K extends Types.Tags<Item>, E, R>(_tag: K, f: Reduce<State, Item, K, E, R>): Reduce<State, Item, K, E, R> =>
+        f
+
+    const layer = <Item, E, R, E2, R2, E3, R3>({
+      source,
+      initial,
+      reduce,
+    }: AccumulatorLayerConfig<Item, E, R, State, E2, R2, E3, R3>): Layer.Layer<Self, E | E2 | E3, R | R2 | R3> =>
+      Effect.gen(function* () {
+        const semaphore = yield* Effect.makeSemaphore(1)
+        const deferred = yield* Deferred.make<State>()
+        const pubsub = yield* PubSub.unbounded<State>({ replay: 1 })
+        yield* source.pipe(
+          Stream.runForEach(
+            Effect.fn(function* (item) {
+              if (!(yield* Deferred.isDone(deferred))) {
+                const match = yield* initial(item)
+                if (Option.isSome(match)) {
+                  const { value } = match
+                  yield* Deferred.succeed(deferred, value)
+                }
+                return
+              }
+              const current = yield* Ref.get(ref)
+              const reduced = yield* reduce(item)(current)
+              yield* Ref.set(ref, reduced)
+              yield* pubsub.publish(reduced)
+            }, semaphore.withPermits(1)),
+          ),
+          Effect.forkScoped,
+        )
+        const initial_ = yield* Deferred.await(deferred)
+        const ref = yield* Ref.make(initial_)
+        yield* pubsub.publish(initial_)
+        return { ref, pubsub }
+      }).pipe(Layer.scoped(tag))
+
+    return Object.assign(tag, { [TypeId]: TypeId, get, stream, reducer, layer })
+  }

package/Actor.ts

@@ -0,0 +1,118 @@
+import { Context, Schema as S, Effect } from "effect"
+
+import type { FieldsRecord, Fields } from "./_types.ts"
+import type * as ActorClient from "./Client.ts"
+import type * as ClientHandle from "./ClientHandle.ts"
+import type { MethodDefinition } from "./Method.ts"
+import * as Method from "./Method.ts"
+import type { Send } from "./Send.ts"
+
+export const TypeId = "~liminal/Actor" as const
+
+export interface Service<ActorSelf, NameA, AttachmentFields extends Fields, EventDefinitions extends FieldsRecord> {
+  readonly name: NameA
+
+  readonly currentClient: ClientHandle.ClientHandle<ActorSelf, AttachmentFields, EventDefinitions>
+
+  readonly clients: ReadonlySet<ClientHandle.ClientHandle<ActorSelf, AttachmentFields, EventDefinitions>>
+}
+
+export interface ActorDefinition<
+  NameA,
+  AttachmentFields extends Fields,
+  ClientSelf,
+  ClientId extends string,
+  MethodDefinitions extends Record<string, MethodDefinition.Any>,
+  EventDefinitions extends FieldsRecord,
+> {
+  readonly name: S.Schema<NameA, string>
+
+  readonly attachments: AttachmentFields
+
+  readonly client: ActorClient.Client<ClientSelf, ClientId, MethodDefinitions, EventDefinitions>
+}
+
+export interface Actor<
+  ActorSelf,
+  ActorId extends string,
+  NameA,
+  AttachmentFields extends Fields,
+  ActorClientSelf,
+  ActorClientId extends string,
+  MethodDefinitions extends Record<string, MethodDefinition.Any>,
+  EventDefinitions extends FieldsRecord,
+> extends Context.Tag<ActorSelf, Service<ActorSelf, NameA, AttachmentFields, EventDefinitions>> {
+  new (_: never): Context.TagClassShape<ActorId, Service<ActorSelf, NameA, AttachmentFields, EventDefinitions>>
+
+  readonly [TypeId]: typeof TypeId
+
+  readonly definition: ActorDefinition<
+    NameA,
+    AttachmentFields,
+    ActorClientSelf,
+    ActorClientId,
+    MethodDefinitions,
+    EventDefinitions
+  >
+
+  readonly schema: {
+    readonly attachments: S.Schema<S.Struct<AttachmentFields>["Type"], S.Struct<AttachmentFields>["Encoded"]>
+  }
+
+  readonly sendAll: Send<ActorSelf, EventDefinitions>
+
+  readonly evict: Effect.Effect<void, never, ActorSelf>
+
+  readonly handler: <K extends keyof MethodDefinitions, R>(
+    tag: K,
+    f: Method.Handler<MethodDefinitions[K], R>,
+  ) => Method.Handler<MethodDefinitions[K], R>
+}
+
+export const Service =
+  <ActorSelf>() =>
+  <
+    ActorId extends string,
+    NameA,
+    AttachmentFields extends Fields,
+    ClientSelf,
+    ClientId extends string,
+    MethodDefinitions extends Record<string, MethodDefinition.Any>,
+    EventDefinitions extends FieldsRecord,
+  >(
+    id: ActorId,
+    definition: ActorDefinition<NameA, AttachmentFields, ClientSelf, ClientId, MethodDefinitions, EventDefinitions>,
+  ): Actor<ActorSelf, ActorId, NameA, AttachmentFields, ClientSelf, ClientId, MethodDefinitions, EventDefinitions> => {
+    const tag = Context.Tag(id)<ActorSelf, Service<ActorSelf, NameA, AttachmentFields, EventDefinitions>>()
+
+    const sendAll: Send<ActorSelf, EventDefinitions> = Effect.fnUntraced(function* (key, payload) {
+      const { clients } = yield* tag
+      yield* Effect.forEach(clients, (client) => client.send(key, payload), {
+        concurrency: "unbounded",
+      })
+    })
+
+    // TODO: more eviction
+    const evict = Effect.gen(function* () {
+      const { clients } = yield* tag
+      for (const client of clients) {
+        yield* client.disconnect
+      }
+    })
+
+    const handler = <K extends keyof MethodDefinitions, R>(
+      _tag: K,
+      f: Method.Handler<MethodDefinitions[K], R>,
+    ): Method.Handler<MethodDefinitions[K], R> => f
+
+    return Object.assign(tag, {
+      [TypeId]: TypeId,
+      definition,
+      schema: {
+        attachments: S.Struct(definition.attachments) as never,
+      },
+      sendAll,
+      evict,
+      handler,
+    })
+  }

package/Audition.ts

@@ -0,0 +1,105 @@
+import { Pipeable, Stream, Effect, Function, Console } from "effect"
+
+import type { FieldsRecord } from "./_types.ts"
+import type { F } from "./F.ts"
+import type * as Method from "./Method.ts"
+
+import * as Client from "./Client.ts"
+import { type ClientError, AuditionError } from "./errors.ts"
+
+const TypeId = "~liminal/Audition" as const
+
+export interface Audition<ClientSelf, MethodDefinitions extends Record<string, Method.MethodDefinition.Any>, Event>
+  extends Pipeable.Pipeable {
+  readonly [TypeId]: typeof TypeId
+
+  readonly events: Stream.Stream<Event, ClientError, ClientSelf>
+
+  readonly f: F<ClientSelf, MethodDefinitions>
+}
+
+export const empty: Audition<never, never, never> = {
+  [TypeId]: TypeId,
+  pipe() {
+    return Pipeable.pipeArguments(this, arguments)
+  },
+  events: Stream.fail(AuditionError.make()),
+  f: () => () => AuditionError.make(),
+}
+
+export const add: {
+  <
+    ClientSelf,
+    ClientId extends string,
+    ClientMethodDefinitions extends Record<string, Method.MethodDefinition.Any>,
+    ClientEventDefinitions extends FieldsRecord,
+  >(
+    client: Client.Client<ClientSelf, ClientId, ClientMethodDefinitions, ClientEventDefinitions>,
+  ): <AuditionSelf, AuditionMethodDefinitions extends Record<string, Method.MethodDefinition.Any>, AuditionEvent>(
+    audition: Audition<AuditionSelf, AuditionMethodDefinitions, AuditionEvent>,
+  ) => Audition<
+    AuditionSelf | ClientSelf,
+    Method.MethodDefinition.Merge<AuditionMethodDefinitions, ClientMethodDefinitions>,
+    AuditionEvent | FieldsRecord.TaggedMember.Type<ClientEventDefinitions>
+  >
+  <
+    AuditionClientSelf,
+    AuditionMethodDefinitions extends Record<string, Method.MethodDefinition.Any>,
+    AuditionEvent,
+    ClientSelf,
+    ClientId extends string,
+    ClientMethodDefinitions extends Record<string, Method.MethodDefinition.Any>,
+    ClientEventDefinitions extends FieldsRecord,
+  >(
+    audition: Audition<AuditionClientSelf, AuditionMethodDefinitions, AuditionEvent>,
+    client: Client.Client<ClientSelf, ClientId, ClientMethodDefinitions, ClientEventDefinitions>,
+  ): Audition<
+    AuditionClientSelf | ClientSelf,
+    Method.MethodDefinition.Merge<AuditionMethodDefinitions, ClientMethodDefinitions>,
+    AuditionEvent | FieldsRecord.TaggedMember.Type<ClientEventDefinitions>
+  >
+} = Function.dual(
+  2,
+  <
+    AuditionSelf,
+    AuditionMethodDefinitions extends Record<string, Method.MethodDefinition.Any>,
+    AuditionEvent,
+    ClientSelf,
+    ClientId extends string,
+    ClientMethodDefinitions extends Record<string, Method.MethodDefinition.Any>,
+    ClientEventDefinitions extends FieldsRecord,
+  >(
+    audition: Audition<AuditionSelf, AuditionMethodDefinitions, AuditionEvent>,
+    client: Client.Client<ClientSelf, ClientId, ClientMethodDefinitions, ClientEventDefinitions>,
+  ): Audition<
+    AuditionSelf | ClientSelf,
+    Method.MethodDefinition.Merge<AuditionMethodDefinitions, ClientMethodDefinitions>,
+    AuditionEvent | FieldsRecord.TaggedMember.Type<ClientEventDefinitions>
+  > => {
+    const f: F<
+      AuditionSelf | ClientSelf,
+      Method.MethodDefinition.Merge<AuditionMethodDefinitions, ClientMethodDefinitions>
+    > = (method) => (payload) =>
+      audition
+        .f(method as never)(payload)
+        .pipe(Effect.catchTag("AuditionError", () => client.f(method as never)(payload)))
+
+    const events = audition.events.pipe(
+      Stream.catchTag("AuditionError", () =>
+        Effect.succeed(client.events).pipe(
+          Effect.tap(() => Console.log(`Auditioning ${client.key}`)),
+          Stream.unwrap,
+        ),
+      ),
+    )
+
+    return {
+      [TypeId]: TypeId,
+      pipe() {
+        return Pipeable.pipeArguments(this, arguments)
+      },
+      events,
+      f,
+    }
+  },
+)

package/CHANGELOG.md

@@ -1,217 +1,7 @@
 # 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
-
-- 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
-
-- e7006b7: Implement tool enablement and disablement.
-
-## 0.13.0
-
-### Minor Changes
-
-- 0e4954e: Rename `L.assistantStruct` to `L.assistantSchema`, is it now supports all schemas, not just struct schemas. Template tag calls are properly dedented and normalized. Additionally, `L.userJson` now uses the optional schema to JSONC-encode with description annotations as comments on corresponding fields.
-
-## 0.12.1
-
-### Patch Changes
-
-- 6df720c: Fix NPM publish.
-
-## 0.12.0
-
-### Minor Changes
-
-- a04ae8b: Introduce L.handle / rework strand event-handling mechanism.
-
-## 0.11.1
-
-### Patch Changes
-
-- feee30f: Testing provenance capture in changeset-driven publishes.
-
-## 0.11.0
-
-### Minor Changes
-
-- 48aa187: Rework mechanism of denoting strand boundary.
-
-## 0.10.0
-
-### Minor Changes
-
-- 866e64a: Redesigning much of the API.
-
-## 0.9.0
-
-### Minor Changes
-
-- df8861a: Separate L.assistant into L.assistantText and L.assistantStruct.
-
-## 0.8.0
-
-### Minor Changes
-
-- bf980fb: Major redesign of the Liminal API to be more effect-idiomatic.
-
-## 0.7.0
-
-### Minor Changes
-
-- d6fe173: Remove approach to passing handlers to strands.
-
-## 0.6.0
-
-### Minor Changes
-
-- e88b9af: Rewrite using Effect-TS.
-
-## 0.5.17
-
-### Patch Changes
-
-- 5c421c8: Re-add string dedenting for template-fn-style usage of user, system and schema.
-
-## 0.5.16
-
-### Patch Changes
-
-- 6e70190: Renaming Model to Adapter and L.model to L.focus
-
-## 0.5.15
-
-### Patch Changes
-
-- 9c276c3: Fix message list cloning, add streaming to ollama adapter.
-
-## 0.5.14
-
-### Patch Changes
-
-- d12049c: Fix L.run return type. Add L.<type> for JSON-schema building.
-
-## 0.5.13
-
-### Patch Changes
-
-- bbd0e74: Liminal schema and util now exist within the liminal package itself. Runtime type compatibility changes.
-
-## 0.5.12
-
-### Patch Changes
-
-- 4808a57: Fix handling of standalone iterables supplied to L.strand. Also introduce strandard, a standard library of strands.
-- Updated dependencies [4808a57]
-  - liminal-util@0.0.7
-
-## 0.5.11
-
-### Patch Changes
-
-- cf42ed2: Agent -> Strand. Making the API more uniform. Ie. Agent -> L.strand. L.branch -> L.strand.
-- Updated dependencies [cf42ed2]
-  - liminal-schema@0.0.5
-  - liminal-util@0.0.6
-
-## 0.5.10
-
-### Patch Changes
-
-- aef5564: Update Model interface to support streaming. Improve event-related functionality and emit fiber-related events.
-- Updated dependencies [aef5564]
-  - liminal-schema@0.0.4
-  - liminal-util@0.0.5
-
-## 0.5.9
-
-### Patch Changes
-
-- dbd5e93: Reintroduced tools and various examples.
-
-## 0.5.8
-
-### Patch Changes
-
-- 23a24ae: Reintroduce L.catch and clean up parts of the generator runtime.
-- f2f360c: Continue to clean up the generator runtime internals.
-- Updated dependencies [23a24ae]
-- Updated dependencies [f2f360c]
-  - liminal-schema@0.0.3
-  - liminal-util@0.0.4
-
-## 0.5.7
-
-### Patch Changes
-
-- a56f121: Re-flatten events. Make fiber info available in event handler via this.
-- Updated dependencies [a56f121]
-  - liminal-util@0.0.3
-
-## 0.5.6
-
-### Patch Changes
-
-- f79205e: Include fiber information in the event type supplied to user-specified handlers. Continue reworking runtime implementation.
-
-## 0.5.5
-
-### Patch Changes
-
-- 43afd27: Fixing misc. bugs and refactoring context management.
-
-## 0.5.4
-
-### Patch Changes
-
-- 284adab: Reintroduce AI SDK adapter and begin simplifying runic execution.
-- Updated dependencies [284adab]
-  - liminal-schema@0.0.2
-  - liminal-util@0.0.2
-
-## 0.5.3
-
-### Patch Changes
-
-- 2d3a717: Complete rewrite of Liminal. Includes new packages for various integrations.
-- Updated dependencies [2d3a717]
-- Updated dependencies [ff04b9f]
-  - liminal-schema@0.0.1
-  - liminal-util@0.0.1
-
-## 0.5.2
-
-### Patch Changes
-
-- de74823: Various API changes, such as infer as a callable object (the object of which implements Symbol.iterator and yields the actual action). Introduced initial "section" action. Also created an adapter for Ollama.
-
-## 0.5.1
-
-### Patch Changes
-
-- 96339de: Fixing continuous publishing. No other changes contained in this release.
-
-## 0.1.1
+## 0.17.1
 
 ### Patch Changes
 
-- 171acfe: Initial publish of Liminal and the Vercel AI adapter library. Still heavily WIP.
-  More publishes to come!
+- 17342eb: This version marks a complete reimagining of Liminal. More information coming soon.