liminal 0.5.12 → 0.5.14

package/CHANGELOG.md

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

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,58 +1,32 @@
-import { assert } from "liminal-util"
-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()
-  }
-
-  static ensure(): Context {
-    const current = Context.get()
-    assert(current)
-    return current
-  }
-
-  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
-  getOrInit(): V
-  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
-    },
-    getOrInit() {
-      const context = Context.get()
-      assert(context)
-      let value = context.get(this)
-      if (!value) {
-        value = this.fork()
-        context.set(this, value)
+    clone(): Context {
+      return {
+        handler: this.handler,
+        models: this.models.clone(),
+        messages: [...this.messages],
+        tools: new Set(this.tools),
+        clone: this.clone,
       }
-      return value as never
     },
-    ...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,24 @@
-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 "./schema/anyOf.ts"
+export * from "./schema/array.ts"
+export * from "./schema/boolean.ts"
+export * from "./schema/const.ts"
+export * from "./schema/enum.ts"
+export * from "./schema/integer.ts"
+export * from "./schema/null.ts"
+export * from "./schema/number"
+export * from "./schema/object.ts"
+export * from "./schema/string.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,18 @@
-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 { 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 JSON.parse(inference)
   },
   {
     *[Symbol.iterator]() {

package/L/catch.ts

@@ -1,24 +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, { 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,33 +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.getOrInit()
-  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.getOrInit()
-  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),
+      },
+      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,14 +1,12 @@
-import { type LEvent, MessageAppended } from "../LEvent.ts"
-import type { ContentPart, Message, MessageRole } from "../Message.ts"
-import { MessageRegistryContext } from "../MessageRegistry.ts"
+import { LEvent, MessageAppended } from "../LEvent.ts"
+import type { Content, Message, MessageRole } from "../Message.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.getOrInit()
-  const message: Message = { role, content }
+export function* message(role: MessageRole, content: Array<Content>): Generator<Rune<LEvent>, void> {
+  const { context: { messages } } = yield* reflect
+  const message: Message = { role, parts: content }
   yield* emit(new MessageAppended(message))
-  messageRegistry.append(message)
+  messages.push(message)
 }

package/L/model.ts

@@ -1,13 +1,13 @@
+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.getOrInit()
-  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<Y, T> {
+  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/schema/_schema_common.ts

@@ -0,0 +1,29 @@
+import type { Schema } from "../../Schema.ts"
+import { isTemplateStringsArray } from "../../util/isTemplateStringsArray.ts"
+
+export function make<S extends Schema>(schema: Omit<S, "T">, description?: string): S & TypeBase {
+  const schema_ = {
+    ...schema,
+    ...description && { description },
+  }
+
+  const Type = Object.assign(function describe(e0?: TemplateStringsArray | string, ...rest: Array<string>) {
+    const junction = isTemplateStringsArray(e0) ? String.raw(e0, ...rest) : e0
+    return make(
+      schema_,
+      description ? `${description}${junction ? `\n\n${junction}` : ""}` : junction,
+    )
+  }, schema_)
+  Object.defineProperty(Type, "toJSON", {
+    value() {
+      return schema_
+    },
+    enumerable: false,
+  })
+  return Type as never
+}
+
+export interface TypeBase {
+  (template: TemplateStringsArray, ...substitutions: Array<string>): this
+  (...values: Array<string>): this
+}

package/L/schema/anyOf.ts

@@ -0,0 +1,10 @@
+import type { Schema, SchemaAnyOf } from "../../Schema.ts"
+import { make } from "./_schema_common.ts"
+
+export interface anyOf<XA extends Array<Schema> = Array<Schema>> extends SchemaAnyOf<XA[number]["T"]> {
+  anyOf: XA
+}
+
+export function anyOf<XA extends Array<Schema>>(anyOf: XA): anyOf<XA> {
+  return make({ anyOf })
+}

package/L/schema/array.ts

@@ -0,0 +1,13 @@
+import type { Schema, SchemaArray } from "../../Schema.ts"
+import { make } from "./_schema_common.ts"
+
+export interface LArray<X extends Schema = Schema> extends SchemaArray<Array<X["T"]>> {
+  items: X
+}
+
+export function array<X extends Schema>(items: X): LArray<X> {
+  return make({
+    type: "array",
+    items,
+  })
+}

package/L/schema/boolean.ts

@@ -0,0 +1,8 @@
+import type { SchemaBoolean } from "../../Schema.ts"
+import { make, type TypeBase } from "./_schema_common.ts"
+
+interface boolean_ extends SchemaBoolean<boolean>, TypeBase {}
+
+const boolean_: boolean_ = make({ type: "boolean" })
+
+export { boolean_ as boolean }

package/L/schema/const.ts

@@ -0,0 +1,18 @@
+import type { SchemaString } from "../../Schema.ts"
+import { make, type TypeBase } from "./_schema_common.ts"
+
+interface const_<K extends string> extends SchemaString<K>, TypeBase {
+  enum?: never
+  const: K
+}
+
+function const_<K extends string>(value: K): const_<K> {
+  return make({
+    type: "string",
+    const: value,
+  })
+}
+
+Object.defineProperty(const_, "name", { value: "const" })
+
+export { const_ as const }

package/L/schema/enum.ts

@@ -0,0 +1,18 @@
+import type { SchemaString } from "../../Schema.ts"
+import { make, type TypeBase } from "./_schema_common.ts"
+
+interface enum_<V extends Array<string> = Array<string>> extends SchemaString<V[number]>, TypeBase {
+  enum: V
+  const?: never
+}
+
+function enum_<const V extends Array<string>>(...values: V): enum_<V> {
+  return make({
+    type: "string",
+    enum: values,
+  })
+}
+
+Object.defineProperty(enum_, "name", { value: "enum" })
+
+export { enum_ as enum }

package/L/schema/integer.ts

@@ -0,0 +1,6 @@
+import type { SchemaInteger } from "../../Schema.ts"
+import { make, type TypeBase } from "./_schema_common.ts"
+
+export interface integer extends SchemaInteger<number>, TypeBase {}
+
+export const integer: integer = make({ type: "integer" })

package/L/schema/null.ts

@@ -0,0 +1,8 @@
+import type { SchemaNull } from "../../Schema.ts"
+import { make, type TypeBase } from "./_schema_common.ts"
+
+export interface null_ extends SchemaNull<null>, TypeBase {}
+
+const null_: null_ = make({ type: "null" })
+
+export { null_ as null }

package/L/schema/number.ts

@@ -0,0 +1,8 @@
+import type { SchemaNumber } from "../../Schema.ts"
+import { make, type TypeBase } from "./_schema_common.ts"
+
+interface number_ extends SchemaNumber<number>, TypeBase {}
+
+const number_: number_ = make({ type: "number" })
+
+export { number_ as number }

package/L/schema/object.ts

@@ -0,0 +1,21 @@
+import type { Schema, SchemaObject } from "../../Schema.ts"
+import { make } from "./_schema_common.ts"
+
+interface object_<F extends Record<string, Schema> = Record<string, Schema>>
+  extends SchemaObject<{ [K in keyof F]: F[K]["T"] }>
+{
+  properties: F
+  required: Array<Extract<keyof F, string>>
+}
+
+function object_<XR extends Record<string, Schema>>(properties: XR): object_<XR> {
+  return make({
+    type: "object",
+    properties,
+    additionalProperties: false,
+    required: Object.keys(properties) as never,
+  })
+}
+
+Object.defineProperty(object_, "name", { value: "object" })
+export { object_ as object }