liminal 0.5.17 → 0.6.0

package/L/message.ts

@@ -1,16 +0,0 @@
-import { LEvent, MessageAppended } from "../LEvent.ts"
-import type { Content, Message, MessageRole } from "../Message.ts"
-import type { Rune } from "../Rune.ts"
-import { emit } from "./emit.ts"
-import { reflect } from "./reflect.ts"
-
-/**
- * Adds a new message to the current context's message list.
- * Emits a message append event to observers.
- */
-export function* message(role: MessageRole, content: Array<Content>): Generator<Rune<LEvent>, void> {
-  const { context: { messages } } = yield* reflect
-  const message: Message = { role, parts: content }
-  yield* emit(new MessageAppended(message))
-  messages.push(message)
-}

package/L/reflect.ts

@@ -1,13 +0,0 @@
-import type { LEvent } from "../LEvent.ts"
-import { Rune, RuneKey } from "../Rune.ts"
-import type { Strand } from "../Strand.ts"
-
-/** Returns the current strand instance, providing access to context and parent information. */
-export const reflect: Iterable<Rune<LEvent>, Strand> = {
-  *[Symbol.iterator]() {
-    return yield {
-      [RuneKey]: true,
-      instruction: { kind: "reflect" },
-    }
-  },
-}

package/L/run.ts

@@ -1,29 +0,0 @@
-import { AdapterRegistry } from "../AdapterRegistry.ts"
-import { Context } from "../Context.ts"
-import type { Definition } from "../Definition.ts"
-import type { Handler } from "../Handler.ts"
-import type { Message } from "../Message.ts"
-import type { Rune } from "../Rune.ts"
-import { Strand } from "../Strand.ts"
-import type { Tool } from "../Tool.ts"
-
-/** Configuration options for running a definition. */
-export interface RunConfig<Y extends Rune<any>> {
-  handler?: Handler<Y> | undefined
-  messages?: Array<Message> | undefined
-  tools?: Set<Tool> | undefined
-  signal?: AbortSignal | undefined
-}
-
-export function run<Y extends Rune<any>, T>(definition: Definition<Y, T>, config?: RunConfig<Y>): Strand<Y, T> {
-  const context = Context({
-    handler: config?.handler,
-    adapters: new AdapterRegistry(),
-    messages: config?.messages ?? [],
-    tools: config?.tools ?? new Set(),
-  })
-  return new Strand(definition, {
-    signal: config?.signal,
-    ...config && { context },
-  })
-}

package/L/schema/_schema_common.ts

@@ -1,30 +0,0 @@
-import type { Schema } from "../../Schema.ts"
-import { fixTemplateStrings } from "../../util/fixTemplateStrings.ts"
-import { isTemplateStringsArray } from "../../util/isTemplateStringsArray.ts"
-
-export function make<S extends Schema>(schema: Omit<S, "T">, description?: string): S & TypeBase {
-  const schema_ = {
-    ...schema,
-    ...description && { description },
-  }
-
-  const Type = Object.assign(function describe(e0?: TemplateStringsArray | string, ...rest: Array<string>) {
-    const junction = isTemplateStringsArray(e0) ? String.raw(fixTemplateStrings(e0), ...rest) : e0
-    return make(
-      schema_,
-      description ? `${description}${junction ? `\n\n${junction}` : ""}` : junction,
-    )
-  }, schema_)
-  Object.defineProperty(Type, "toJSON", {
-    value() {
-      return schema_
-    },
-    enumerable: false,
-  })
-  return Type as never
-}
-
-export interface TypeBase {
-  (template: TemplateStringsArray, ...substitutions: Array<string>): this
-  (...values: Array<string>): this
-}

package/L/schema/anyOf.ts

@@ -1,10 +0,0 @@
-import type { Schema, SchemaAnyOf } from "../../Schema.ts"
-import { make } from "./_schema_common.ts"
-
-export interface anyOf<XA extends Array<Schema> = Array<Schema>> extends SchemaAnyOf<XA[number]["T"]> {
-  anyOf: XA
-}
-
-export function anyOf<XA extends Array<Schema>>(anyOf: XA): anyOf<XA> {
-  return make({ anyOf })
-}

package/L/schema/array.ts

@@ -1,13 +0,0 @@
-import type { Schema, SchemaArray } from "../../Schema.ts"
-import { make } from "./_schema_common.ts"
-
-export interface LArray<X extends Schema = Schema> extends SchemaArray<Array<X["T"]>> {
-  items: X
-}
-
-export function array<X extends Schema>(items: X): LArray<X> {
-  return make({
-    type: "array",
-    items,
-  })
-}

package/L/schema/boolean.ts

@@ -1,8 +0,0 @@
-import type { SchemaBoolean } from "../../Schema.ts"
-import { make, type TypeBase } from "./_schema_common.ts"
-
-interface boolean_ extends SchemaBoolean<boolean>, TypeBase {}
-
-const boolean_: boolean_ = make({ type: "boolean" })
-
-export { boolean_ as boolean }

package/L/schema/const.ts

@@ -1,18 +0,0 @@
-import type { SchemaString } from "../../Schema.ts"
-import { make, type TypeBase } from "./_schema_common.ts"
-
-interface const_<K extends string> extends SchemaString<K>, TypeBase {
-  enum?: never
-  const: K
-}
-
-function const_<K extends string>(value: K): const_<K> {
-  return make({
-    type: "string",
-    const: value,
-  })
-}
-
-Object.defineProperty(const_, "name", { value: "const" })
-
-export { const_ as const }

package/L/schema/enum.ts

@@ -1,18 +0,0 @@
-import type { SchemaString } from "../../Schema.ts"
-import { make, type TypeBase } from "./_schema_common.ts"
-
-interface enum_<V extends Array<string> = Array<string>> extends SchemaString<V[number]>, TypeBase {
-  enum: V
-  const?: never
-}
-
-function enum_<const V extends Array<string>>(...values: V): enum_<V> {
-  return make({
-    type: "string",
-    enum: values,
-  })
-}
-
-Object.defineProperty(enum_, "name", { value: "enum" })
-
-export { enum_ as enum }

package/L/schema/integer.ts

@@ -1,6 +0,0 @@
-import type { SchemaInteger } from "../../Schema.ts"
-import { make, type TypeBase } from "./_schema_common.ts"
-
-export interface integer extends SchemaInteger<number>, TypeBase {}
-
-export const integer: integer = make({ type: "integer" })

package/L/schema/null.ts

@@ -1,8 +0,0 @@
-import type { SchemaNull } from "../../Schema.ts"
-import { make, type TypeBase } from "./_schema_common.ts"
-
-export interface null_ extends SchemaNull<null>, TypeBase {}
-
-const null_: null_ = make({ type: "null" })
-
-export { null_ as null }

package/L/schema/number.ts

@@ -1,8 +0,0 @@
-import type { SchemaNumber } from "../../Schema.ts"
-import { make, type TypeBase } from "./_schema_common.ts"
-
-interface number_ extends SchemaNumber<number>, TypeBase {}
-
-const number_: number_ = make({ type: "number" })
-
-export { number_ as number }

package/L/schema/object.ts

@@ -1,21 +0,0 @@
-import type { Schema, SchemaObject } from "../../Schema.ts"
-import { make } from "./_schema_common.ts"
-
-interface object_<F extends Record<string, Schema> = Record<string, Schema>>
-  extends SchemaObject<{ [K in keyof F]: F[K]["T"] }>
-{
-  properties: F
-  required: Array<Extract<keyof F, string>>
-}
-
-function object_<XR extends Record<string, Schema>>(properties: XR): object_<XR> {
-  return make({
-    type: "object",
-    properties,
-    additionalProperties: false,
-    required: Object.keys(properties) as never,
-  })
-}
-
-Object.defineProperty(object_, "name", { value: "object" })
-export { object_ as object }

package/L/schema/string.ts

@@ -1,11 +0,0 @@
-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,22 +0,0 @@
-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"
-
-/**
- * Creates a child strand that executes a definition.
- * Optionally specify the context. Otherwise the current context is inherited.
- */
-export function* strand<Y extends Rune<any>, T>(
-  definition: Definition<Y, T>,
-  context?: Context,
-): Generator<Rune<LEvent>, T> {
-  return yield {
-    [RuneKey]: true,
-    instruction: {
-      kind: "create_child",
-      definition,
-      context,
-    },
-  }
-}

package/L/stream.ts

@@ -1,16 +0,0 @@
-import { InferenceRequested, type LEvent } from "../LEvent.ts"
-import type { Rune } from "../Rune.ts"
-import { continuation } from "./continuation.ts"
-import { emit } from "./emit.ts"
-import { reflect } from "./reflect.ts"
-
-/** Creates a readable stream of content from the current model. */
-export const stream: Iterable<Rune<LEvent>, ReadableStream<string>> = {
-  *[Symbol.iterator]() {
-    const { context: { adapters, messages }, signal } = yield* reflect
-    const adapter = adapters.ensure()
-    const requestId = crypto.randomUUID()
-    yield* emit(new InferenceRequested(requestId))
-    return yield* continuation("stream", adapter.seal({ messages, signal }).stream)
-  },
-}

package/L/system.ts

@@ -1,19 +0,0 @@
-import type { LEvent } from "../LEvent.ts"
-import type { Rune } from "../Rune.ts"
-import { fixTemplateStrings } from "../util/fixTemplateStrings.ts"
-import { isTemplateStringsArray } from "../util/isTemplateStringsArray.ts"
-import { message } from "./message.ts"
-
-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(fixTemplateStrings(e0), ...rest) : e0,
-  }])
-}

package/L/user.ts

@@ -1,19 +0,0 @@
-import type { LEvent } from "../LEvent.ts"
-import type { Rune } from "../Rune.ts"
-import { fixTemplateStrings } from "../util/fixTemplateStrings.ts"
-import { isTemplateStringsArray } from "../util/isTemplateStringsArray.ts"
-import { message } from "./message.ts"
-
-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(fixTemplateStrings(e0), ...rest) : e0,
-  }])
-}

package/LiminalAssertionError.ts

@@ -1,19 +0,0 @@
-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,16 +0,0 @@
-export interface Message {
-  readonly role: MessageRole
-  readonly parts: Array<Content>
-}
-
-export type MessageRole = "system" | "user" | "assistant"
-
-export type Content = {
-  readonly part: string
-  readonly alt?: never
-  readonly mime?: never
-} | {
-  readonly part: URL
-  readonly alt: string
-  readonly mime?: string
-}

package/Rune.test.ts

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

package/Rune.ts

@@ -1,60 +0,0 @@
-import type { Context } from "./Context.ts"
-import type { Definition } from "./Definition.ts"
-
-/**
- * `Rune` represents a computational unit within a Strand execution.
- * It is a specialized protocol for expressing different kinds of operations
- * that can be yielded from generator functions to control message state
- * and concurrency within the Liminal runtime.
- * @template E The event type this Rune can handle
- */
-export interface Rune<E> {
-  [RuneKey]: true
-  instruction: RuneInstruction<E>
-}
-
-export type RuneInstruction<E> =
-  | RuneInstruction.Continue
-  | RuneInstruction.Emit<E>
-  | RuneInstruction.Reflect
-  | RuneInstruction.CreateChild
-export namespace RuneInstruction {
-  /** Tells the runtime to call this function and and pass the result to the next iteration. */
-  export interface Continue {
-    kind: "continue"
-    debug: string
-    f: () => any
-  }
-
-  /** Dispatch an event to the registered handler. */
-  export interface Emit<E> {
-    kind: "emit"
-    event: E
-  }
-
-  /** Tells the runtime to provide a reference to the current strand */
-  export interface Reflect {
-    kind: "reflect"
-  }
-
-  /** Creates a nested execution context with its own definition. */
-  export interface CreateChild {
-    kind: "create_child"
-    definition: Definition
-    context?: Context | undefined
-  }
-}
-
-export namespace Rune {
-  /** Extract the event type from a Rune type. */
-  export type E<X extends Rune<any>> = X extends Rune<infer E> ? E : never
-
-  /** Type guard to check if a value is a Rune. */
-  export function is(value: unknown): value is Rune<any> {
-    return typeof value === "object" && value !== null && RuneKey in value
-  }
-}
-
-/** Symbol used to identify Rune objects. */
-export const RuneKey: unique symbol = Symbol.for("liminal/RuneKey")
-export type RuneKey = typeof RuneKey

package/Schema.ts

@@ -1,185 +0,0 @@
-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>