liminal 0.5.11 → 0.5.13

package/L/system.ts

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

package/L/user.ts

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

package/LEvent.ts

@@ -1,12 +1,11 @@
-import type { SchemaObject } from "liminal-schema"
 import { EventBase } from "./EventBase.ts"
 import type { Message } from "./Message.ts"
 import type { Model } from "./Model.ts"
+import type { Schema } from "./Schema.ts"
+import type { StrandStatus } from "./Strand.ts"
 
 export type LEvent =
-  | FiberCreated
-  | FiberResolved
-  | FiberStarted
+  | StrandStatusChanged
   | InferenceRequested
   | Inferred
   | MessageAppended
@@ -28,10 +27,10 @@ export class ModelRegistered extends EventBase(LEventTag, "model_registered") {
 }
 
 export class InferenceRequested extends EventBase(LEventTag, "inference_requested") {
-  declare schema?: SchemaObject
+  declare schema?: Schema
   constructor(
-    readonly requestId: number,
-    schema?: SchemaObject | undefined,
+    readonly requestId: string,
+    schema?: Schema | undefined,
   ) {
     super()
     if (schema) {
@@ -42,7 +41,7 @@ export class InferenceRequested extends EventBase(LEventTag, "inference_requeste
 
 export class Inferred extends EventBase(LEventTag, "inferred") {
   constructor(
-    readonly requestId: number,
+    readonly requestId: string,
     readonly inference: string,
   ) {
     super()
@@ -55,15 +54,8 @@ export class MessageAppended extends EventBase(LEventTag, "message_appended") {
   }
 }
 
-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()
-  }
-}
-export class FiberRejected extends EventBase(LEventTag, "fiber_rejected") {
-  constructor(readonly reason: any) {
+export class StrandStatusChanged extends EventBase(LEventTag, "strand_status_changed") {
+  constructor(readonly status: StrandStatus) {
     super()
   }
 }

package/LiminalAssertionError.ts

@@ -0,0 +1,19 @@
+export class LiminalAssertionError extends Error {
+  override readonly name = "LiminalAssertionError"
+}
+
+export namespace LiminalAssertionError {
+  export function assert(expr: unknown, msg = ""): asserts expr {
+    if (!expr) {
+      throw new LiminalAssertionError(msg)
+    }
+  }
+
+  export function unimplemented(): never {
+    throw new LiminalAssertionError()
+  }
+
+  export function unreachable(): never {
+    throw new LiminalAssertionError()
+  }
+}

package/Model.ts

@@ -1,6 +1,7 @@
-import type { SchemaObject } from "liminal-schema"
-import { attachCustomInspect } from "liminal-util"
 import type { Message } from "./Message.ts"
+import type { SchemaObject } from "./Schema.ts"
+import type { Tool } from "./Tool.ts"
+import { attachCustomInspect } from "./util/attachCustomInspect.ts"
 
 export class Model {
   constructor(
@@ -16,7 +17,8 @@ export class Model {
 export interface Envelope {
   messages: Array<Message>
   schema?: SchemaObject | undefined
-  signal?: AbortSignal
+  signal: AbortSignal
+  tools?: Set<Tool> | undefined
 }
 
 export interface SealedEnvelope {

package/ModelRegistry.ts

@@ -1,4 +1,3 @@
-import { ContextPart } from "./Context.ts"
 import type { Model } from "./Model.ts"
 
 /** An intrusive list for storing `Model`s. */
@@ -40,7 +39,7 @@ export class ModelRegistry {
     node.prev = node.next = undefined
   }
 
-  clone(): ModelRegistry {
+  clone() {
     const instance = new ModelRegistry()
     for (let node = this.head; node; node = node.next) {
       instance.register(node.model)
@@ -54,8 +53,3 @@ export interface ModelRegistryNode {
   model: Model
   next?: ModelRegistryNode | undefined
 }
-
-export const ModelRegistryContext: ContextPart<ModelRegistry> = ContextPart(
-  (parent) => parent?.clone() ?? new ModelRegistry(),
-  "model_registry",
-)

package/Rune.test.ts

@@ -0,0 +1,5 @@
+import { expect, test } from "vitest"
+
+test("adds 1 + 2 to equal 3", () => {
+  expect(1 + 2).toBe(3)
+})

package/Rune.ts

@@ -1,19 +1,31 @@
-import type { Fiber } from "./Fiber.ts"
+import type { Context } from "./Context.ts"
+import type { Definition } from "./Definition.ts"
 
-export interface Rune<out E = any> {
-  E: E
-  (fiber: Fiber): any
+export interface Rune<E> {
   [RuneKey]: true
-  debug?: string
+  value: {
+    kind: "continuation"
+    debug: string
+    f: () => any
+  } | {
+    kind: "event"
+    event: E
+  } | {
+    kind: "reflect"
+  } | {
+    kind: "child"
+    definition: Definition
+    context?: Context | undefined
+  }
 }
 
-export declare namespace Rune {
-  export type E<X extends Rune> = X["E"]
+export namespace Rune {
+  export type E<X extends Rune<any>> = X extends Rune<infer E> ? E : never
+
+  export function is(value: unknown): value is Rune<any> {
+    return typeof value === "object" && value !== null && RuneKey in value
+  }
 }
 
-export const RuneKey: unique symbol = Symbol.for("liminal/Rune")
+export const RuneKey: unique symbol = Symbol.for("liminal/RuneKey")
 export type RuneKey = typeof RuneKey
-
-export function isRune(value: unknown): value is Rune {
-  return typeof value === "object" && value !== null && RuneKey in value
-}

package/Schema.ts

@@ -0,0 +1,185 @@
+import { subtle } from "node:crypto"
+import { LiminalAssertionError as LE } from "./LiminalAssertionError.ts"
+
+export type Schema<T = any> = SchemaType<T> | SchemaAnyOf<T>
+
+export type SchemaType<T = any> =
+  | SchemaNull<T>
+  | SchemaBoolean<T>
+  | SchemaInteger<T>
+  | SchemaNumber<T>
+  | SchemaString<T>
+  | SchemaArray<T>
+  | SchemaObject<T>
+
+export interface SchemaNull<T = any> extends SchemaTypeBase<"null", T> {}
+
+export interface SchemaBoolean<T = any> extends SchemaTypeBase<"boolean", T> {}
+
+export interface SchemaInteger<T = any> extends SchemaTypeBase<"integer", T> {}
+
+export interface SchemaNumber<T = any> extends SchemaTypeBase<"number", T> {}
+
+export interface SchemaString<T = any> extends SchemaTypeBase<"string", T> {
+  enum?: Array<string>
+  const?: string
+}
+
+export interface SchemaArray<T = any> extends SchemaTypeBase<"array", T> {
+  items: Schema
+}
+
+export interface SchemaObject<T = any> extends SchemaTypeBase<"object", T> {
+  properties: Record<string, Schema>
+  required: Array<string>
+  additionalProperties: false
+}
+
+interface SchemaTypeBase<K extends SchemaTypeName, T> extends SchemaBase<T> {
+  type: K
+  anyOf?: never
+}
+
+export type SchemaTypeName = "null" | "boolean" | "integer" | "number" | "string" | "array" | "object"
+
+export interface SchemaAnyOf<T = any> extends SchemaBase<T> {
+  type?: never
+  anyOf: Array<Schema>
+}
+
+export interface SchemaBase<T> {
+  T: T
+  description?: string
+}
+
+export namespace Schema {
+  const ids = new WeakMap<Schema, Record<string, string>>()
+  const schemas = new WeakMap<WeakKey, Schema>()
+  const validators = new WeakMap<Schema, (value: unknown) => Promise<unknown>>()
+
+  export function compile<T>(key: WeakKey, {
+    schema: schema_,
+    validate,
+  }: {
+    schema(): unknown
+    validate(value: unknown): Promise<T>
+  }) {
+    let schema = schemas.get(key)
+    if (!schema) {
+      schema = Schema.validate(schema_())
+      schemas.set(key, schema)
+    }
+    validators.set(schema, validate)
+    return schema
+  }
+
+  export async function validateValue<T>(schema: Schema<T>, value: unknown): Promise<T> {
+    const validator = validators.get(schema)
+    LE.assert(validator)
+    return await validator(value) as never
+  }
+
+  export async function id(schema: Schema, description?: string): Promise<string> {
+    description = description ?? ""
+    if (!ids.has(schema)) {
+      ids.set(schema, {})
+    }
+    const schemaIds = ids.get(schema)!
+    let id = schemaIds[description]
+    if (!id) {
+      const content = `${description}_${JSON.stringify(schema)}`
+      const bytes = new Uint8Array(await subtle.digest("SHA-256", new TextEncoder().encode(content)))
+      let binary = ""
+      for (const b of bytes) binary += String.fromCharCode(b)
+      id = btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "")
+      schemaIds[description] = id
+    }
+    return id
+  }
+
+  export function wrap(schema: Schema): SchemaObject {
+    return {
+      type: "object",
+      properties: { value: schema },
+      additionalProperties: false,
+      required: ["value"],
+    } satisfies Omit<SchemaObject, "T"> as never
+  }
+
+  export function validate(value: unknown): Schema {
+    LE.assert(typeof value === "object")
+    LE.assert(value !== null)
+    if ("anyOf" in value) {
+      LE.assert(Array.isArray(value.anyOf))
+      return {
+        anyOf: value.anyOf.map(validate),
+      } satisfies Omit<SchemaAnyOf, "T"> as never
+    } else {
+      if ("enum" in value) {
+        LE.assert(Array.isArray(value.enum))
+        LE.assert(!("const" in value))
+        value.enum.forEach((v) => LE.assert(typeof v === "string"))
+        return {
+          type: "string",
+          enum: value.enum,
+        } satisfies Omit<SchemaString, "T"> as never
+      } else if ("const" in value) {
+        LE.assert(typeof value.const === "string")
+        return {
+          type: "string",
+          const: value.const,
+        } satisfies Omit<SchemaString, "T"> as never
+      } else if ("type" in value) {
+        LE.assert("type" in value)
+        LE.assert(typeof value.type === "string")
+        LE.assert(SCHEMA_TYPE_NAMES[value.type])
+        switch (value.type) {
+          case "null":
+          case "boolean":
+          case "integer":
+          case "number": {
+            break
+          }
+          case "string": {
+            if ("const" in value) {
+              LE.assert(typeof value.const === "string")
+            }
+            break
+          }
+          case "array": {
+            LE.assert("items" in value)
+            return {
+              type: "array",
+              items: validate(value.items),
+            } satisfies Omit<SchemaArray, "T"> as never
+          }
+          case "object": {
+            LE.assert("properties" in value)
+            LE.assert(typeof value.properties === "object")
+            const { properties } = value
+            LE.assert(properties !== null)
+            return {
+              type: "object",
+              properties: Object.fromEntries(
+                Object.entries(properties).map(([key, value]) => [key, validate(value)]),
+              ),
+              required: Object.keys(properties),
+              additionalProperties: false,
+            } satisfies Omit<SchemaObject, "T"> as never
+          }
+        }
+      }
+    }
+    return value as Schema
+  }
+}
+
+const SCHEMA_TYPE_NAMES: Record<string, boolean> = {
+  null: true,
+  boolean: true,
+  integer: true,
+  number: true,
+  string: true,
+  array: true,
+  object: true,
+} satisfies Record<SchemaTypeName, true>

package/Strand.ts

@@ -0,0 +1,253 @@
+import { Context } from "./Context.ts"
+import { Definition } from "./Definition.ts"
+import { StrandRejectedError } from "./errors.ts"
+import { continuation } from "./L/continuation.ts"
+import { StrandStatusChanged } from "./LEvent.ts"
+import type { Rune } from "./Rune.ts"
+import { attachCustomInspect } from "./util/attachCustomInspect.ts"
+
+export interface StrandConfig {
+  parent?: Strand | undefined
+  context?: Context | undefined
+  signal?: AbortSignal | undefined
+}
+
+let nextIndex: number = 0
+
+export class Strand<Y extends Rune<any> = Rune<any>, T = any> implements Iterable<Y, T>, PromiseLike<T> {
+  declare T: T
+  declare Y: Y
+
+  readonly #controller: AbortController = new AbortController()
+  readonly signal: AbortSignal = this.#controller.signal
+  #handle?: ((this: Strand, event: any) => void) | undefined
+  #definition: Definition<Y, T>
+  status: StrandStatus<T> = { type: "untouched" }
+  readonly index: number = nextIndex++
+  readonly depth: number
+  declare readonly parent?: Strand
+  readonly context: Context
+
+  constructor(definition: Definition<Y, T>, config: StrandConfig) {
+    this.#definition = definition
+    this.depth = (config?.parent?.depth ?? -1) + 1
+    const { parent, context, signal: configSignal } = config ?? {}
+    if (parent) {
+      this.parent = parent
+      this.#attachSignal(parent.signal, () => ({
+        type: "parent_aborted",
+        reason: parent.signal.reason,
+      }))
+    }
+    if (configSignal) {
+      this.#attachSignal(configSignal, () => ({
+        type: "config_signal_aborted",
+        reason: configSignal.reason,
+      }))
+    }
+    if (context) {
+      this.context = context
+      const { handler } = context
+      if (handler) {
+        this.#handle = (function(this: Strand, event: any) {
+          try {
+            handler.call(this, event)
+          } catch (exception) {
+            this.#setTerminalStatus({
+              type: "handler_exception_thrown",
+              exception,
+            })
+          }
+        }).bind(this)
+        this.#handle(new StrandStatusChanged(this.status))
+      }
+    } else {
+      this.context = Context()
+    }
+  }
+
+  #setStatus(status: StrandStatus<T>): void {
+    this.status = status
+    this.#handle?.(new StrandStatusChanged(this.status))
+  }
+
+  #setTerminalStatus = (status: StrandStatus.Rejected | StrandStatus.Resolved<T>): void => {
+    this.#setStatus(status)
+    this.#controller.abort(this.status)
+  }
+
+  #attachSignal(
+    signal: AbortSignal,
+    getStatus: () => StrandStatus.Rejected.ConfigSignalAborted | StrandStatus.Rejected.ParentAborted,
+  ): void {
+    const f = () => {
+      this.#setTerminalStatus(getStatus())
+    }
+    if (signal.aborted) {
+      return f()
+    }
+    signal.addEventListener("abort", f, { once: true })
+    this.#controller.signal.addEventListener(
+      "abort",
+      () => {
+        signal.removeEventListener("abort", f)
+      },
+      { once: true },
+    )
+  }
+
+  then<TResult1 = T, TResult2 = never>(
+    onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null,
+    onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null,
+  ): PromiseLike<TResult1 | TResult2> {
+    if (this.status.type !== "untouched") {
+      return this.#replay(this.status).then(onfulfilled, onrejected)
+    }
+    let resolve: (value: T) => void = undefined!
+    let reject: (reason?: unknown) => void = undefined!
+    const promise = new Promise<T>((resolve_, reject_) => {
+      resolve = resolve_
+      reject = reject_
+    })
+    this.status = {
+      type: "pending",
+      promise,
+      resolve,
+      reject,
+    }
+    this.#handle?.(new StrandStatusChanged(this.status))
+    const iterator = Definition.unwrap(this.#definition)
+    let nextArg: unknown
+    queueMicrotask(async () => {
+      try {
+        let current = await iterator.next()
+        while (!current.done) {
+          const rune = current.value
+          const { value } = rune
+          switch (value.kind) {
+            case "reflect": {
+              nextArg = this
+              break
+            }
+            case "continuation": {
+              nextArg = await value.f()
+              break
+            }
+            case "event": {
+              this.#handle?.(value.event)
+              nextArg = undefined
+              break
+            }
+            case "child": {
+              nextArg = await new Strand(value.definition, {
+                parent: this,
+                context: value.context ?? this.context.clone(),
+              }).then()
+              break
+            }
+          }
+          switch (this.status.type) {
+            case "config_signal_aborted":
+            case "parent_aborted":
+            case "continuation_exception_thrown":
+            case "handler_exception_thrown": {
+              try {
+                await iterator.return?.(undefined)
+              } catch (exception) {}
+              return Promise.reject(new StrandRejectedError(this.status))
+            }
+          }
+          current = await iterator.next(nextArg)
+        }
+        const { value } = current
+        this.#setTerminalStatus({
+          type: "resolved",
+          value,
+        })
+        resolve(value)
+      } catch (exception) {
+        this.#setTerminalStatus({
+          type: "continuation_exception_thrown",
+          exception,
+        })
+        reject(exception)
+      }
+    })
+    return promise.then(onfulfilled, onrejected)
+  }
+
+  *[Symbol.iterator](): Generator<Y, T> {
+    return yield* continuation("run_strand", () => this.then()) as any
+  }
+
+  #replay(status: Exclude<StrandStatus, StrandStatus.Untouched>): Promise<T> {
+    switch (status.type) {
+      case "config_signal_aborted":
+      case "parent_aborted":
+      case "continuation_exception_thrown":
+      case "handler_exception_thrown": {
+        return Promise.reject(new StrandRejectedError(status))
+      }
+      case "resolved": {
+        return Promise.resolve(status.value)
+      }
+      case "pending": {
+        return status.promise
+      }
+    }
+  }
+
+  static {
+    attachCustomInspect(this, ({ index, parent }) => ({ index, ...parent && { parent } }))
+  }
+}
+
+export type StrandStatus<T = any> =
+  | StrandStatus.Untouched
+  | StrandStatus.Pending<T>
+  | StrandStatus.Resolved<T>
+  | StrandStatus.Rejected
+export namespace StrandStatus {
+  export interface Untouched {
+    type: "untouched"
+  }
+
+  export interface Pending<T> {
+    type: "pending"
+    promise: Promise<T>
+    resolve: (value: T) => void
+    reject: (reason?: unknown) => void
+  }
+
+  export interface Resolved<T> {
+    type: "resolved"
+    value: T
+  }
+
+  export type Rejected =
+    | Rejected.ConfigSignalAborted
+    | Rejected.ParentAborted
+    | Rejected.ContinuationExceptionThrown
+    | Rejected.HandlerExceptionThrown
+  // | Rejected.ModelError
+  // | Rejected.ValidationError
+  // | Rejected.Timeout
+  export namespace Rejected {
+    export interface ConfigSignalAborted {
+      type: "config_signal_aborted"
+      reason: unknown
+    }
+    export interface ParentAborted {
+      type: "parent_aborted"
+      reason: unknown
+    }
+    export interface ContinuationExceptionThrown {
+      type: "continuation_exception_thrown"
+      exception: unknown
+    }
+    export interface HandlerExceptionThrown {
+      type: "handler_exception_thrown"
+      exception: unknown
+    }
+  }
+}