liminal 0.5.11 → 0.5.13

package/CHANGELOG.md

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

package/Config.ts

@@ -0,0 +1,13 @@
+import type { Message } from "./Message.ts"
+import { ModelRegistry } from "./ModelRegistry.ts"
+import type { Rune } from "./Rune.ts"
+import type { Strand } from "./Strand.ts"
+import type { Tool } from "./Tool.ts"
+
+export interface Config<Y extends Rune<any> = Rune<any>, T = any> {
+  handler?: ((this: Strand<Y, T>, event: Rune.E<Y>) => void) | undefined
+  models?: ModelRegistry | undefined
+  messages?: Array<Message>
+  tools?: Set<Tool> | undefined
+  signal?: AbortSignal | undefined
+}

package/Context.ts

@@ -1,40 +1,32 @@
-import { AsyncLocalStorage } from "node:async_hooks"
+import type { Handler } from "./Handler.ts"
+import type { Message } from "./Message.ts"
+import { ModelRegistry } from "./ModelRegistry.ts"
+import type { Tool } from "./Tool.ts"
 
-const storage = new AsyncLocalStorage<Context>()
+export interface Context {
+  readonly handler: Handler | undefined
+  readonly models: ModelRegistry
+  readonly messages: Array<Message>
+  readonly tools: Set<Tool>
 
-export class Context extends Map<ContextPart, unknown> {
-  static get(): Context | undefined {
-    return storage.getStore()
-  }
-
-  run<R>(f: () => R): R {
-    return storage.run(this, f)
-  }
-
-  fork(): Context {
-    const context = new Context()
-    for (const [handle, value] of this.entries()) {
-      if (!context.has(handle)) {
-        context.set(handle, handle.fork(value))
-      }
-    }
-    return context
-  }
+  clone(): Context
 }
 
-export interface ContextPart<V = any> {
-  fork(parent?: V): V
-  get(): V | undefined
-  debug?: string
-}
+export function Context(context?: Omit<Context, "clone">): Context {
+  return {
+    handler: context?.handler,
+    models: context?.models.clone() ?? new ModelRegistry(),
+    messages: [],
+    tools: new Set(context?.tools),
 
-export function ContextPart<V>(fork: (parent?: V) => V, debug?: string): ContextPart<V> {
-  const self: ContextPart<V> = {
-    fork,
-    get() {
-      return Context.get()?.get(self) as never
+    clone(): Context {
+      return {
+        handler: this.handler,
+        models: this.models.clone(),
+        messages: [...this.messages],
+        tools: new Set(this.tools),
+        clone: this.clone,
+      }
     },
-    ...debug && { debug },
   }
-  return self
 }

package/Definition.ts

@@ -0,0 +1,32 @@
+import type { Rune } from "./Rune.ts"
+
+export type RuneIterator<Y extends Rune<any> = Rune<any>, T = any> = Iterator<Y, T> | AsyncIterator<Y, T>
+export type RuneIterable<Y extends Rune<any> = Rune<any>, T = any> = Iterable<Y, T> | AsyncIterable<Y, T>
+export type Definition<Y extends Rune<any> = Rune<any>, T = any> = RuneIterable<Y, T> | (() => RuneIterable<Y, T>)
+
+export namespace Definition {
+  export type Y<X extends Definition> = X extends RuneIterable<infer Y> ? Y
+    : X extends () => RuneIterable<infer Y> ? Y
+    : X extends RuneIterator<infer Y> ? Y
+    : never
+
+  export type T<X extends Definition> = X extends RuneIterable<Rune<any>, infer T> ? T
+    : X extends () => RuneIterable<Rune<any>, infer T> ? T
+    : X extends RuneIterator<Rune<any>, infer T> ? T
+    : never
+
+  export type E<X extends Definition> = Rune.E<Y<X>>
+
+  export function unwrap<Y extends Rune<any>, T>(definition: Definition<Y, T>): RuneIterator<Y, T> {
+    if (Symbol.iterator in definition) {
+      return definition[Symbol.iterator]()
+    } else if (Symbol.asyncIterator in definition) {
+      return definition[Symbol.asyncIterator]()
+    }
+    const iterable = definition()
+    if (Symbol.iterator in iterable) {
+      return iterable[Symbol.iterator]()
+    }
+    return iterable[Symbol.asyncIterator]()
+  }
+}

package/EventBase.ts

@@ -1,4 +1,4 @@
-import { attachCustomInspect } from "liminal-util"
+import { attachCustomInspect } from "./util/attachCustomInspect.ts"
 
 export interface EventBase<B extends symbol = symbol, K extends string = string> {
   readonly brand: B

package/Handler.ts

@@ -1,6 +1,4 @@
-import { ContextPart as ContextPart } from "./Context.ts"
-import type { Fiber } from "./Fiber.ts"
+import type { Rune } from "./Rune.ts"
+import type { Strand } from "./Strand.ts"
 
-export type Handler<E = any> = [(this: Fiber, event: E) => void][0]
-
-export const HandlerContext: ContextPart<Handler | undefined> = ContextPart((parent) => parent, "handler")
+export type Handler<Y extends Rune<any> = Rune<any>> = (this: Strand, event: Rune.E<Y>) => void

package/L/L.ts

@@ -1,11 +1,14 @@
-export * from "liminal-schema/factories"
+export * from "./all.ts"
 export * from "./assistant.ts"
 export * from "./catch.ts"
+export * from "./context.ts"
+export * from "./continuation.ts"
 export * from "./emit.ts"
 export * from "./infer.ts"
 export * from "./message.ts"
 export * from "./model.ts"
-export * from "./rune.ts"
+export * from "./reflect.ts"
+export * from "./run.ts"
 export * from "./strand.ts"
 export * from "./stream.ts"
 export * from "./system.ts"

package/L/all.ts

@@ -0,0 +1,35 @@
+import type { Context } from "../Context.ts"
+import { Definition } from "../Definition.ts"
+import type { LEvent } from "../LEvent.ts"
+import type { Rune } from "../Rune.ts"
+import { Strand } from "../Strand.ts"
+import { continuation } from "./continuation.ts"
+import { reflect } from "./reflect.ts"
+
+export function all<A extends Array<Definition>>(
+  definitions: A,
+  context?: Context,
+): Generator<Rune<LEvent> | Definition.Y<A[number]>, { [I in keyof A]: Definition.T<A[I]> }>
+export function all<A extends Record<keyof any, Definition>>(
+  definitions: A,
+  context?: Context,
+): Generator<Rune<LEvent> | Definition.Y<A[keyof A]>, { [K in keyof A]: Definition.T<A[K]> }>
+export function* all<A extends Array<Definition> | Record<keyof any, Definition>>(
+  definitions: A,
+  context?: Context,
+): Generator<Rune<any>, any> { // TODO: although it's somewhat irrelevant, type this
+  const parent = yield* reflect
+  const strands: Array<Strand> = []
+  for (const definition of Array.isArray(definitions) ? definitions : Object.values(definitions)) {
+    strands.push(
+      new Strand(definition, {
+        parent,
+        context: context?.clone() ?? parent.context.clone(),
+      }),
+    )
+  }
+  const results = yield* continuation("all", () => Promise.all(strands))
+  if (Array.isArray(strands)) return results
+  const keys = Object.keys(strands)
+  return Object.fromEntries(results.map((result, i) => [keys[i], result]))
+}

package/L/assistant.ts

@@ -1,21 +1,20 @@
-import { type LType, toJSONSchema, validate } from "liminal-schema"
 import type { LEvent } from "../LEvent.ts"
 import type { Rune } from "../Rune.ts"
+import { Schema } from "../Schema.ts"
+import { continuation } from "./continuation.ts"
 import { infer } from "./infer.ts"
 import { message } from "./message.ts"
-import { rune } from "./rune.ts"
 
 export interface assistant extends Iterable<Rune<LEvent>, string> {
-  <T>(type: LType<T>): Generator<Rune<LEvent>, T>
+  <T>(schema: Schema<T>): Generator<Rune<LEvent>, T>
 }
 
 export const assistant: assistant = Object.assign(
-  function*<T>(type: LType<T>): Generator<Rune<LEvent>, T> {
-    const schema = toJSONSchema(type)
+  function* assistant<T>(schema: Schema<T>): Generator<Rune<LEvent>, T> {
     const inference = yield* infer(schema)
     yield* message("assistant", [{ part: inference }])
     const input = JSON.parse(inference)
-    return yield* rune(() => validate(type, input), "validate_assistant_message")
+    return yield* continuation("validate_assistant_message", () => Schema.validateValue(schema, input))
   },
   {
     *[Symbol.iterator]() {

package/L/catch.ts

@@ -1,29 +1,27 @@
-import { assert } from "liminal-util"
-import { Context } from "../Context.ts"
-import { Fiber } from "../Fiber.ts"
+import type { Definition } from "../Definition.ts"
+import type { LEvent } from "../LEvent.ts"
 import type { Rune } from "../Rune.ts"
-import type { Runic } from "../Runic.ts"
-import { rune } from "./rune.ts"
+import { Strand } from "../Strand.ts"
+import { continuation } from "./continuation.ts"
+import { reflect } from "./reflect.ts"
 
 export { catch_ as catch }
 
-function* catch_<Y extends Rune, T>(runic: Runic<Y, T>): Generator<Rune<Y>, CatchResult<T>> {
-  return yield* rune(async (parent) => {
+function* catch_<Y extends Rune<any>, T>(
+  definition: Definition<Y, T>,
+): Generator<Rune<LEvent> | Rune<Y>, CatchResult<T>> {
+  const parent = yield* reflect
+  return yield* continuation("catch", async () => {
     try {
-      const context = Context.get()
-      assert(context)
-      return {
-        resolved: await context.fork().run(() =>
-          new Fiber(runic, {
-            context: context.fork(),
-            parent,
-          }).resolution()
-        ),
-      }
+      const resolved = await new Strand(definition, {
+        parent,
+        context: parent.context.clone(),
+      }).then()
+      return { resolved }
     } catch (exception: unknown) {
       return { rejected: exception }
     }
-  }, "catch")
+  })
 }
 Object.defineProperty(catch_, "name", { value: "catch" })
 

package/L/context.ts

@@ -0,0 +1,12 @@
+import { Context } from "../Context.ts"
+import { reflect } from "./reflect.ts"
+
+export function* context(partial: Partial<Omit<Context, "clone">>) {
+  const { context } = yield* reflect
+  return Context({
+    handler: partial.handler ?? context.handler,
+    messages: partial.messages ?? context.messages,
+    models: partial.models ?? context.models,
+    tools: partial.tools ?? context.tools,
+  })
+}

package/L/continuation.ts

@@ -0,0 +1,13 @@
+import type { LEvent } from "../LEvent.ts"
+import { Rune, RuneKey } from "../Rune.ts"
+
+export function* continuation<R>(debug: string, f: () => R): Generator<Rune<LEvent>, Awaited<R>> {
+  return yield {
+    [RuneKey]: true,
+    value: {
+      kind: "continuation",
+      debug,
+      f,
+    },
+  }
+}

package/L/emit.ts

@@ -1,10 +1,12 @@
-import type { EnsureNarrow } from "liminal-util"
-import { Fiber } from "../Fiber.ts"
-import type { Rune } from "../Rune.ts"
+import { Rune, RuneKey } from "../Rune.ts"
+import type { EnsureNarrow } from "../util/EnsureNarrow.ts"
 
-export interface emit<E> extends Generator<Rune<E>, void> {}
-
-export function* emit<const E>(event: EnsureNarrow<E>): emit<E> {
-  const self = yield* Fiber
-  self.handle(event)
+export function* emit<E>(event: EnsureNarrow<E>): Generator<Rune<E>, void> {
+  return yield {
+    [RuneKey]: true,
+    value: {
+      kind: "event",
+      event,
+    },
+  }
 }

package/L/infer.ts

@@ -1,35 +1,30 @@
-import type { SchemaObject } from "liminal-schema"
-import { assert } from "liminal-util"
 import { InferenceRequested, Inferred, type LEvent } from "../LEvent.ts"
-import { MessageRegistryContext } from "../MessageRegistry.ts"
-import { ModelRegistryContext } from "../ModelRegistry.ts"
+import { LiminalAssertionError } from "../LiminalAssertionError.ts"
 import type { Rune } from "../Rune.ts"
-import { RequestCounter } from "./_common.ts"
+import { Schema } from "../Schema.ts"
+import { continuation } from "./continuation.ts"
 import { emit } from "./emit.ts"
-import { rune } from "./rune.ts"
+import { reflect } from "./reflect.ts"
 
-export { infer_ as infer }
-
-interface infer_ extends Generator<Rune<LEvent>, string> {}
-
-function* infer_(schema?: SchemaObject): infer_ {
-  const modelRegistry = ModelRegistryContext.get()
-  assert(modelRegistry)
-  const model = modelRegistry.peek()
-  assert(model)
-  const requestId = RequestCounter.next()
+export function* infer(schema?: Schema): Generator<Rune<LEvent>, string> {
+  const { context: { models, messages }, signal } = yield* reflect
+  const model = models.peek()
+  LiminalAssertionError.assert(model)
+  const requestId = crypto.randomUUID()
   yield* emit(new InferenceRequested(requestId, schema))
-  const messageRegistry = MessageRegistryContext.get()
-  assert(messageRegistry)
-  const inference = yield* rune((fiber) =>
-    model
-      .seal({
-        messages: messageRegistry.messages,
-        schema,
-        signal: fiber.controller.signal,
-      })
-      .resolve(), "infer")
+  let inference = yield* continuation("infer", () =>
+    model.seal({
+      messages,
+      schema: schema
+        ? schema.type === "object"
+          ? schema
+          : Schema.wrap(schema)
+        : undefined,
+      signal,
+    }).resolve())
+  if (schema?.type && schema.type !== "object") {
+    inference = JSON.stringify(JSON.parse(inference).value)
+  }
   yield* emit(new Inferred(requestId, inference))
   return inference
 }
-Object.defineProperty(infer_, "name", { value: "infer" })

package/L/message.ts

@@ -1,16 +1,12 @@
-import { assert } from "liminal-util"
-import { type LEvent, MessageAppended } from "../LEvent.ts"
+import { LEvent, MessageAppended } from "../LEvent.ts"
 import type { ContentPart, Message, MessageRole } from "../Message.ts"
-import { MessageRegistryContext } from "../MessageRegistry.ts"
 import type { Rune } from "../Rune.ts"
 import { emit } from "./emit.ts"
+import { reflect } from "./reflect.ts"
 
-export interface message extends Generator<Rune<LEvent>, void> {}
-
-export function* message(role: MessageRole, content: Array<ContentPart>): message {
-  const messageRegistry = MessageRegistryContext.get()
-  assert(messageRegistry)
+export function* message(role: MessageRole, content: Array<ContentPart>): Generator<Rune<LEvent>, void> {
+  const { context: { messages } } = yield* reflect
   const message: Message = { role, content }
   yield* emit(new MessageAppended(message))
-  messageRegistry.append(message)
+  messages.push(message)
 }

package/L/model.ts

@@ -1,15 +1,13 @@
-import { assert } from "liminal-util"
+import type { LEvent } from "../LEvent.ts"
 import { ModelRegistered } from "../LEvent.ts"
 import type { Model } from "../Model.ts"
-import { ModelRegistryContext } from "../ModelRegistry.ts"
 import type { Rune } from "../Rune.ts"
 import { emit } from "./emit.ts"
+import { reflect } from "./reflect.ts"
 
-export interface model extends Generator<Rune<ModelRegistered>, void> {}
-
-export function* model(model: Model): model {
-  const registry = ModelRegistryContext.get()
-  assert(registry)
-  registry.register(model)
+export function* model(model: Model): Generator<Rune<LEvent>, Model> {
+  const { context: { models } } = yield* reflect
+  models.register(model)
   yield* emit(new ModelRegistered(model))
+  return model
 }

package/L/reflect.ts

@@ -0,0 +1,12 @@
+import type { LEvent } from "../LEvent.ts"
+import { Rune, RuneKey } from "../Rune.ts"
+import type { Strand } from "../Strand.ts"
+
+export const reflect: Iterable<Rune<LEvent>, Strand> = {
+  *[Symbol.iterator]() {
+    return yield {
+      [RuneKey]: true,
+      value: { kind: "reflect" },
+    }
+  },
+}

package/L/run.ts

@@ -0,0 +1,29 @@
+import { Context } from "../Context.ts"
+import type { Definition } from "../Definition.ts"
+import type { Handler } from "../Handler.ts"
+import type { Message } from "../Message.ts"
+import { ModelRegistry } from "../ModelRegistry.ts"
+import type { Rune } from "../Rune.ts"
+import { Strand } from "../Strand.ts"
+import type { Tool } from "../Tool.ts"
+
+export interface RunConfig<Y extends Rune<any>> {
+  handler?: Handler<Y> | undefined
+  models?: ModelRegistry | undefined
+  messages?: Array<Message> | undefined
+  tools?: Set<Tool> | undefined
+  signal?: AbortSignal | undefined
+}
+
+export function run<Y extends Rune<any>, T>(definition: Definition<Y, T>, config?: RunConfig<Y>): Strand {
+  const context = Context({
+    handler: config?.handler,
+    models: config?.models ?? new ModelRegistry(),
+    messages: config?.messages ?? [],
+    tools: config?.tools ?? new Set(),
+  })
+  return new Strand(definition, {
+    signal: config?.signal,
+    ...config && { context },
+  })
+}

package/L/strand.ts

@@ -1,99 +1,18 @@
-import { Context } from "../Context.ts"
-import { Fiber } from "../Fiber.ts"
-import { HandlerContext } from "../Handler.ts"
-import { MessageRegistry, MessageRegistryContext } from "../MessageRegistry.ts"
-import { ModelRegistry, ModelRegistryContext } from "../ModelRegistry.ts"
-import { type Rune } from "../Rune.ts"
-import type { Runic } from "../Runic.ts"
-import { ToolRegistry, ToolRegistryContext } from "../ToolRegistry.ts"
-import { rune } from "./rune.ts"
+import type { Context } from "../Context.ts"
+import type { Definition } from "../Definition.ts"
+import type { LEvent } from "../LEvent.ts"
+import { type Rune, RuneKey } from "../Rune.ts"
 
-export interface StrandConfig<T = any, E = any> {
-  handler?: ((this: Fiber<T>, event: E) => void) | undefined
-  models?: ModelRegistry | undefined
-  messages?: MessageRegistry | undefined
-  tools?: ToolRegistry | undefined
-  signal?: AbortSignal | undefined
-}
-
-export interface strand<Y extends Rune, T> extends Iterable<Y, T>, PromiseLike<T> {}
-
-export function strand<X extends Runic>(
-  runic: X,
-  config?: StrandConfig<Runic.T<X>, Rune.E<Runic.Y<X>>>,
-): strand<Runic.Y<X>, Runic.T<X>>
-export function strand<XA extends Array<Runic>>(
-  runics: XA,
-  config?: StrandConfig<{ [I in keyof XA]: Runic.T<XA[I]> }, Rune.E<Runic.Y<XA[number]>>>,
-): strand<Runic.Y<XA[number]> | Rune<never>, { [I in keyof XA]: Runic.T<XA[I]> }>
-export function strand<XR extends Record<keyof any, Runic>>(
-  runics: XR,
-  config?: StrandConfig<{ [K in keyof XR]: Runic.T<XR[K]> }, Rune.E<Runic.Y<XR[keyof XR]>>>,
-): strand<Runic.Y<XR[keyof XR]> | Rune<never>, { [K in keyof XR]: Runic.T<XR[K]> }>
-export function strand(
-  value: Runic | Array<Runic> | Record<keyof any, Runic>,
-  config?: StrandConfig,
-): strand<Rune, any> {
-  return {
-    *[Symbol.iterator](): Generator<Rune, any> {
-      const parent = yield* Fiber
-      if (Array.isArray(value)) {
-        const fibers = value.map((runic) =>
-          new Fiber(runic, {
-            parent,
-            context: makeContext(),
-          })
-        )
-        return yield* rune(() => Promise.all(fibers.map((fiber) => fiber.resolution())), "strand")
-      } else if (typeof value === "object") {
-        const fibers = Object.values(value).map((runic) =>
-          new Fiber(runic, {
-            parent,
-            context: makeContext(),
-          })
-        )
-        return yield* rune(async () => {
-          const keys = Object.keys(value)
-          return await Promise
-            .all(fibers.map((fiber) => fiber.resolution()))
-            .then((resolved) => resolved.map((value, i) => [keys[i], value]))
-            .then(Object.fromEntries)
-        }, "strand")
-      }
-      const self = new Fiber(typeof value === "function" ? value() : value, {
-        parent,
-        context: makeContext(),
-      })
-      return yield* rune(() => self.resolution(), "strand")
+export function* strand<Y extends Rune<any>, T>(
+  definition: Definition<Y, T>,
+  context?: Context,
+): Generator<Rune<LEvent>, T> {
+  return yield {
+    [RuneKey]: true,
+    value: {
+      kind: "child",
+      definition,
+      context,
     },
-    then(onfulfilled, onrejected) {
-      return new Fiber(this, { context: makeContext() }).resolution().then(onfulfilled, onrejected)
-    },
-  }
-
-  function makeContext() {
-    let context = Context.get()?.fork()
-    if (!context) {
-      context = new Context([
-        [ModelRegistryContext, new ModelRegistry()],
-        [MessageRegistryContext, new MessageRegistry()],
-        [ToolRegistryContext, new ToolRegistry()],
-      ])
-    }
-    if (config) {
-      if ("handler" in config) {
-        context.set(HandlerContext, config.handler)
-      }
-      if ("models" in config) {
-        context.set(ModelRegistryContext, config.models?.clone() ?? new ModelRegistry())
-      }
-      if ("messages" in config) {
-        context.set(MessageRegistryContext, config.messages?.clone() ?? new MessageRegistry())
-      }
-      if ("tools" in config) {
-        context.set(ToolRegistryContext, config.tools?.clone() ?? new ToolRegistry())
-      }
-    }
-    return context
   }
 }

package/L/stream.ts

@@ -1,30 +1,17 @@
-import { assert } from "liminal-util"
 import { InferenceRequested, type LEvent } from "../LEvent.ts"
-import { MessageRegistryContext } from "../MessageRegistry.ts"
-import { ModelRegistryContext } from "../ModelRegistry.ts"
-import { type Rune } from "../Rune.ts"
-import { RequestCounter } from "./_common.ts"
+import { LiminalAssertionError } from "../LiminalAssertionError.ts"
+import type { Rune } from "../Rune.ts"
+import { continuation } from "./continuation.ts"
 import { emit } from "./emit.ts"
-import { rune } from "./rune.ts"
+import { reflect } from "./reflect.ts"
 
-export interface stream extends Iterable<Rune<LEvent>, ReadableStream<string>> {}
-
-export const stream: stream = {
-  *[Symbol.iterator](): Generator<Rune<LEvent>, ReadableStream<string>> {
-    const modelRegistry = ModelRegistryContext.get()
-    assert(modelRegistry)
-    const model = modelRegistry.peek()
-    assert(model)
-    const requestId = RequestCounter.next()
+export const stream: Iterable<Rune<LEvent>, ReadableStream<string>> = {
+  *[Symbol.iterator]() {
+    const { context: { models, messages }, signal } = yield* reflect
+    const model = models.peek()
+    LiminalAssertionError.assert(model)
+    const requestId = crypto.randomUUID()
     yield* emit(new InferenceRequested(requestId))
-    const messageRegistry = MessageRegistryContext.get()
-    assert(messageRegistry)
-    return yield* rune((fiber) =>
-      model
-        .seal({
-          messages: messageRegistry.messages,
-          signal: fiber.controller.signal,
-        })
-        .stream(), "stream")
+    return yield* continuation("stream", () => model.seal({ messages, signal }).stream())
   },
 }