liminal 0.5.9 → 0.5.11

package/CHANGELOG.md

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

package/Context.ts

@@ -1,43 +1,40 @@
-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
+export class Context extends Map<ContextPart, unknown> {
+  static get(): Context | undefined {
+    return storage.getStore()
   }
 
-  set<V>(context: ContextHandle<V>, value: V): this {
-    super.set(context, value)
-    return this
+  run<R>(f: () => R): R {
+    return storage.run(this, f)
   }
 
-  run<R>(callback: () => R): R {
-    return storage.run(this, callback)
-  }
-
-  clone(overrides?: Iterable<[ContextHandle, unknown]>): Context {
-    const context = new Context(overrides)
+  fork(): Context {
+    const context = new Context()
     for (const [handle, value] of this.entries()) {
       if (!context.has(handle)) {
-        context.set(handle, handle.clone?.(value) ?? value)
+        context.set(handle, handle.fork(value))
       }
     }
     return context
   }
 }
 
-export type ContextHandle<V = any> = {
-  clone: ((value: V) => V) | undefined
+export interface ContextPart<V = any> {
+  fork(parent?: V): V
+  get(): V | undefined
+  debug?: string
 }
 
-export function ContextHandle<V>(clone?: (value: V) => V): ContextHandle<V> {
-  return { clone }
+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
+    },
+    ...debug && { debug },
+  }
+  return self
 }

package/EventBase.ts

@@ -7,6 +7,12 @@ export interface EventBase<B extends symbol = symbol, K extends string = string>
 
 export function EventBase<B extends symbol, K extends string>(brand: B, type: K) {
   return class implements EventBase<B, K> {
+    static is<T>(this: new(...args: any) => T, value: unknown): value is T {
+      return typeof value === "object" && value !== null
+        && "brand" in value && value.brand === brand
+        && "type" in value && value.type === type
+    }
+
     readonly brand = brand
     readonly type = type
 

package/Fiber.ts

@@ -1,69 +1,63 @@
 import { attachCustomInspect } from "liminal-util"
 import { Context } from "./Context.ts"
-import type { Rune } from "./Rune.ts"
+import { type Handler, HandlerContext } from "./Handler.ts"
+import { ToolRegistry, ToolRegistryContext } from "./index.ts"
+import { FiberCreated, FiberRejected, FiberResolved, FiberStarted } from "./LEvent.ts"
+import { MessageRegistry, MessageRegistryContext } from "./MessageRegistry.ts"
+import { ModelRegistry, ModelRegistryContext } from "./ModelRegistry.ts"
+import { type Rune, RuneKey } from "./Rune.ts"
 import { Runic } from "./Runic.ts"
 
-export type FiberStatus<T> = {
-  type: "untouched"
-} | {
-  type: "pending"
-  self: AbortSignal
-  promise: Promise<T>
-} | {
-  type: "aborted"
-  reason: unknown
-} | {
-  type: "resolved"
-  value: T
-} | {
-  type: "rejected"
-  exception: unknown
+export interface FiberConfig {
+  parent?: Fiber
+  signal?: AbortSignal
+  context: Context
 }
 
 export class Fiber<T = any> {
-  static nextIndex: number = 0
+  static *[Symbol.iterator](): Generator<Rune<never>, Fiber> {
+    return yield Object.assign((fiber: Fiber) => fiber, {
+      [RuneKey]: true,
+      debug: "current_fiber",
+    } as never)
+  }
 
-  declare T: T
+  static nextIndex: number = 0
   readonly index: number = Fiber.nextIndex++
 
-  #runic: Runic<Rune, T>
-  declare readonly parent?: Fiber
-  #context: Context = Context.ensure()
+  readonly #context: Context
+  readonly #runic: Runic<Rune, T>
+  readonly #handler: Handler | undefined = HandlerContext.get()
+  readonly #configSignal?: AbortSignal
 
-  signal: AbortSignal
-  either: AbortSignal
-  abort: (reason?: any) => void
+  declare readonly parent?: Fiber
 
   status: FiberStatus<T> = { type: "untouched" }
+  controller: AbortController = new AbortController()
 
-  constructor(runic: Runic<Rune, T>, parent?: Fiber) {
+  constructor(runic: Runic<Rune, T>, config: FiberConfig) {
     this.#runic = runic
-    if (parent) {
-      this.parent = parent
-    }
-    const controller = new AbortController()
-    this.signal = controller.signal
-    this.either = AbortSignal.any([
-      ...this.parent?.signal ? [this.parent.signal] : [],
-      this.signal,
-    ])
-    this.abort = controller.abort.bind(controller)
+    const { context, parent, signal } = config
+    this.#context = context
+    if (parent) this.parent = parent
+    if (signal) this.#configSignal = signal
+    this.handle(new FiberCreated())
   }
 
-  fork<T>(runic: Runic<Rune, T>): Fiber<T> {
-    return new Fiber(runic, this)
+  handle(event: any) {
+    this.#handler?.call(this, event)
   }
 
-  resolution(this: Fiber<T>): Promise<T> {
-    const { status, abort } = this
-    switch (status.type) {
+  resolution(): Promise<T> {
+    switch (this.status.type) {
       case "untouched": {
         const { promise, resolve, reject } = Promise.withResolvers<T>()
         this.status = {
           type: "pending",
-          self: this.signal,
+          self: this.controller.signal,
           promise,
         }
+        this.handle(new FiberStarted())
         const iterator = Runic.unwrap(this.#runic)
         let nextArg: unknown
         this.#context.run(async () => {
@@ -79,30 +73,32 @@ export class Fiber<T = any> {
               type: "resolved",
               value,
             }
-            abort()
+            this.handle(new FiberResolved(value))
+            this.controller.abort()
             resolve(value)
           } catch (exception) {
             this.status = {
               type: "rejected",
               exception,
             }
-            abort(exception)
+            this.handle(new FiberRejected(exception))
+            this.controller.abort()
             reject(exception)
           }
         })
         return promise
       }
       case "pending": {
-        return status.promise
+        return this.status.promise
       }
       case "resolved": {
-        return Promise.resolve(status.value)
+        return Promise.resolve(this.status.value)
       }
       case "rejected": {
-        return Promise.reject(status.exception)
+        return Promise.reject(this.status.exception)
       }
       case "aborted": {
-        return Promise.reject(status.reason)
+        return Promise.reject(this.status.reason)
       }
     }
   }
@@ -111,3 +107,20 @@ export class Fiber<T = any> {
     attachCustomInspect(this, ({ index, parent }) => ({ index, ...parent && { parent } }))
   }
 }
+
+export type FiberStatus<T> = {
+  type: "untouched"
+} | {
+  type: "pending"
+  self: AbortSignal
+  promise: Promise<T>
+} | {
+  type: "aborted"
+  reason: unknown
+} | {
+  type: "resolved"
+  value: T
+} | {
+  type: "rejected"
+  exception: unknown
+}

package/Handler.ts

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

package/L/L.ts

@@ -1,10 +1,12 @@
 export * from "liminal-schema/factories"
-export * from "./_infer.ts"
-export * from "./_message.ts"
 export * from "./assistant.ts"
-export * from "./branch.ts"
 export * from "./catch.ts"
 export * from "./emit.ts"
+export * from "./infer.ts"
+export * from "./message.ts"
 export * from "./model.ts"
+export * from "./rune.ts"
+export * from "./strand.ts"
+export * from "./stream.ts"
 export * from "./system.ts"
 export * from "./user.ts"

package/L/_common.ts

@@ -0,0 +1,6 @@
+export class RequestCounter {
+  static count: number = 0
+  static next(): number {
+    return this.count++
+  }
+}

package/L/assistant.ts

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

package/L/catch.ts

@@ -1,12 +1,25 @@
+import { assert } from "liminal-util"
+import { Context } from "../Context.ts"
+import { Fiber } from "../Fiber.ts"
 import type { Rune } from "../Rune.ts"
 import type { Runic } from "../Runic.ts"
 import { rune } from "./rune.ts"
 
 export { catch_ as catch }
+
 function* catch_<Y extends Rune, T>(runic: Runic<Y, T>): Generator<Rune<Y>, CatchResult<T>> {
-  return yield* rune(async (fiber) => {
+  return yield* rune(async (parent) => {
     try {
-      return { resolved: await fiber.fork(runic).resolution() }
+      const context = Context.get()
+      assert(context)
+      return {
+        resolved: await context.fork().run(() =>
+          new Fiber(runic, {
+            context: context.fork(),
+            parent,
+          }).resolution()
+        ),
+      }
     } catch (exception: unknown) {
       return { rejected: exception }
     }

package/L/emit.ts

@@ -1,14 +1,10 @@
 import type { EnsureNarrow } from "liminal-util"
-import { Context } from "../Context.ts"
-import { HandlerContext } from "../Handler.ts"
+import { Fiber } from "../Fiber.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> {
-  const context = Context.ensure()
-  const handler = context.get(HandlerContext)
-  const fiber = yield* rune
-  handler?.call(fiber, event)
+  const self = yield* Fiber
+  self.handle(event)
 }

package/L/{_infer.ts → infer.ts}

@@ -1,31 +1,35 @@
 import type { SchemaObject } from "liminal-schema"
 import { assert } from "liminal-util"
-import { Context } 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 { RequestCounter } from "./_common.ts"
 import { emit } from "./emit.ts"
 import { rune } from "./rune.ts"
 
-export function* _infer(schema?: SchemaObject): Generator<Rune<LEvent>, string> {
-  const context = Context.ensure()
-  const modelRegistry = context.get(ModelRegistryContext)
+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 = InferenceCounter.next()
+  const requestId = RequestCounter.next()
   yield* emit(new InferenceRequested(requestId, schema))
-  const messageRegistry = context.get(MessageRegistryContext)
+  const messageRegistry = MessageRegistryContext.get()
   assert(messageRegistry)
-  const inference = yield* rune(() => model.resolve(messageRegistry.messages, schema), "infer")
+  const inference = yield* rune((fiber) =>
+    model
+      .seal({
+        messages: messageRegistry.messages,
+        schema,
+        signal: fiber.controller.signal,
+      })
+      .resolve(), "infer")
   yield* emit(new Inferred(requestId, inference))
   return inference
 }
-
-class InferenceCounter {
-  static count: number = 0
-  static next(): number {
-    return this.count++
-  }
-}
+Object.defineProperty(infer_, "name", { value: "infer" })

package/L/{_message.ts → message.ts}

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

package/L/model.ts

@@ -1,5 +1,4 @@
 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"
@@ -9,8 +8,7 @@ import { emit } from "./emit.ts"
 export interface model extends Generator<Rune<ModelRegistered>, void> {}
 
 export function* model(model: Model): model {
-  const context = Context.ensure()
-  const registry = context.get(ModelRegistryContext)
+  const registry = ModelRegistryContext.get()
   assert(registry)
   registry.register(model)
   yield* emit(new ModelRegistered(model))

package/L/rune.ts

@@ -1,30 +1,12 @@
 import { Fiber } from "../Fiber.ts"
 import { type Rune, RuneKey } from "../Rune.ts"
 
-export interface rune extends Iterable<Rune<never>, Fiber> {
-  <R>(source: (fiber: Fiber) => R, debug?: string): Iterable<Rune<never>, Awaited<R>> & {
-    <E>(): Generator<Rune<E>, Awaited<R>>
-  }
+export function* rune<R>(
+  source: (fiber: Fiber) => R,
+  debug?: string,
+): Generator<Rune<never>, Awaited<R>> {
+  return yield Object.assign(source, {
+    [RuneKey]: true,
+    debug,
+  }) as never
 }
-export const rune: rune = Object.assign(
-  function<R>(source: (fiber: Fiber) => R, debug?: string) {
-    return Object.assign(
-      function*<E>(): Generator<Rune<E>, Awaited<R>> {
-        return yield Object.assign(source, { [RuneKey]: true, debug } as never)
-      },
-      {
-        *[Symbol.iterator](): Generator<Rune<never>, Awaited<R>> {
-          return yield Object.assign(source, { [RuneKey]: true, debug } as never)
-        },
-      },
-    )
-  },
-  {
-    *[Symbol.iterator](): Generator<Rune<never>, Fiber> {
-      return yield Object.assign((fiber: Fiber) => fiber, {
-        [RuneKey]: true,
-        debug: "get_current_fiber",
-      } as never)
-    },
-  },
-)

package/L/strand.ts

@@ -0,0 +1,99 @@
+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"
+
+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")
+    },
+    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

@@ -0,0 +1,30 @@
+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 { emit } from "./emit.ts"
+import { rune } from "./rune.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()
+    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")
+  },
+}

package/L/system.ts

@@ -1,7 +1,7 @@
 import { isTemplateStringsArray } from "liminal-util"
 import type { LEvent } from "../LEvent.ts"
 import type { Rune } from "../Rune.ts"
-import { _message } from "./_message.ts"
+import { message } from "./message.ts"
 
 export interface system extends Generator<Rune<LEvent>, void> {}
 
@@ -9,5 +9,5 @@ export function system(template: TemplateStringsArray, ...substitutions: Array<s
 export function system(value: string): system
 export function system(e0: TemplateStringsArray | string, ...rest: Array<string>): system {
   const part = isTemplateStringsArray(e0) ? String.raw(e0, ...rest) : e0
-  return _message("system", [{ part }])
+  return message("system", [{ part }])
 }