liminal 0.5.4 → 0.5.6

package/Agent.ts

@@ -1,28 +1,36 @@
-import type { FiberConfig, FiberInfo } from "./Fiber.ts"
-import { run } from "./run.ts"
-import type { Rune, RuneKey } from "./Rune.ts"
+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 type { RuntimeEvent } from "./RuntimeEvent.ts"
+
+export interface AgentConfig<E> {
+  handler?: ((event: RuntimeEvent<E>) => void) | undefined
+  models?: ModelRegistry
+  messages?: MessageRegistry
+  signal?: AbortSignal | undefined
+}
 
 export interface Agent<out T, out E> extends PromiseLike<T> {
   T: T
   E: E
 }
 
-export function Agent<Y extends Rune, T>(runic: Runic<Y, T>, config?: AgentConfig<Y, T>): Agent<T, Rune.E<Y>> {
+export function Agent<Y extends Rune, T>(
+  runic: Runic<Y, T>,
+  config?: AgentConfig<Rune.E<Y>>,
+): Agent<T, Rune.E<Y>> {
   return {
     then(onfulfilled, onrejected) {
-      return run(runic, {
-        T: null!,
-        globals: {
-          handler: config?.handler ?? (() => {}),
-        },
-        signal: config?.signal,
-      }).then(onfulfilled, onrejected)
+      const rootCtx = new Context([
+        [HandlerContext, config?.handler],
+        [ModelRegistryContext, config?.models ?? new ModelRegistry()],
+        [MessageRegistryContext, config?.messages ?? new MessageRegistry()],
+      ])
+      return rootCtx.run(() => Fiber(runic).resolve().then(onfulfilled, onrejected))
     },
   } satisfies Omit<Agent<T, Rune.E<Y>>, "E" | "T"> as never
 }
-
-export interface AgentConfig<Y extends Rune, _T> {
-  handler: (event: Y[RuneKey], info: FiberInfo) => void
-  signal?: AbortSignal
-}

package/CHANGELOG.md

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

package/Context.ts

@@ -0,0 +1,52 @@
+import { assert } from "liminal-util"
+import { AsyncLocalStorage } from "node:async_hooks"
+
+const storage = new AsyncLocalStorage<Context>()
+
+export class Context extends Map<ContextHandle, unknown> {
+  static ensure(): Context {
+    const context = storage.getStore()
+    assert(context)
+    return context
+  }
+
+  get<V>(context: ContextHandle<V>): V | undefined {
+    return super.get(context) as never
+  }
+
+  getOrInit<V>(context: ContextHandle<V>, init: () => V): V {
+    if (this.has(context)) {
+      return this.get(context) as V
+    }
+    const instance = init()
+    this.set(context, instance)
+    return instance
+  }
+
+  set<V>(context: ContextHandle<V>, value: V): this {
+    super.set(context, value)
+    return this
+  }
+
+  run<R>(callback: () => R): R {
+    return storage.run(this, callback)
+  }
+
+  clone(overrides?: Iterable<[ContextHandle, unknown]>): Context {
+    const context = new Context(overrides)
+    for (const [handle, value] of this.entries()) {
+      if (!context.has(handle)) {
+        context.set(handle, handle.clone?.(value) ?? value)
+      }
+    }
+    return context
+  }
+}
+
+export type ContextHandle<V = any> = {
+  clone?: ((value: V) => V) | undefined
+}
+
+export function ContextHandle<V>(clone?: (value: V) => V): ContextHandle<V> {
+  return { clone }
+}

package/EventBase.ts

@@ -1,13 +1,26 @@
 import { inspect, type InspectOptions } from "node:util"
 
-export abstract class EventBase<B extends symbol, K extends string> {
-  constructor(
-    readonly brand: B,
-    readonly type: K,
-  ) {}
+export interface EventBase<B extends symbol = symbol, K extends string = string> {
+  readonly brand: B
+  readonly type: K
+}
+
+export function EventBase<B extends symbol, K extends string>(brand: B, type: K) {
+  return class implements EventBase<B, K> {
+    readonly brand = brand
+    readonly type = type
 
-  [inspect.custom](depth: number, options: InspectOptions) {
-    const { brand: _0, type: _1, ...rest } = this
-    return `${this.constructor.name} ` + inspect(rest, { ...options, depth })
+    // Allows us to circumvent a false positive ts error related to private symbols.
+    // https://github.com/microsoft/TypeScript/issues/58496
+    static {
+      Object.defineProperties(this.prototype, {
+        [inspect.custom]: {
+          value(depth: number, options: InspectOptions) {
+            const { brand: _0, type: _1, ...rest } = this
+            return `${this.constructor.name} ` + inspect(rest, { ...options, depth })
+          },
+        },
+      })
+    }
   }
 }

package/Fiber.ts

@@ -1,67 +1,54 @@
-import { assert } from "liminal-util"
-import type { Globals } from "./Globals.ts"
-import { FiberCreated, FiberResolved, FiberStarted } from "./LEvent.ts"
+import { Context } from "./Context.ts"
 import type { Rune } from "./Rune.ts"
 import { Runic } from "./Runic.ts"
-import type { StateMap } from "./state/StateMap.ts"
-
-export interface Fiber<out T = any> {
-  T: T
-  runic: Runic<Rune, T>
-  globals: Globals
-  parent: Fiber<any> | undefined
-  fiberId: number
-  handler<E>(event: E): void
-  run(): Promise<T>
-}
 
 export interface FiberInfo {
-  fiber: number
-  timestamp: number
+  readonly index: number
+  readonly parent?: FiberInfo
 }
 
-let nextFiberId = 0
+let nextIndex = 0
 
-export interface FiberConfig<T = any> {
-  T: T
-  signal?: AbortSignal | undefined
-  globals: Globals
-  state?: StateMap | undefined
+export interface Fiber<T = any> {
+  parent?: Fiber | undefined
+  info: FiberInfo
+  resolve(): Promise<T>
 }
 
-export function handler<E>(fiberConfig: FiberConfig, event: E): void {
-  fiberConfig.globals.handler(event, {
-    // fiber: fiberConfig.fiberId,
-    timestamp: Date.now(),
-  })
+export function Fiber<T = any>(runic: Runic<Rune, T>, parent?: Fiber): Fiber<T> {
+  let index = nextIndex++
+  let pending: Promise<T> | undefined
+  const context = Context.ensure()
+  return {
+    parent,
+    info: {
+      index,
+      ...parent && { parent: parent.info },
+    },
+    resolve,
+  }
+
+  function resolve(this: Fiber<T>): Promise<T> {
+    if (!pending) {
+      const { promise, resolve, reject } = Promise.withResolvers<T>()
+      pending = promise
+      const iterator = Runic.unwrap(runic)
+      let nextArg: unknown
+      context.run(async () => {
+        try {
+          let current = await iterator.next()
+          while (!current.done) {
+            const rune = current.value
+            nextArg = await rune(this)
+            current = await iterator.next(nextArg)
+          }
+          const { value } = current
+          resolve(value)
+        } catch (error) {
+          reject(error)
+        }
+      })
+    }
+    return pending
+  }
 }
-
-// export interface FiberConfig<T> {
-//   parent?: Fiber<any>
-//   globals: Globals
-//   runic: Runic<Rune, T>
-//   signal?: AbortSignal | undefined
-// }
-
-// export function Fiber<T>(config: FiberConfig<T>): Fiber<T> {
-//   const fiber = {
-//     runic: config.runic,
-//     globals: config.globals,
-//     parent: config.parent,
-//     fiberId: nextFiberId++,
-//     handler,
-//     run,
-//   } satisfies Omit<Fiber<T>, "T"> as Fiber<T>
-
-//   fiber.handler(new FiberCreated())
-//   return fiber
-
-//   async function run(this: Fiber<T>): Promise<T> {
-//     fiber.handler(new FiberStarted())
-//     const iterator = Runic.unwrap(this.runic)
-//     const result = await iterator.next()
-//     assert(result.done)
-//     fiber.handler(new FiberResolved(result.value))
-//     return result.value
-//   }
-// }

package/Handler.ts

@@ -0,0 +1,6 @@
+import { ContextHandle } from "./Context.ts"
+import type { RuntimeEvent } from "./RuntimeEvent.ts"
+
+export type Handler<E = any> = [(event: RuntimeEvent<E>) => void][0]
+
+export const HandlerContext: ContextHandle<Handler | undefined> = ContextHandle()

package/L/L.ts

@@ -4,9 +4,6 @@ export * from "./_message.ts"
 export * from "./assistant.ts"
 export * from "./branch.ts"
 export * from "./emit.ts"
-export * from "./fork.ts"
-export * from "./join.ts"
 export * from "./model.ts"
-export * from "./self.ts"
 export * from "./system.ts"
 export * from "./user.ts"

package/L/_infer.ts

@@ -1,40 +1,33 @@
 import type { SchemaObject } from "liminal-schema"
 import { assert } from "liminal-util"
+import { Context, ContextHandle } from "../Context.ts"
 import { InferenceRequested, Inferred, type LEvent } from "../LEvent.ts"
+import { MessageRegistryContext } from "../MessageRegistry.ts"
+import { ModelRegistryContext } from "../ModelRegistry.ts"
 import type { Rune } from "../Rune.ts"
-import { context } from "../state/Context.ts"
-import { MessageRegistry } from "../state/MessageRegistry.ts"
-import { ModelRegistry } from "../state/ModelRegistry.ts"
 import { emit } from "./emit.ts"
 import { rune } from "./rune.ts"
 
 export function* _infer(schema?: SchemaObject): Generator<Rune<LEvent>, string> {
-  const state = context.get()
-  const modelRegistry = state.getOrInit(ModelRegistry.make)
+  const context = Context.ensure()
+  const modelRegistry = context.get(ModelRegistryContext)
+  assert(modelRegistry)
   const model = modelRegistry.peek()
-  const messageRegistry = state.getOrInit(MessageRegistry.make)
-  const counter = state.getOrInit(InferenceRequestCounter)
   assert(model)
-  const requestId = counter.next()
+  const requestId = context.getOrInit(InferenceRequestCounterContext, () => new InferenceRequestCounter()).next()
   yield* emit(new InferenceRequested(requestId, schema))
+  const messageRegistry = context.get(MessageRegistryContext)
+  assert(messageRegistry)
   const inference = yield* rune(() => model.resolve(messageRegistry.messages, schema))
   yield* emit(new Inferred(requestId, inference))
   return inference
 }
 
-function InferenceRequestCounter(instance?: Counter) {
-  return {
-    count: instance?.count ?? 0,
-    next() {
-      return this.count++
-    },
-    clone() {
-      return InferenceRequestCounter(this)
-    },
+class InferenceRequestCounter {
+  count: number = 0
+  next(): number {
+    return this.count++
   }
 }
 
-interface Counter {
-  count: number
-  next(): number
-}
+const InferenceRequestCounterContext: ContextHandle<InferenceRequestCounter> = ContextHandle()

package/L/_message.ts

@@ -1,15 +1,17 @@
+import { assert } from "liminal-util"
+import { Context } from "../Context.ts"
 import { type 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 { context } from "../state/Context.ts"
-import { MessageRegistry } from "../state/MessageRegistry.ts"
 import { emit } from "./emit.ts"
 
 export interface _message extends Generator<Rune<LEvent>, void> {}
 
 export function* _message(role: MessageRole, content: Array<ContentPart>): _message {
-  const state = context.get()
-  const messageRegistry = state.getOrInit(MessageRegistry.make)
+  const context = Context.ensure()
+  const messageRegistry = context.get(MessageRegistryContext)
+  assert(messageRegistry)
   const message: Message = { role, content }
   yield* emit(new MessageAppended(message))
   messageRegistry.append(message)

package/L/branch.ts

@@ -1,10 +1,8 @@
-import type { FiberConfig } from "../Fiber.ts"
-import { run } from "../run.ts"
+import { Context } from "../Context.ts"
+import { Fiber } from "../Fiber.ts"
 import { type Rune } from "../Rune.ts"
 import type { Runic } from "../Runic.ts"
-import { context } from "../state/Context.ts"
 import { rune } from "./rune.ts"
-import { self } from "./self.ts"
 
 export interface branch<Y extends Rune, T> extends Generator<Y, T> {}
 
@@ -16,36 +14,20 @@ export function branch<XR extends Record<keyof any, Runic>>(
   runics: XR,
 ): branch<Runic.Y<XR[keyof XR]> | Rune<never>, { [K in keyof XR]: Runic.T<XR[K]> }>
 export function* branch(value: Runic | Array<Runic> | Record<keyof any, Runic>): branch<Rune, any> {
-  const parent = yield* self
-  const { globals } = parent
+  const context = Context.ensure()
+  const parent = yield* rune((fiber) => fiber)
   if (Array.isArray(value)) {
-    const runners = value.map((runic) => {
-      const state = context.get()
-      const fiberConfig: FiberConfig = {
-        T: null!,
-        globals,
-        state,
-      }
-      return () => run(runic, fiberConfig)
-    })
-    return yield* rune(() => Promise.all(runners.map((runner) => runner())))
+    const fibers = value.map((runic) => context.clone().run(() => Fiber(runic, parent)))
+    return yield* rune(() => Promise.all(fibers.map(({ resolve }) => resolve())))
   } else if (typeof value === "object") {
-    const runners = Object.entries(value).map(([key, runic]) => {
-      const state = context.get()
-      const fiberConfig: FiberConfig = {
-        T: null!,
-        globals,
-        state,
-      }
-      return async () => [key, await run(runic, fiberConfig)]
-    })
-    return yield* rune(() => Promise.all(runners.map((runner) => runner())).then(Object.fromEntries))
+    const entries = Object.entries(value)
+    const fibers = entries.map(([_key, runic]) => context.clone().run(() => Fiber(runic, parent)))
+    return yield* rune(() =>
+      Promise
+        .all(fibers.map(({ resolve }, i) => resolve().then((value) => [entries[i]![0], value])))
+        .then(Object.fromEntries)
+    )
   }
-  const state = context.get()
-  const fiberConfig: FiberConfig = {
-    T: null!,
-    globals,
-    state,
-  }
-  return yield* rune(() => run(typeof value === "function" ? value() : value, fiberConfig))
+  const fiber = context.clone().run(() => Fiber(typeof value === "function" ? value() : value, parent))
+  return yield* rune(() => fiber.resolve())
 }

package/L/emit.ts

@@ -1,10 +1,18 @@
 import type { EnsureNarrow } from "liminal-util"
-import { handler } from "../Fiber.ts"
+import { Context } from "../Context.ts"
+import { HandlerContext } from "../Handler.ts"
 import type { Rune } from "../Rune.ts"
 import { rune } from "./rune.ts"
 
 export interface emit<E> extends Generator<Rune<E>, void> {}
 
 export function* emit<const E>(event: EnsureNarrow<E>): emit<E> {
-  yield* rune((fiberConfig) => handler(fiberConfig, event))<E>()
+  const context = Context.ensure()
+  const handler = context.get(HandlerContext)
+  const fiber = yield* rune((fiber) => fiber)
+  handler?.({
+    ...fiber.info,
+    ...fiber.parent && { parent: fiber.parent.info },
+    event,
+  })
 }

package/L/model.ts

@@ -1,12 +1,17 @@
+import { assert } from "liminal-util"
+import { Context } from "../Context.ts"
+import { ModelRegistered } from "../LEvent.ts"
 import type { Model } from "../Model.ts"
+import { ModelRegistryContext } from "../ModelRegistry.ts"
 import type { Rune } from "../Rune.ts"
-import { context } from "../state/Context.ts"
-import { ModelRegistry } from "../state/ModelRegistry.ts"
+import { emit } from "./emit.ts"
 
-export interface model extends Generator<Rune<never>, void> {}
+export interface model extends Generator<Rune<ModelRegistered>, void> {}
 
 export function* model(model: Model): model {
-  const state = context.get()
-  const modelRegistry = state.getOrInit(ModelRegistry.make)
-  modelRegistry.register(model)
+  const context = Context.ensure()
+  const registry = context.get(ModelRegistryContext)
+  assert(registry)
+  registry.register(model)
+  yield* emit(new ModelRegistered(model))
 }

package/L/rune.ts

@@ -1,11 +1,11 @@
-import type { FiberConfig } from "../Fiber.ts"
+import { Fiber } from "../Fiber.ts"
 import { type Rune, RuneKey } from "../Rune.ts"
 
 export interface rune<T> extends Iterable<Rune<never>, T> {
   <E>(): Generator<Rune<E>, T>
 }
 
-export function rune<R>(source: (fiberConfig: FiberConfig) => R): rune<Awaited<R>> {
+export function rune<R>(source: (fiber: Fiber) => R): rune<Awaited<R>> {
   return Object.assign(
     function*<E>(): Generator<Rune<E>, Awaited<R>> {
       return yield Object.assign(source, { [RuneKey]: {} as never })

package/LEvent.ts

@@ -1,55 +1,59 @@
 import type { SchemaObject } from "liminal-schema"
 import { EventBase } from "./EventBase.ts"
 import type { Message } from "./Message.ts"
+import type { Model } from "./Model.ts"
 
-export type LEvent = InferenceRequested | Inferred | MessageAppended | FiberCreated | FiberStarted | FiberResolved
+export type LEvent =
+  | FiberCreated
+  | FiberResolved
+  | FiberStarted
+  | InferenceRequested
+  | Inferred
+  | MessageAppended
+  | ModelRegistered
 
 export const LEventTag: unique symbol = Symbol.for("liminal/LEvent")
 export type LEventTag = typeof LEventTag
 
-export class InferenceRequested extends EventBase<LEventTag, "inference_requested"> {
+export class ModelRegistered extends EventBase(LEventTag, "model_registered") {
+  constructor(readonly model: Model) {
+    super()
+  }
+}
+
+export class InferenceRequested extends EventBase(LEventTag, "inference_requested") {
   declare schema?: SchemaObject
   constructor(
     readonly requestId: number,
     schema?: SchemaObject | undefined,
   ) {
-    super(LEventTag, "inference_requested")
+    super()
     if (schema) {
       this.schema = schema
     }
   }
 }
 
-export class Inferred extends EventBase<LEventTag, "inferred"> {
+export class Inferred extends EventBase(LEventTag, "inferred") {
   constructor(
     readonly requestId: number,
     readonly inference: string,
   ) {
-    super(LEventTag, "inferred")
+    super()
   }
 }
 
-export class MessageAppended extends EventBase<LEventTag, "message_appended"> {
+export class MessageAppended extends EventBase(LEventTag, "message_appended") {
   constructor(readonly message: Message) {
-    super(LEventTag, "message_appended")
-  }
-}
-
-export class FiberCreated extends EventBase<LEventTag, "fiber_created"> {
-  constructor() {
-    super(LEventTag, "fiber_created")
-  }
-}
-
-export class FiberStarted extends EventBase<LEventTag, "fiber_started"> {
-  constructor() {
-    super(LEventTag, "fiber_started")
+    super()
   }
 }
 
-export class FiberResolved extends EventBase<LEventTag, "fiber_resolved"> {
+export class FiberCreated extends EventBase(LEventTag, "fiber_created") {}
+export class FiberStarted extends EventBase(LEventTag, "fiber_started") {}
+export class FiberResolved extends EventBase(LEventTag, "fiber_resolved") {
   constructor(readonly value: any) {
-    super(LEventTag, "fiber_resolved")
+    super()
   }
 }
 

package/MessageRegistry.ts

@@ -0,0 +1,21 @@
+import { ContextHandle } from "./Context.ts"
+import type { Message } from "./Message.ts"
+
+export class MessageRegistry {
+  messages: Array<Message>
+  constructor(messages?: Array<Message>) {
+    this.messages = messages ?? []
+  }
+
+  append(message: Message): void {
+    this.messages.push(message)
+  }
+
+  clone(): MessageRegistry {
+    return new MessageRegistry([...this.messages])
+  }
+}
+
+export const MessageRegistryContext: ContextHandle<MessageRegistry> = ContextHandle(({ messages }) =>
+  new MessageRegistry([...messages])
+)

package/{state/ModelRegistry.ts → ModelRegistry.ts}

@@ -1,29 +1,20 @@
-import type { Model } from "../Model.ts"
+import { ContextHandle } from "./Context.ts"
+import type { Model } from "./Model.ts"
 
 /** An intrusive list for storing `Model`s. */
 export class ModelRegistry {
-  static make(modelRegistry?: ModelRegistry) {
-    const instance = new ModelRegistry()
-    if (modelRegistry) {
-      for (let node = modelRegistry.head; node; node = node.next) {
-        instance.register(node.model)
-      }
-    }
-    return instance
-  }
-
   declare head?: ModelRegistryNode | undefined
   declare tail?: ModelRegistryNode | undefined
 
-  clone(): ModelRegistry {
-    const clone = new ModelRegistry()
-    for (let node = this?.head; node; node = node.next) {
-      clone.register(node.model)
+  constructor(models?: Array<Model>) {
+    if (models) {
+      for (const model of models) {
+        this.register(model)
+      }
     }
-    return clone
   }
 
-  peek(): Model | undefined {
+  peek() {
     return this.tail?.model
   }
 
@@ -41,7 +32,7 @@ export class ModelRegistry {
     return node
   }
 
-  remove(node: ModelRegistryNode): void {
+  remove(node: ModelRegistryNode) {
     if (node.prev) {
       node.prev.next = node.next
     }
@@ -63,3 +54,11 @@ export interface ModelRegistryNode {
   model: Model
   next?: ModelRegistryNode | undefined
 }
+
+export const ModelRegistryContext: ContextHandle<ModelRegistry> = ContextHandle(({ head }) => {
+  const instance = new ModelRegistry()
+  for (let node = head; node; node = node.next) {
+    instance.register(node.model)
+  }
+  return instance
+})

package/Rune.ts

@@ -1,7 +1,7 @@
-import type { FiberConfig } from "./Fiber.ts"
+import type { Fiber } from "./Fiber.ts"
 
 export interface Rune<out E = any> {
-  (fiber: FiberConfig): any
+  (fiber: Fiber): any
   [RuneKey]: E
 }