liminal 0.5.3 → 0.5.4

package/Agent.ts

@@ -1,4 +1,5 @@
-import { Fiber, type FiberInfo } from "./Fiber.ts"
+import type { FiberConfig, FiberInfo } from "./Fiber.ts"
+import { run } from "./run.ts"
 import type { Rune, RuneKey } from "./Rune.ts"
 import type { Runic } from "./Runic.ts"
 
@@ -10,14 +11,13 @@ export interface Agent<out T, out E> extends PromiseLike<T> {
 export function Agent<Y extends Rune, T>(runic: Runic<Y, T>, config?: AgentConfig<Y, T>): Agent<T, Rune.E<Y>> {
   return {
     then(onfulfilled, onrejected) {
-      const root = Fiber({
+      return run(runic, {
+        T: null!,
         globals: {
           handler: config?.handler ?? (() => {}),
         },
-        runic,
         signal: config?.signal,
-      })
-      return root.run().then(onfulfilled, onrejected)
+      }).then(onfulfilled, onrejected)
     },
   } satisfies Omit<Agent<T, Rune.E<Y>>, "E" | "T"> as never
 }

package/CHANGELOG.md

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

package/EventBase.ts

@@ -0,0 +1,13 @@
+import { inspect, type InspectOptions } from "node:util"
+
+export abstract class EventBase<B extends symbol, K extends string> {
+  constructor(
+    readonly brand: B,
+    readonly type: K,
+  ) {}
+
+  [inspect.custom](depth: number, options: InspectOptions) {
+    const { brand: _0, type: _1, ...rest } = this
+    return `${this.constructor.name} ` + inspect(rest, { ...options, depth })
+  }
+}

package/Fiber.ts

@@ -1,32 +1,18 @@
+import { assert } from "liminal-util"
 import type { Globals } from "./Globals.ts"
-import { type FiberCreated, type FiberResolved, type FiberStarted, LEventTag } from "./LEvent.ts"
+import { FiberCreated, FiberResolved, FiberStarted } from "./LEvent.ts"
 import type { Rune } from "./Rune.ts"
 import { Runic } from "./Runic.ts"
-import { DefaultStateMap } from "./state/DefaultStateMap.ts"
-import { StateMap } from "./state/StateMap.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
-  status: FiberStatus<T>
   fiberId: number
-  state: StateMap
-  globals: Globals
-  run(this: this): Promise<T>
   handler<E>(event: E): void
-}
-
-export type FiberStatus<T> = {
-  type: "untouched"
-} | {
-  type: "pending"
-  promise: Promise<T>
-} | {
-  type: "resolved"
-  value: T
-} | {
-  type: "rejected"
-  reason?: unknown
+  run(): Promise<T>
 }
 
 export interface FiberInfo {
@@ -36,82 +22,46 @@ export interface FiberInfo {
 
 let nextFiberId = 0
 
-export interface FiberConfig<T> {
-  parent?: Fiber<any>
+export interface FiberConfig<T = any> {
+  T: T
+  signal?: AbortSignal | undefined
   globals: Globals
-  runic: Runic<Rune, T>
   state?: StateMap | undefined
-  signal?: AbortSignal | undefined
 }
 
-export function Fiber<T>(config: FiberConfig<T>): Fiber<T> {
-  const fiber = {
-    state: config.state ?? new DefaultStateMap(),
-    globals: config.globals,
-    parent: config.parent,
-    status: { type: "untouched" },
-    fiberId: nextFiberId++,
-    run,
-    handler,
-  } satisfies Omit<Fiber<T>, "T"> as Fiber<T>
-  fiber.handler<FiberCreated>({
-    [LEventTag]: "fiber_created",
+export function handler<E>(fiberConfig: FiberConfig, event: E): void {
+  fiberConfig.globals.handler(event, {
+    // fiber: fiberConfig.fiberId,
+    timestamp: Date.now(),
   })
-  return fiber
+}
 
-  function handler<E>(this: Fiber<T>, event: E): void {
-    config.globals.handler(event, {
-      fiber: this.fiberId,
-      timestamp: Date.now(),
-    })
-  }
+// export interface FiberConfig<T> {
+//   parent?: Fiber<any>
+//   globals: Globals
+//   runic: Runic<Rune, T>
+//   signal?: AbortSignal | undefined
+// }
 
-  async function run(this: Fiber<T>): Promise<T> {
-    if (this.status.type === "pending") {
-      return await this.status.promise
-    } else if (this.status.type === "resolved") {
-      return this.status.value
-    } else if (this.status.type === "rejected") {
-      throw this.status.reason
-    }
-    this.handler<FiberStarted>({
-      [LEventTag]: "fiber_started",
-    })
-    const { promise, resolve, reject } = Promise.withResolvers<T>()
-    if (config.signal) {
-      if (config.signal.aborted) {
-        reject(config.signal.reason)
-        return await promise
-      } else {
-        config.signal.addEventListener("abort", () => {
-          reject(config.signal?.reason)
-        })
-      }
-    }
-    this.status = {
-      type: "pending",
-      promise,
-    }
-    queueMicrotask(async () => {
-      const iterator = Runic.unwrap(config.runic)
-      let nextArg: any
-      try {
-        let current = await iterator.next(nextArg)
-        while (!current.done) {
-          const rune = current.value
-          const nextArg = await rune(this)
-          current = await iterator.next(nextArg)
-        }
-        const { value } = current
-        this.handler<FiberResolved>({
-          [LEventTag]: "fiber_resolved",
-          value,
-        })
-        resolve(value)
-      } catch (reason: unknown) {
-        reject(reason)
-      }
-    })
-    return await promise
-  }
-}
+// 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/Globals.ts

@@ -3,7 +3,7 @@ export interface Globals {
 }
 
 export interface EventInfo {
-  fiber: number
+  // fiber: number
   timestamp: number
   // group
   // depth

package/L/L.ts

@@ -8,6 +8,5 @@ export * from "./fork.ts"
 export * from "./join.ts"
 export * from "./model.ts"
 export * from "./self.ts"
-export * from "./state.ts"
 export * from "./system.ts"
 export * from "./user.ts"

package/L/_infer.ts

@@ -1,35 +1,40 @@
-import type { SchemaRoot } from "liminal-schema"
+import type { SchemaObject } from "liminal-schema"
 import { assert } from "liminal-util"
-import { type InferenceRequested, type Inferred, type LEvent, LEventTag } from "../LEvent.ts"
+import { InferenceRequested, Inferred, type LEvent } from "../LEvent.ts"
 import type { Rune } from "../Rune.ts"
-import { Counter } from "../state/Counter.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"
-import { state } from "./state.ts"
 
-export function* _infer(schema?: SchemaRoot): Generator<Rune<LEvent>, string> {
-  const [modelRegistry, { messages }, counter] = yield* state(
-    ModelRegistry,
-    MessageRegistry,
-    InferenceRequestCounter,
-  )
+export function* _infer(schema?: SchemaObject): Generator<Rune<LEvent>, string> {
+  const state = context.get()
+  const modelRegistry = state.getOrInit(ModelRegistry.make)
   const model = modelRegistry.peek()
+  const messageRegistry = state.getOrInit(MessageRegistry.make)
+  const counter = state.getOrInit(InferenceRequestCounter)
   assert(model)
   const requestId = counter.next()
-  yield* emit<InferenceRequested>({
-    [LEventTag]: "inference_requested",
-    ...schema && { schema },
-    requestId,
-  })
-  const inference = yield* rune(() => model.resolve(messages, schema))
-  yield* emit<Inferred>({
-    [LEventTag]: "inferred",
-    inference,
-    requestId,
-  })
+  yield* emit(new InferenceRequested(requestId, schema))
+  const inference = yield* rune(() => model.resolve(messageRegistry.messages, schema))
+  yield* emit(new Inferred(requestId, inference))
   return inference
 }
 
-class InferenceRequestCounter extends Counter {}
+function InferenceRequestCounter(instance?: Counter) {
+  return {
+    count: instance?.count ?? 0,
+    next() {
+      return this.count++
+    },
+    clone() {
+      return InferenceRequestCounter(this)
+    },
+  }
+}
+
+interface Counter {
+  count: number
+  next(): number
+}

package/L/_message.ts

@@ -1,18 +1,16 @@
-import { type LEvent, LEventTag, type MessageAppended } from "../LEvent.ts"
+import { type LEvent, MessageAppended } from "../LEvent.ts"
 import type { ContentPart, Message, MessageRole } from "../Message.ts"
 import type { Rune } from "../Rune.ts"
+import { context } from "../state/Context.ts"
 import { MessageRegistry } from "../state/MessageRegistry.ts"
 import { emit } from "./emit.ts"
-import { state } from "./state.ts"
 
 export interface _message extends Generator<Rune<LEvent>, void> {}
 
 export function* _message(role: MessageRole, content: Array<ContentPart>): _message {
-  const [messageRegistry] = yield* state(MessageRegistry)
+  const state = context.get()
+  const messageRegistry = state.getOrInit(MessageRegistry.make)
   const message: Message = { role, content }
-  yield* emit<MessageAppended>({
-    [LEventTag]: "message_appended",
-    message,
-  })
+  yield* emit(new MessageAppended(message))
   messageRegistry.append(message)
 }

package/L/assistant.ts

@@ -1,7 +1,4 @@
-import type { StandardSchemaV1 } from "@standard-schema/spec"
-import { type LType, toJSONSchema } from "liminal-schema"
-import type { json } from "liminal-util"
-import { LiminalAssertionError } from "liminal-util"
+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"
@@ -18,11 +15,7 @@ export const assistant: assistant = Object.assign(
     const inference = yield* _infer(schema)
     yield* _message("assistant", [{ part: inference }])
     const input = JSON.parse(inference)
-    const result = yield* rune(() => (type as StandardSchemaV1<json.ValueObject, T>)["~standard"].validate(input))
-    if (result.issues) {
-      throw new LiminalAssertionError(JSON.stringify(result.issues, null, 2))
-    }
-    return result.value
+    return yield* rune(() => validate(type, input))
   },
   {
     *[Symbol.iterator]() {

package/L/branch.ts

@@ -1,9 +1,9 @@
-import { Fiber } from "../Fiber.ts"
+import type { FiberConfig } from "../Fiber.ts"
+import { run } from "../run.ts"
 import { type Rune } from "../Rune.ts"
 import type { Runic } from "../Runic.ts"
-import { all } from "./all.ts"
-import { fork } from "./fork.ts"
-import { join } from "./join.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> {}
@@ -17,29 +17,35 @@ export function branch<XR extends Record<keyof any, Runic>>(
 ): 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, state } = parent
+  const { globals } = parent
   if (Array.isArray(value)) {
-    const fibers = value.map((runic) =>
-      Fiber({
+    const runners = value.map((runic) => {
+      const state = context.get()
+      const fiberConfig: FiberConfig = {
+        T: null!,
         globals,
-        parent,
-        runic,
-        state: state.clone(),
-      })
-    )
-    return yield* join(yield* all(...fibers))
+        state,
+      }
+      return () => run(runic, fiberConfig)
+    })
+    return yield* rune(() => Promise.all(runners.map((runner) => runner())))
   } else if (typeof value === "object") {
-    const fibers = Object.values(value).map((runic) =>
-      Fiber({
+    const runners = Object.entries(value).map(([key, runic]) => {
+      const state = context.get()
+      const fiberConfig: FiberConfig = {
+        T: null!,
         globals,
-        parent,
-        runic,
-        state: state.clone(),
-      })
-    )
-    const resolved = yield* join(yield* all(...fibers))
-    return Object.fromEntries(Object.keys(value).map((key, i) => [key, resolved[i]]))
+        state,
+      }
+      return async () => [key, await run(runic, fiberConfig)]
+    })
+    return yield* rune(() => Promise.all(runners.map((runner) => runner())).then(Object.fromEntries))
   }
-  const fiber = yield* fork(typeof value === "function" ? value() : value, state.clone())
-  return yield* join(fiber)
+  const state = context.get()
+  const fiberConfig: FiberConfig = {
+    T: null!,
+    globals,
+    state,
+  }
+  return yield* rune(() => run(typeof value === "function" ? value() : value, fiberConfig))
 }

package/L/emit.ts

@@ -1,11 +1,10 @@
 import type { EnsureNarrow } from "liminal-util"
+import { handler } 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> {
-  yield* rune((fiber) => {
-    fiber.handler(event)
-  })<E>()
+  yield* rune((fiberConfig) => handler(fiberConfig, event))<E>()
 }

package/L/fork.ts

@@ -1,18 +1,20 @@
-import { Fiber } from "../Fiber.ts"
-import type { Rune } from "../Rune.ts"
-import type { Runic } from "../Runic.ts"
-import type { StateMap } from "../state/StateMap.ts"
-import { rune } from "./rune.ts"
+// import type { FiberConfig } from "../Fiber.ts"
+// import type { Rune } from "../Rune.ts"
+// import type { Runic } from "../Runic.ts"
+// import { runic as runic_ } from "./runic.ts"
+// import { self } from "./self.ts"
 
-export interface fork<Y extends Rune, T> extends Generator<Rune<never> | Y, Fiber<T>> {}
+// export interface fork<Y extends Rune, T> extends Generator<Rune<any> | Y, FiberConfig<T>> {}
 
-export function* fork<Y extends Rune, T>(runic: Runic<Y, T>, state?: StateMap): fork<Y, T> {
-  return yield* rune((parent) =>
-    Fiber({
-      globals: parent.globals,
-      parent,
-      runic,
-      state: state?.clone(),
-    })
-  )
-}
+// export function* fork<Y extends Rune, T>(runic: Runic<Y, T>): fork<Y, T> {
+//   const parent = yield* self
+//   const { globals, state, signal } = parent
+//   const controller = new AbortController()
+//   const fiberConfig: FiberConfig = {
+//     T: null!,
+//     globals,
+//     signal: controller.signal,
+//     state: state?.clone(),
+//   }
+//   return (yield* runic_(runic, fiberConfig)) as never
+// }

package/L/model.ts

@@ -1,11 +1,12 @@
 import type { Model } from "../Model.ts"
 import type { Rune } from "../Rune.ts"
+import { context } from "../state/Context.ts"
 import { ModelRegistry } from "../state/ModelRegistry.ts"
-import { state } from "./state.ts"
 
 export interface model extends Generator<Rune<never>, void> {}
 
 export function* model(model: Model): model {
-  const [modelRegistry] = yield* state(ModelRegistry)
+  const state = context.get()
+  const modelRegistry = state.getOrInit(ModelRegistry.make)
   modelRegistry.register(model)
 }

package/L/rune.ts

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

package/L/self.ts

@@ -1,13 +1,13 @@
-import type { Fiber } from "../Fiber.ts"
+import type { FiberConfig } from "../Fiber.ts"
 import type { Rune } from "../Rune.ts"
 import { rune } from "./rune.ts"
 
 export interface self {
-  [Symbol.iterator](): Generator<Rune<never>, Fiber>
+  [Symbol.iterator](): Generator<Rune<never>, FiberConfig>
 }
 
 export const self: self = {
   *[Symbol.iterator]() {
-    return yield* rune((fiber) => fiber)
+    return yield* rune((fiberConfig) => fiberConfig)
   },
 }

package/LEvent.ts

@@ -1,34 +1,57 @@
-import type { SchemaRoot } from "liminal-schema"
+import type { SchemaObject } from "liminal-schema"
+import { EventBase } from "./EventBase.ts"
 import type { Message } from "./Message.ts"
 
 export type LEvent = InferenceRequested | Inferred | MessageAppended | FiberCreated | FiberStarted | FiberResolved
 
-export interface InferenceRequested extends LEventBase<"inference_requested"> {
-  requestId: number
-  schema?: SchemaRoot
+export const LEventTag: unique symbol = Symbol.for("liminal/LEvent")
+export type LEventTag = typeof LEventTag
+
+export class InferenceRequested extends EventBase<LEventTag, "inference_requested"> {
+  declare schema?: SchemaObject
+  constructor(
+    readonly requestId: number,
+    schema?: SchemaObject | undefined,
+  ) {
+    super(LEventTag, "inference_requested")
+    if (schema) {
+      this.schema = schema
+    }
+  }
 }
 
-export interface Inferred extends LEventBase<"inferred"> {
-  requestId: number
-  inference: string
+export class Inferred extends EventBase<LEventTag, "inferred"> {
+  constructor(
+    readonly requestId: number,
+    readonly inference: string,
+  ) {
+    super(LEventTag, "inferred")
+  }
 }
 
-export interface MessageAppended extends LEventBase<"message_appended"> {
-  message: Message
+export class MessageAppended extends EventBase<LEventTag, "message_appended"> {
+  constructor(readonly message: Message) {
+    super(LEventTag, "message_appended")
+  }
 }
 
-export interface FiberCreated extends LEventBase<"fiber_created"> {}
-export interface FiberStarted extends LEventBase<"fiber_started"> {}
-export interface FiberResolved extends LEventBase<"fiber_resolved"> {
-  value: any
+export class FiberCreated extends EventBase<LEventTag, "fiber_created"> {
+  constructor() {
+    super(LEventTag, "fiber_created")
+  }
 }
 
-interface LEventBase<K extends string> {
-  [LEventTag]: K
+export class FiberStarted extends EventBase<LEventTag, "fiber_started"> {
+  constructor() {
+    super(LEventTag, "fiber_started")
+  }
 }
 
-export const LEventTag: unique symbol = Symbol.for("liminal/LEvent")
-export type LEventTag = typeof LEventTag
+export class FiberResolved extends EventBase<LEventTag, "fiber_resolved"> {
+  constructor(readonly value: any) {
+    super(LEventTag, "fiber_resolved")
+  }
+}
 
 export function isLEvent(value: unknown): value is LEvent {
   return typeof value === "object" && value !== null && LEventTag in value

package/Rune.ts

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

package/dist/Agent.d.ts

@@ -1,4 +1,4 @@
-import { type FiberInfo } from "./Fiber.ts";
+import type { FiberInfo } from "./Fiber.ts";
 import type { Rune, RuneKey } from "./Rune.ts";
 import type { Runic } from "./Runic.ts";
 export interface Agent<out T, out E> extends PromiseLike<T> {

package/dist/Agent.js

@@ -1,15 +1,14 @@
-import { Fiber } from "./Fiber.js";
+import { run } from "./run.js";
 export function Agent(runic, config) {
     return {
         then(onfulfilled, onrejected) {
-            const root = Fiber({
+            return run(runic, {
+                T: null,
                 globals: {
                     handler: config?.handler ?? (() => { }),
                 },
-                runic,
                 signal: config?.signal,
-            });
-            return root.run().then(onfulfilled, onrejected);
+            }).then(onfulfilled, onrejected);
         },
     };
 }

package/dist/Agent.js.map

@@ -1 +1 @@
-{"version":3,"file":"Agent.js","sourceRoot":"","sources":["../Agent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAkB,MAAM,YAAY,CAAA;AASlD,MAAM,UAAU,KAAK,CAAoB,KAAkB,EAAE,MAA0B;IACrF,OAAO;QACL,IAAI,CAAC,WAAW,EAAE,UAAU;YAC1B,MAAM,IAAI,GAAG,KAAK,CAAC;gBACjB,OAAO,EAAE;oBACP,OAAO,EAAE,MAAM,EAAE,OAAO,IAAI,CAAC,GAAG,EAAE,GAAE,CAAC,CAAC;iBACvC;gBACD,KAAK;gBACL,MAAM,EAAE,MAAM,EAAE,MAAM;aACvB,CAAC,CAAA;YACF,OAAO,IAAI,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,WAAW,EAAE,UAAU,CAAC,CAAA;QACjD,CAAC;KACsD,CAAA;AAC3D,CAAC"}
+{"version":3,"file":"Agent.js","sourceRoot":"","sources":["../Agent.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAA;AAS9B,MAAM,UAAU,KAAK,CAAoB,KAAkB,EAAE,MAA0B;IACrF,OAAO;QACL,IAAI,CAAC,WAAW,EAAE,UAAU;YAC1B,OAAO,GAAG,CAAC,KAAK,EAAE;gBAChB,CAAC,EAAE,IAAK;gBACR,OAAO,EAAE;oBACP,OAAO,EAAE,MAAM,EAAE,OAAO,IAAI,CAAC,GAAG,EAAE,GAAE,CAAC,CAAC;iBACvC;gBACD,MAAM,EAAE,MAAM,EAAE,MAAM;aACvB,CAAC,CAAC,IAAI,CAAC,WAAW,EAAE,UAAU,CAAC,CAAA;QAClC,CAAC;KACsD,CAAA;AAC3D,CAAC"}

package/dist/EventBase.d.ts

@@ -0,0 +1,7 @@
+import { inspect, type InspectOptions } from "node:util";
+export declare abstract class EventBase<B extends symbol, K extends string> {
+    readonly brand: B;
+    readonly type: K;
+    constructor(brand: B, type: K);
+    [inspect.custom](depth: number, options: InspectOptions): string;
+}