liminal 0.5.12 → 0.5.14

package/L/schema/string.ts

@@ -0,0 +1,11 @@
+import type { SchemaString } from "../../Schema.ts"
+import { make, type TypeBase } from "./_schema_common.ts"
+
+interface string_ extends SchemaString<string>, TypeBase {
+  enum?: never
+  const?: never
+}
+
+const string_: string_ = make({ type: "string" })
+
+export { string_ as string }

package/L/strand.ts

@@ -1,75 +1,18 @@
-import { assert, isIterableLike } from "liminal-util"
-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 { Runic } from "../Runic.ts"
-import type { StrandConfig } from "../StrandConfig.ts"
-import { ToolRegistry, ToolRegistryContext } from "../ToolRegistry.ts"
-import { rune } from "./rune.ts"
+import type { Context } from "../Context.ts"
+import type { Definition } from "../Definition.ts"
+import type { LEvent } from "../LEvent.ts"
+import { type Rune, RuneKey } from "../Rune.ts"
 
-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) => context().run(() => new Fiber(runic, { parent })))
-        return yield* rune(() => Promise.all(fibers.map((fiber) => fiber.resolution())), "strand")
-      } else if (typeof value === "object" && !isIterableLike(value)) {
-        const fibers = Object.values(value).map((runic) => context().run(() => new Fiber(runic, { parent })))
-        return yield* rune(() => {
-          const keys = Object.keys(value)
-          return Promise
-            .all(fibers.map((fiber) => fiber.resolution()))
-            .then((resolved) => resolved.map((value, i) => [keys[i], value]))
-            .then(Object.fromEntries)
-        }, "strand")
-      }
-      const fiber = context().run(() => new Fiber(value, { parent }))
-      return yield* rune(() => fiber.resolution(), "strand")
-    },
-    then(onfulfilled, onrejected) {
-      return new Fiber(this).resolution().then(onfulfilled, onrejected)
+export function* strand<Y extends Rune<any>, T>(
+  definition: Definition<Y, T>,
+  context?: Context,
+): Generator<Rune<LEvent>, T> {
+  return yield {
+    [RuneKey]: true,
+    value: {
+      kind: "child",
+      definition,
+      context,
     },
   }
-
-  function context() {
-    const current = Context.get()
-    assert(current)
-    const context = current.fork()
-    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

@@ -1,30 +1,17 @@
-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 { LiminalAssertionError } from "../LiminalAssertionError.ts"
+import type { Rune } from "../Rune.ts"
+import { continuation } from "./continuation.ts"
 import { emit } from "./emit.ts"
-import { rune } from "./rune.ts"
+import { reflect } from "./reflect.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()
+export const stream: Iterable<Rune<LEvent>, ReadableStream<string>> = {
+  *[Symbol.iterator]() {
+    const { context: { models, messages }, signal } = yield* reflect
+    const model = models.peek()
+    LiminalAssertionError.assert(model)
+    const requestId = crypto.randomUUID()
     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")
+    return yield* continuation("stream", () => model.seal({ messages, signal }).stream())
   },
 }

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<number | string>): system
-export function system(value: string): system
-export function system(e0: TemplateStringsArray | string, ...rest: Array<number | 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<number | string>): user
-export function user(value: string): user
-export function user(e0: TemplateStringsArray | string, ...rest: Array<number | 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/Message.ts

@@ -1,13 +1,14 @@
 export interface Message {
   readonly role: MessageRole
-  readonly content: Array<ContentPart>
+  readonly parts: Array<Content>
 }
 
 export type MessageRole = "system" | "user" | "assistant"
 
-export type ContentPart = {
+export type Content = {
   readonly part: string
   readonly alt?: never
+  readonly mime?: never
 } | {
   readonly part: URL
   readonly alt: string

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) => unknown>()
+
+  export function compile<T>(key: WeakKey, {
+    schema: schema_,
+    validate,
+  }: {
+    schema(): unknown
+    validate(value: unknown): T
+  }) {
+    let schema = schemas.get(key)
+    if (!schema) {
+      schema = Schema.validate(schema_())
+      schemas.set(key, schema)
+    }
+    validators.set(schema, validate)
+    return schema
+  }
+
+  export function validateValue<T>(schema: Schema<T>, value: unknown): T {
+    const validator = validators.get(schema)
+    LE.assert(validator)
+    return 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>