liminal 0.5.16 → 0.6.0

package/L/L.ts

@@ -1,24 +0,0 @@
-export * from "./all.ts"
-export * from "./assistant.ts"
-export * from "./catch.ts"
-export * from "./continuation.ts"
-export * from "./emit.ts"
-export * from "./focus.ts"
-export * from "./infer.ts"
-export * from "./message.ts"
-export * from "./reflect.ts"
-export * from "./run.ts"
-export * from "./schema/anyOf.ts"
-export * from "./schema/array.ts"
-export * from "./schema/boolean.ts"
-export * from "./schema/const.ts"
-export * from "./schema/enum.ts"
-export * from "./schema/integer.ts"
-export * from "./schema/null.ts"
-export * from "./schema/number"
-export * from "./schema/object.ts"
-export * from "./schema/string.ts"
-export * from "./strand.ts"
-export * from "./stream.ts"
-export * from "./system.ts"
-export * from "./user.ts"

package/L/all.ts

@@ -1,39 +0,0 @@
-import type { Context } from "../Context.ts"
-import { Definition } from "../Definition.ts"
-import type { LEvent } from "../LEvent.ts"
-import type { Rune } from "../Rune.ts"
-import { Strand } from "../Strand.ts"
-import { continuation } from "./continuation.ts"
-import { reflect } from "./reflect.ts"
-
-/**
- * Runs multiple definitions in parallel and collects their results.
- * Can be used with an array or object of definitions.
- */
-export function all<A extends Array<Definition>>(
-  definitions: A,
-  context?: Context,
-): Generator<Rune<LEvent> | Definition.Y<A[number]>, { [I in keyof A]: Definition.T<A[I]> }>
-export function all<A extends Record<keyof any, Definition>>(
-  definitions: A,
-  context?: Context,
-): Generator<Rune<LEvent> | Definition.Y<A[keyof A]>, { [K in keyof A]: Definition.T<A[K]> }>
-export function* all<A extends Array<Definition> | Record<keyof any, Definition>>(
-  definitions: A,
-  context?: Context,
-): Generator<Rune<any>, any> { // TODO: although it's somewhat irrelevant, type this
-  const parent = yield* reflect
-  const strands: Array<Strand> = []
-  for (const definition of Array.isArray(definitions) ? definitions : Object.values(definitions)) {
-    strands.push(
-      new Strand(definition, {
-        parent,
-        context: context?.clone() ?? parent.context.clone(),
-      }),
-    )
-  }
-  const results = yield* continuation("all", () => Promise.all(strands))
-  if (Array.isArray(strands)) return results
-  const keys = Object.keys(strands)
-  return Object.fromEntries(results.map((result, i) => [keys[i], result]))
-}

package/L/assistant.ts

@@ -1,28 +0,0 @@
-import type { LEvent } from "../LEvent.ts"
-import type { Rune } from "../Rune.ts"
-import { Schema } from "../Schema.ts"
-import { infer } from "./infer.ts"
-import { message } from "./message.ts"
-
-/**
- * Produces an assistant message when yielded. Can be called with a schema
- * for structured output. Otherwise produces a string.
- */
-export interface assistant extends Iterable<Rune<LEvent>, string> {
-  <T>(schema: Schema<T>): Generator<Rune<LEvent>, T>
-}
-
-export const assistant: assistant = Object.assign(
-  function* assistant<T>(schema: Schema<T>): Generator<Rune<LEvent>, T> {
-    const inference = yield* infer(schema)
-    yield* message("assistant", [{ part: inference }])
-    return JSON.parse(inference)
-  },
-  {
-    *[Symbol.iterator]() {
-      const inference = yield* infer()
-      yield* message("assistant", [{ part: inference }])
-      return inference
-    },
-  },
-)

package/L/catch.ts

@@ -1,38 +0,0 @@
-import type { Definition } from "../Definition.ts"
-import type { LEvent } from "../LEvent.ts"
-import type { Rune } from "../Rune.ts"
-import { Strand } from "../Strand.ts"
-import { continuation } from "./continuation.ts"
-import { reflect } from "./reflect.ts"
-
-export { catch_ as catch }
-
-/**
- * Error handling utility that catches exceptions from running a definition.
- * Returns a result object indicating whether the operation succeeded or failed.
- */
-function* catch_<Y extends Rune<any>, T>(
-  definition: Definition<Y, T>,
-): Generator<Rune<LEvent> | Rune<Y>, CatchResult<T>> {
-  const parent = yield* reflect
-  return yield* continuation("catch", async () => {
-    try {
-      const resolved = await new Strand(definition, {
-        parent,
-        context: parent.context.clone(),
-      }).then()
-      return { resolved }
-    } catch (exception: unknown) {
-      return { rejected: exception }
-    }
-  })
-}
-Object.defineProperty(catch_, "name", { value: "catch" })
-
-export type CatchResult<T> = {
-  resolved: T
-  rejected?: never
-} | {
-  resolved?: never
-  rejected: unknown
-}

package/L/continuation.ts

@@ -1,14 +0,0 @@
-import type { LEvent } from "../LEvent.ts"
-import { Rune, RuneKey } from "../Rune.ts"
-
-/** Yields a continuation rune that executes a function and passes its result to the next iteration. */
-export function* continuation<R>(debug: string, f: () => R): Generator<Rune<LEvent>, Awaited<R>> {
-  return yield {
-    [RuneKey]: true,
-    instruction: {
-      kind: "continue",
-      debug,
-      f,
-    },
-  }
-}

package/L/emit.ts

@@ -1,16 +0,0 @@
-import { Rune, RuneKey } from "../Rune.ts"
-import type { EnsureNarrow } from "../util/EnsureNarrow.ts"
-
-/**
- * Emits an event to be supplied to handlers.
- * Used for broadcasting state changes and triggering side effects.
- */
-export function* emit<E>(event: EnsureNarrow<E>): Generator<Rune<E>, void> {
-  return yield {
-    [RuneKey]: true,
-    instruction: {
-      kind: "emit",
-      event,
-    },
-  }
-}

package/L/focus.ts

@@ -1,17 +0,0 @@
-import type { Adapter } from "../Adapter.ts"
-import type { LEvent } from "../LEvent.ts"
-import { AdapterFocused } from "../LEvent.ts"
-import type { Rune } from "../Rune.ts"
-import { emit } from "./emit.ts"
-import { reflect } from "./reflect.ts"
-
-/**
- * Registers a model in the current context and emits a model registration event.
- * Returns the registered model instance.
- */
-export function* focus(adapter: Adapter): Generator<Rune<LEvent>, Adapter> {
-  const { context: { adapters } } = yield* reflect
-  adapters.register(adapter)
-  yield* emit(new AdapterFocused(adapter))
-  return adapter
-}

package/L/infer.ts

@@ -1,34 +0,0 @@
-import { InferenceRequested, Inferred, type LEvent } from "../LEvent.ts"
-import type { Rune } from "../Rune.ts"
-import { Schema } from "../Schema.ts"
-import { continuation } from "./continuation.ts"
-import { emit } from "./emit.ts"
-import { reflect } from "./reflect.ts"
-
-/**
- * Requests an inference from the current model, optionally with a schema.
- * Emits inference-related events and returns the model's response as a string.
- */
-export function* infer(schema?: Schema): Generator<Rune<LEvent>, string> {
-  const { context: { adapters: models, messages }, signal } = yield* reflect
-  const model = models.ensure()
-  const requestId = crypto.randomUUID()
-  yield* emit(new InferenceRequested(requestId, schema))
-  let inference = yield* continuation(
-    "infer",
-    model
-      .seal({
-        messages,
-        ...schema && {
-          schema: schema.type === "object" ? schema : Schema.wrap(schema),
-        },
-        signal,
-      })
-      .resolve,
-  )
-  if (schema?.type && schema.type !== "object") {
-    inference = JSON.stringify(JSON.parse(inference).value)
-  }
-  yield* emit(new Inferred(requestId, inference))
-  return inference
-}

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,30 +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
-  models?: AdapterRegistry | 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: config?.models ?? 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,29 +0,0 @@
-import type { Schema } from "../../Schema.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(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,18 +0,0 @@
-import type { LEvent } from "../LEvent.ts"
-import type { Rune } from "../Rune.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(e0, ...rest) : e0,
-  }])
-}

package/L/user.ts

@@ -1,18 +0,0 @@
-import type { LEvent } from "../LEvent.ts"
-import type { Rune } from "../Rune.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(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