liminal 0.5.2 → 0.5.4

package/index.ts

@@ -1,41 +1,13 @@
-export * from "./Action.ts"
-export * from "./actions/appendMessage.ts"
+export * as _util from "liminal-util"
 export * from "./Agent.ts"
-export * from "./events/Aborted.ts"
-export * from "./events/Embedded.ts"
-export * from "./events/EmbeddingRequested.ts"
-export * from "./events/Emitted.ts"
-export * from "./events/EventBase.ts"
-export * from "./events/EventHandler.ts"
-export * from "./events/EventResolved.ts"
-export * from "./events/EventResolved.ts"
-export * from "./events/EventResolved.ts"
-export * from "./events/InferenceRequested.ts"
-export * from "./events/Inferred.ts"
-export * from "./events/isScopeChildEvent.ts"
-export * from "./events/isScopeDescendantEvent.ts"
-export * from "./events/LEvent.ts"
-export * from "./events/MessageAppended.ts"
-export * from "./events/MessageRemoved.ts"
-export * from "./events/MessagesSet.ts"
-export * from "./events/ModelPushed.ts"
-export * from "./events/ModelRemoved.ts"
-export * from "./events/Returned.ts"
-export * from "./events/Threw.ts"
-export * from "./events/ToolCalled.ts"
-export * from "./events/ToolDisabled.ts"
-export * from "./events/ToolEnabled.ts"
-export * from "./Exec.ts"
-export * as L from "./L.ts"
-export * from "./LiminalAssertionError.ts"
-export * from "./LiminalConfig.ts"
+export * from "./EventBase.ts"
+export * from "./Fiber.ts"
+export * as L from "./L/L.ts"
+export * from "./LEvent.ts"
 export * from "./Message.ts"
 export * from "./Model.ts"
-export * from "./Scope.ts"
-export * from "./Spec.ts"
-export * from "./Tool.ts"
-export * from "./types/non_factories.ts"
-export * from "./util/JSONKey.ts"
-export * from "./util/JSONObject.ts"
-export * from "./util/JSONValue.ts"
-export * as _util from "./util/util.ts"
+export * from "./Rune.ts"
+export * from "./Runic.ts"
+export * from "./state/MessageRegistry.ts"
+export * from "./state/ModelRegistry.ts"
+export * from "./state/StateMap.ts"

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.5.2",
+  "version": "0.5.4",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",
@@ -11,21 +11,17 @@
     "directory": "liminal"
   },
   "type": "module",
-  "description": "Liminal is a model-agnostic library for conversation state management.",
+  "description": "Primitives for composing model-agnostic agents using TypeScript generator functions.",
   "bin": {
     "liminal": "./dist/cli/main.js"
   },
   "exports": {
-    ".": "./dist/index.js",
-    "./testing": "./dist/testing/index.js",
-    "./types": "./dist/types/index.js"
+    ".": "./dist/index.js"
   },
   "dependencies": {
-    "standard-json-schema": "^0.1.1"
-  },
-  "peerDependencies": {
-    "@standard-schema/spec": "^1.0.0",
-    "conditional-type-checks": "^1.0.6"
+    "conditional-type-checks": "^1.0.6",
+    "liminal-schema": "^0.0.2",
+    "liminal-util": "^0.0.2"
   },
   "peerDependenciesMeta": {
     "conditional-type-checks": {

package/run.ts

@@ -0,0 +1,39 @@
+import type { FiberConfig } from "./Fiber.ts"
+import { Runic } from "./Runic.ts"
+import { context } from "./state/Context.ts"
+
+export async function run<X extends Runic>(
+  runic: X,
+  config: FiberConfig<Runic.T<X>>,
+): Promise<Runic.T<X>> {
+  const { promise, resolve, reject } = Promise.withResolvers<Runic.T<X>>()
+  if (config.signal) {
+    if (config.signal.aborted) {
+      reject(config.signal.reason)
+      return await promise
+    } else {
+      config.signal.addEventListener("abort", () => {
+        reject(config.signal?.reason)
+      })
+    }
+  }
+  queueMicrotask(() =>
+    context.fork(async () => {
+      const iterator = Runic.unwrap(runic)
+      let nextArg: any
+      try {
+        let current = await iterator.next(config)
+        while (!current.done) {
+          const rune = current.value
+          nextArg = await rune(config)
+          current = await iterator.next(nextArg)
+        }
+        const { value } = current
+        resolve(value)
+      } catch (reason: unknown) {
+        reject(reason)
+      }
+    })
+  )
+  return await promise
+}

package/state/Context.ts

@@ -0,0 +1,19 @@
+import { AsyncLocalStorage } from "node:async_hooks"
+import { StateMap } from "./StateMap"
+
+class Context extends AsyncLocalStorage<StateMap> {
+  get(): StateMap {
+    let state = this.getStore()
+    if (!state) {
+      state = new StateMap()
+      this.enterWith(state)
+    }
+    return state
+  }
+
+  fork<T>(f: () => Promise<T>): Promise<T> {
+    return this.run(this.get(), f)
+  }
+}
+
+export const context = new Context()

package/state/MessageRegistry.ts

@@ -0,0 +1,21 @@
+import type { Message } from "../Message.ts"
+
+// TODO: marks and tags
+export class MessageRegistry {
+  static make(messageRegistry?: MessageRegistry) {
+    return new MessageRegistry(messageRegistry?.messages ? [...messageRegistry?.messages] : undefined)
+  }
+
+  messages: Array<Message>
+  constructor(messages: Iterable<Message> = []) {
+    this.messages = Array.from(messages)
+  }
+
+  clone() {
+    return new MessageRegistry([...this.messages])
+  }
+
+  append(message: Message) {
+    this.messages.push(message)
+  }
+}

package/state/ModelConfig.ts

@@ -0,0 +1,49 @@
+export class ModelConfig {
+  static from(config: Partial<ModelConfig>) {
+    return Object.assign(new ModelConfig(), config)
+  }
+
+  /** Seed used for deterministic sampling. */
+  declare seed?: number
+  /** Logit bias modifies the likelihood of specific tokens appearing. */
+  declare logitBias?: Record<string, number>
+  /** Sampling configuration. */
+  declare sampling?: SamplerConfig
+
+  /** Creates a copy of the configuration. */
+  clone() {
+    return Object.assign(new ModelConfig(), {
+      ...this,
+      logitBias: { ...this.logitBias },
+      sampling: {
+        ...this.sampling,
+        stopSequences: [...(this.sampling?.stopSequences ?? [])],
+        penalty: { ...this.sampling?.penalty },
+      },
+    })
+  }
+}
+
+export interface SamplerConfig {
+  /** The maximum number of tokens to generate. */
+  maxTokens?: number
+  /** Temperature controls randomness in generation (0.0-2.0). */
+  temperature?: number
+  /** Cumulative probability cutoff for nucleus sampling (0.0-1.0). */
+  topP?: number
+  /** The number of tokens to consider in top-k sampling. */
+  topk?: number
+  /** Stop sequences is the list of sequences to stop generation. */
+  stopSequences?: Array<string>
+  /** Penalty configuration. */
+  penalty?: PenaltyConfig
+}
+
+export interface PenaltyConfig {
+  /** Presence penalty adjusts the likelihood of token repetition (-2.0 to 2.0). */
+  presence?: number
+  /** Frequency penalty penalizes tokens based on their frequency (-2.0 to 2.0). */
+  frequency?: number
+  /** Repetition penalty range defines how many tokens back repetition penalties apply. */
+  repetitionRange?: number
+}

package/state/ModelRegistry.ts

@@ -0,0 +1,65 @@
+import type { Model } from "../Model.ts"
+
+/** An intrusive list for storing `Model`s. */
+export class ModelRegistry {
+  static make(modelRegistry?: ModelRegistry) {
+    const instance = new ModelRegistry()
+    if (modelRegistry) {
+      for (let node = modelRegistry.head; node; node = node.next) {
+        instance.register(node.model)
+      }
+    }
+    return instance
+  }
+
+  declare head?: ModelRegistryNode | undefined
+  declare tail?: ModelRegistryNode | undefined
+
+  clone(): ModelRegistry {
+    const clone = new ModelRegistry()
+    for (let node = this?.head; node; node = node.next) {
+      clone.register(node.model)
+    }
+    return clone
+  }
+
+  peek(): Model | undefined {
+    return this.tail?.model
+  }
+
+  register(value: Model): ModelRegistryNode {
+    const node: ModelRegistryNode = {
+      prev: this.tail,
+      model: value,
+    }
+    if (this.tail) {
+      this.tail.next = node
+    } else {
+      this.head = node
+    }
+    this.tail = node
+    return node
+  }
+
+  remove(node: ModelRegistryNode): void {
+    if (node.prev) {
+      node.prev.next = node.next
+    }
+    if (node.next) {
+      node.next.prev = node.prev
+    }
+    if (node === this.head) {
+      this.head = node.next
+    }
+    if (node === this.tail) {
+      this.tail = node.prev
+    }
+    node.prev = node.next = undefined
+  }
+}
+
+export interface ModelRegistryNode {
+  prev: ModelRegistryNode | undefined
+  model: Model
+  next?: ModelRegistryNode | undefined
+}

package/state/StateMap.ts

@@ -0,0 +1,24 @@
+export class StateMap extends Map<StateFactory, Cloneable> {
+  clone(): StateMap {
+    const clone = new StateMap()
+    for (const [key, value] of this.entries()) {
+      clone.set(key, value.clone())
+    }
+    return clone
+  }
+
+  getOrInit<T extends Cloneable>(factory: StateFactory<T>): T {
+    let instance = this.get(factory)
+    if (!instance) {
+      instance = factory()
+      this.set(factory, instance)
+    }
+    return instance as never
+  }
+}
+
+export type StateFactory<T = any> = (instance?: T) => T
+
+export interface Cloneable {
+  clone(): this
+}

package/tsconfig.json

@@ -4,5 +4,9 @@
     "noEmit": false,
     "outDir": "dist"
   },
-  "include": ["."]
+  "include": ["."],
+  "references": [
+    { "path": "../liminal-schema" },
+    { "path": "../liminal-util" }
+  ]
 }

package/Action.ts

@@ -1,29 +0,0 @@
-import type { Scope } from "./Scope.ts"
-import type { Spec } from "./Spec.ts"
-import type { PromiseOr } from "./util/PromiseOr.ts"
-
-export interface Action<K extends string = string, S extends Spec = Spec> {
-  "": S
-  type: K
-  [ActionKey]: true
-  trace: string
-  reducer(this: this, scope: Scope): PromiseOr<Scope>
-}
-
-export type ActionReducer<K extends string, S extends Spec> = (this: Action<K, S>, scope: Scope) => PromiseOr<Scope>
-
-export function Action<K extends string, S extends Spec>(type: K, reducer: ActionReducer<K, S>): Action<K, S> {
-  return ({
-    type,
-    [ActionKey]: true,
-    trace: new Error().stack!,
-    reducer,
-  } satisfies Omit<Action<K, S>, "">) as never
-}
-
-export type ActionKey = typeof ActionKey
-export const ActionKey = Symbol("Liminal/Action")
-
-export function isAction(value: unknown): value is Action {
-  return typeof value === "object" && value !== null && ActionKey in value
-}

package/Exec.ts

@@ -1,51 +0,0 @@
-import type { Action } from "./Action.ts"
-import type { Agent } from "./Agent.ts"
-import type { EventHandler } from "./events/EventHandler.ts"
-import type { EventResolved, ExtractEventResolved } from "./events/EventResolved.ts"
-import type { LanguageModel } from "./Model.ts"
-import { RootScope, type Scope } from "./Scope.ts"
-import type { FromEntries } from "./util/FromEntries.ts"
-import type { JSONKey } from "./util/JSONKey.ts"
-
-export interface ExecConfig {
-  default: LanguageModel
-  args?: Record<JSONKey, any>
-  signal?: AbortSignal
-  handler?: EventHandler
-}
-
-export type ExtractExecConfig<Y extends Action> =
-  & {
-    default: LanguageModel
-    signal?: AbortSignal
-    handler?: EventHandler<Extract<ExtractEventResolved<Y[""]> & {}, EventResolved>>
-  }
-  & (
-    [Y[""]["Entry"]] extends [never] ? {
-        args?: undefined
-      }
-      : {
-        args: FromEntries<Y[""]["Entry"]>
-      }
-  )
-
-export async function exec<Y extends Action, T>(
-  createAgent: () => Agent<Y, T>,
-  config: ExtractExecConfig<Y>,
-): Promise<T> {
-  let scope: Scope = RootScope(config as never)
-  scope = await scope.reduce(createAgent())
-  const { signal: { aborted, reason } } = scope.controller
-  if (aborted) {
-    scope.event({
-      type: "aborted",
-      reason,
-    })
-    throw reason
-  }
-  scope.event({
-    type: "returned",
-    value: scope.value,
-  })
-  return scope.value
-}

package/L.ts

@@ -1,24 +0,0 @@
-export * from "./_.ts"
-export * from "./actions/abort.ts"
-export * from "./actions/actions_derived/clear.ts"
-export * from "./actions/actions_derived/declareModel.ts"
-export * from "./actions/actions_derived/messages.ts"
-export * from "./actions/actions_derived/readers_derived.ts"
-export * from "./actions/appendMessage.ts"
-export * from "./actions/await.ts"
-export * from "./actions/branch.ts"
-export * from "./actions/catch.ts"
-export * from "./actions/declareArg.ts"
-export * from "./actions/disableTool.ts"
-export * from "./actions/embed.ts"
-export * from "./actions/emit.ts"
-export * from "./actions/enableTool.ts"
-export * from "./actions/infer.ts"
-export * from "./actions/messages.ts"
-export * from "./actions/pushModel.ts"
-export * from "./actions/scope.ts"
-export * from "./actions/section.ts"
-export * from "./actions/throw.ts"
-export * from "./types/factories.ts"
-
-export * from "./actions/actions_derived/metatype.ts"

package/LiminalAssertionError.ts

@@ -1,3 +0,0 @@
-export class LiminalAssertionError extends Error {
-  override readonly name = "LiminalAssertionError"
-}

package/LiminalConfig.ts

@@ -1,7 +0,0 @@
-import type { ExecConfig } from "./Exec.ts"
-
-export interface LiminalConfig extends ExecConfig {
-  agents?: string
-  silent?: boolean
-  write?: boolean | string
-}

package/PathLike.ts

@@ -1,17 +0,0 @@
-import type { _ } from "./_.ts"
-import type { JSONKey } from "./util/JSONKey.ts"
-
-export type Path = Array<JSONKey>
-export declare namespace Path {
-  export type FromPathLike<P extends PathLike> = P extends [infer E0 extends KeyLike, ...infer ERest extends PathLike]
-    ? [E0 extends JSONKey ? E0 : JSONKey, ...FromPathLike<ERest>]
-    : []
-}
-
-export type KeyLike = JSONKey | _
-export type PathLike = Array<KeyLike>
-export declare namespace PathLike {
-  export type FromPath<P extends Path> = P extends [infer E0, ...infer ERest extends Path]
-    ? [E0 | _, ...FromPath<ERest>]
-    : []
-}

package/Scope.ts

@@ -1,152 +0,0 @@
-import type { Action } from "./Action.ts"
-import type { Agent } from "./Agent.ts"
-import type { EventHandler } from "./events/EventHandler.ts"
-import type { LEvent } from "./events/LEvent.ts"
-import type { ExecConfig } from "./Exec.ts"
-import type { Message } from "./Message.ts"
-import type { EmbeddingModel, LanguageModel } from "./Model.ts"
-import type { Tool } from "./Tool.ts"
-import type { JSONKey } from "./util/JSONKey.ts"
-
-export type Scope = RootScope | ChildScope
-
-export interface RootScope extends ScopeBase<RootScopeType> {}
-export interface ChildScope extends ScopeBase<ChildScopeType> {
-  readonly parent: Scope
-}
-
-export type RootScopeType = "root"
-export type ChildScopeType = "catch" | "tool" | "branch" | "branch_arm" | "set_messages" | "run_section"
-export type ScopeType = RootScopeType | ChildScopeType
-
-export interface ScopeBase<Type extends ScopeType> {
-  readonly type: Type
-  readonly path: Array<JSONKey>
-  readonly args?: Record<JSONKey, any>
-  readonly controller: AbortController
-  readonly messages: Set<Message>
-  readonly tools: Set<Tool>
-  readonly nextArg?: any
-  readonly value: any
-  readonly thrown?: any
-  readonly languageModels: Set<LanguageModel>
-  readonly embeddingModels: Set<EmbeddingModel>
-  readonly handler?: EventHandler
-  readonly childForkCounts: Record<JSONKey, number>
-  readonly index: number
-  readonly sections: Set<Section>
-
-  reduce(agent: Agent): Promise<Scope>
-  fork(
-    source: ChildScopeType,
-    subpath: Array<JSONKey>,
-    overrides?: Partial<ChildScope>,
-  ): Scope
-  event(event: LEvent): void
-}
-
-export interface Section {
-  sectionKey: JSONKey
-  messages: Set<Message>
-}
-
-export function RootScope({
-  signal,
-  args,
-  handler,
-  default: defaultLanguageModel,
-}: ExecConfig): RootScope {
-  const controller = new AbortController()
-  signal?.addEventListener("abort", () => {
-    controller.abort()
-  })
-  return {
-    type: "root",
-    args,
-    controller,
-    messages: new Set(),
-    tools: new Set(),
-    value: undefined,
-    path: [],
-    languageModels: new Set([defaultLanguageModel]),
-    embeddingModels: new Set(),
-    childForkCounts: {},
-    sections: new Set(),
-    index: 0,
-    reduce,
-    fork,
-    handler,
-    event,
-  }
-}
-
-async function reduce(this: Scope, agent: Agent): Promise<Scope> {
-  const { signal } = this.controller
-  let scope = { ...this }
-  if (signal.aborted) return scope
-  let value: unknown
-  try {
-    let current = await agent.next()
-    while (!current.done) {
-      const { value } = current
-      if (signal.aborted) return scope
-      scope = await (value as Action).reducer(scope)
-      if (signal.aborted) return scope
-      current = await agent.next(scope.nextArg)
-    }
-    value = current.value
-  } catch (thrown: unknown) {
-    scope.controller.abort(thrown)
-  }
-  return {
-    ...scope,
-    value,
-    nextArg: undefined,
-  }
-}
-
-function fork(
-  this: Scope,
-  type: ChildScopeType,
-  subpath: Array<JSONKey>,
-  overrides?: Partial<ChildScope>,
-): ChildScope {
-  const subpathStr = subpath.join(" ")
-  let index = this.childForkCounts[subpathStr]
-  if (typeof index === "number") {
-    this.childForkCounts[subpathStr]! += 1
-  } else {
-    index = 0
-    this.childForkCounts[subpathStr] = 1
-  }
-  const f: ChildScope = {
-    type,
-    controller: this.controller,
-    args: this.args,
-    messages: new Set(this.messages),
-    tools: new Set(),
-    languageModels: new Set(this.languageModels),
-    embeddingModels: new Set(this.embeddingModels),
-    childForkCounts: {},
-    handler: this.handler,
-    path: [...this.path, ...subpath],
-    parent: this,
-    value: undefined,
-    index,
-    sections: new Set(this.sections),
-    reduce,
-    fork,
-    event,
-    ...overrides ?? {},
-  }
-  f.event({ type: "forked" })
-  return f
-}
-
-function event(this: ChildScope, event: LEvent): void {
-  this.handler?.({
-    scope: this.path,
-    index: this.index,
-    ...event,
-  })
-}

package/Spec.ts

@@ -1,29 +0,0 @@
-import type { LEvent } from "./events/LEvent.ts"
-import type { Expand } from "./util/Expand.ts"
-import type { JSONEntry } from "./util/JSONEntry.ts"
-import type { JSONKey } from "./util/JSONKey.ts"
-
-export interface Spec<
-  Key extends JSONKey = JSONKey,
-  Event extends LEvent = LEvent,
-  Spec_ extends Spec = any,
-  Entry_ extends JSONEntry = JSONEntry,
-  Throw = any,
-  Value = any,
-> {
-  Event: Event
-  Child: [Key, Spec_]
-  Entry: Entry_
-  Throw: Throw
-  Value: Value
-}
-
-export declare namespace Spec {
-  export type Make<P extends Partial<Spec>> = Expand<{
-    Event: [unknown] extends [P["Event"]] ? never : P["Event"]
-    Child: [unknown] extends [P["Child"]] ? never : P["Child"]
-    Throw: [unknown] extends [P["Throw"]] ? never : P["Throw"]
-    Entry: [unknown] extends [P["Entry"]] ? never : P["Entry"]
-    Value: [unknown] extends [P["Value"]] ? never : P["Value"]
-  }>
-}