liminal 0.5.2 → 0.5.4

package/Agent.ts

@@ -1,10 +1,28 @@
-import type { Action } from "./Action.ts"
-import type { DeferredOr } from "./util/DeferredOr.ts"
-import type { IteratorLike } from "./util/IteratorLike.ts"
+import type { FiberConfig, FiberInfo } from "./Fiber.ts"
+import { run } from "./run.ts"
+import type { Rune, RuneKey } from "./Rune.ts"
+import type { Runic } from "./Runic.ts"
 
-export type Agent<Y extends Action = Action, R = any> = IteratorLike<Y, R>
+export interface Agent<out T, out E> extends PromiseLike<T> {
+  T: T
+  E: E
+}
 
-export type AgentLike<Y extends Action = Action, R = any> = DeferredOr<Agent<Y, R>>
+export function Agent<Y extends Rune, T>(runic: Runic<Y, T>, config?: AgentConfig<Y, T>): Agent<T, Rune.E<Y>> {
+  return {
+    then(onfulfilled, onrejected) {
+      return run(runic, {
+        T: null!,
+        globals: {
+          handler: config?.handler ?? (() => {}),
+        },
+        signal: config?.signal,
+      }).then(onfulfilled, onrejected)
+    },
+  } satisfies Omit<Agent<T, Rune.E<Y>>, "E" | "T"> as never
+}
 
-export type AgentLikeY<A extends AgentLike> = A extends AgentLike<infer Y> ? Y : never
-export type AgentLikeT<A extends AgentLike> = A extends AgentLike<Action, infer T> ? T : never
+export interface AgentConfig<Y extends Rune, _T> {
+  handler: (event: Y[RuneKey], info: FiberInfo) => void
+  signal?: AbortSignal
+}

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # liminal
 
+## 0.5.4
+
+### Patch Changes
+
+- 284adab: Reintroduce AI SDK adapter and begin simplifying runic execution.
+- Updated dependencies [284adab]
+  - liminal-schema@0.0.2
+  - liminal-util@0.0.2
+
+## 0.5.3
+
+### Patch Changes
+
+- 2d3a717: Complete rewrite of Liminal. Includes new packages for various integrations.
+- Updated dependencies [2d3a717]
+- Updated dependencies [ff04b9f]
+  - liminal-schema@0.0.1
+  - liminal-util@0.0.1
+
 ## 0.5.2
 
 ### Patch Changes

package/EventBase.ts

@@ -0,0 +1,13 @@
+import { inspect, type InspectOptions } from "node:util"
+
+export abstract class EventBase<B extends symbol, K extends string> {
+  constructor(
+    readonly brand: B,
+    readonly type: K,
+  ) {}
+
+  [inspect.custom](depth: number, options: InspectOptions) {
+    const { brand: _0, type: _1, ...rest } = this
+    return `${this.constructor.name} ` + inspect(rest, { ...options, depth })
+  }
+}

package/Fiber.ts

@@ -0,0 +1,67 @@
+import { assert } from "liminal-util"
+import type { Globals } from "./Globals.ts"
+import { FiberCreated, FiberResolved, FiberStarted } from "./LEvent.ts"
+import type { Rune } from "./Rune.ts"
+import { Runic } from "./Runic.ts"
+import type { StateMap } from "./state/StateMap.ts"
+
+export interface Fiber<out T = any> {
+  T: T
+  runic: Runic<Rune, T>
+  globals: Globals
+  parent: Fiber<any> | undefined
+  fiberId: number
+  handler<E>(event: E): void
+  run(): Promise<T>
+}
+
+export interface FiberInfo {
+  fiber: number
+  timestamp: number
+}
+
+let nextFiberId = 0
+
+export interface FiberConfig<T = any> {
+  T: T
+  signal?: AbortSignal | undefined
+  globals: Globals
+  state?: StateMap | undefined
+}
+
+export function handler<E>(fiberConfig: FiberConfig, event: E): void {
+  fiberConfig.globals.handler(event, {
+    // fiber: fiberConfig.fiberId,
+    timestamp: Date.now(),
+  })
+}
+
+// export interface FiberConfig<T> {
+//   parent?: Fiber<any>
+//   globals: Globals
+//   runic: Runic<Rune, T>
+//   signal?: AbortSignal | undefined
+// }
+
+// export function Fiber<T>(config: FiberConfig<T>): Fiber<T> {
+//   const fiber = {
+//     runic: config.runic,
+//     globals: config.globals,
+//     parent: config.parent,
+//     fiberId: nextFiberId++,
+//     handler,
+//     run,
+//   } satisfies Omit<Fiber<T>, "T"> as Fiber<T>
+
+//   fiber.handler(new FiberCreated())
+//   return fiber
+
+//   async function run(this: Fiber<T>): Promise<T> {
+//     fiber.handler(new FiberStarted())
+//     const iterator = Runic.unwrap(this.runic)
+//     const result = await iterator.next()
+//     assert(result.done)
+//     fiber.handler(new FiberResolved(result.value))
+//     return result.value
+//   }
+// }

package/Globals.ts

@@ -0,0 +1,10 @@
+export interface Globals {
+  handler<E = any>(event: E, info: EventInfo): void
+}
+
+export interface EventInfo {
+  // fiber: number
+  timestamp: number
+  // group
+  // depth
+}

package/L/L.ts

@@ -0,0 +1,12 @@
+export * from "liminal-schema/factories"
+export * from "./_infer.ts"
+export * from "./_message.ts"
+export * from "./assistant.ts"
+export * from "./branch.ts"
+export * from "./emit.ts"
+export * from "./fork.ts"
+export * from "./join.ts"
+export * from "./model.ts"
+export * from "./self.ts"
+export * from "./system.ts"
+export * from "./user.ts"

package/L/_infer.ts

@@ -0,0 +1,40 @@
+import type { SchemaObject } from "liminal-schema"
+import { assert } from "liminal-util"
+import { InferenceRequested, Inferred, type LEvent } from "../LEvent.ts"
+import type { Rune } from "../Rune.ts"
+import { context } from "../state/Context.ts"
+import { MessageRegistry } from "../state/MessageRegistry.ts"
+import { ModelRegistry } from "../state/ModelRegistry.ts"
+import { emit } from "./emit.ts"
+import { rune } from "./rune.ts"
+
+export function* _infer(schema?: SchemaObject): Generator<Rune<LEvent>, string> {
+  const state = context.get()
+  const modelRegistry = state.getOrInit(ModelRegistry.make)
+  const model = modelRegistry.peek()
+  const messageRegistry = state.getOrInit(MessageRegistry.make)
+  const counter = state.getOrInit(InferenceRequestCounter)
+  assert(model)
+  const requestId = counter.next()
+  yield* emit(new InferenceRequested(requestId, schema))
+  const inference = yield* rune(() => model.resolve(messageRegistry.messages, schema))
+  yield* emit(new Inferred(requestId, inference))
+  return inference
+}
+
+function InferenceRequestCounter(instance?: Counter) {
+  return {
+    count: instance?.count ?? 0,
+    next() {
+      return this.count++
+    },
+    clone() {
+      return InferenceRequestCounter(this)
+    },
+  }
+}
+
+interface Counter {
+  count: number
+  next(): number
+}

package/L/_message.ts

@@ -0,0 +1,16 @@
+import { type LEvent, MessageAppended } from "../LEvent.ts"
+import type { ContentPart, Message, MessageRole } from "../Message.ts"
+import type { Rune } from "../Rune.ts"
+import { context } from "../state/Context.ts"
+import { MessageRegistry } from "../state/MessageRegistry.ts"
+import { emit } from "./emit.ts"
+
+export interface _message extends Generator<Rune<LEvent>, void> {}
+
+export function* _message(role: MessageRole, content: Array<ContentPart>): _message {
+  const state = context.get()
+  const messageRegistry = state.getOrInit(MessageRegistry.make)
+  const message: Message = { role, content }
+  yield* emit(new MessageAppended(message))
+  messageRegistry.append(message)
+}

package/L/all.ts

@@ -0,0 +1,11 @@
+import type { Fiber } from "../Fiber.ts"
+import type { Rune } from "../Rune.ts"
+import { rune } from "./rune.ts"
+
+export interface all<A extends Array<any>> extends Generator<Rune<never>, Fiber<A>> {}
+
+export function* all<XA extends Array<Fiber>>(
+  ...fibers: XA
+): all<{ [I in keyof XA]: XA[I]["T"] }> {
+  return (yield* rune((_fiber) => Promise.all(fibers.map((fiber) => fiber.run())))) as never
+}

package/L/assistant.ts

@@ -0,0 +1,27 @@
+import { type LType, toJSONSchema, validate } from "liminal-schema"
+import type { LEvent } from "../LEvent.ts"
+import type { Rune } from "../Rune.ts"
+import { _infer } from "./_infer.ts"
+import { _message } from "./_message.ts"
+import { rune } from "./rune.ts"
+
+export interface assistant extends Iterable<Rune<LEvent>, string> {
+  <T>(schema: LType<T>): Generator<Rune<LEvent>, T>
+}
+
+export const assistant: assistant = Object.assign(
+  function*<T>(type: LType<T>): Generator<Rune<LEvent>, T> {
+    const schema = toJSONSchema(type)
+    const inference = yield* _infer(schema)
+    yield* _message("assistant", [{ part: inference }])
+    const input = JSON.parse(inference)
+    return yield* rune(() => validate(type, input))
+  },
+  {
+    *[Symbol.iterator]() {
+      const inference = yield* _infer()
+      yield* _message("assistant", [{ part: inference }])
+      return inference
+    },
+  },
+)

package/L/branch.ts

@@ -0,0 +1,51 @@
+import type { FiberConfig } from "../Fiber.ts"
+import { run } from "../run.ts"
+import { type Rune } from "../Rune.ts"
+import type { Runic } from "../Runic.ts"
+import { context } from "../state/Context.ts"
+import { rune } from "./rune.ts"
+import { self } from "./self.ts"
+
+export interface branch<Y extends Rune, T> extends Generator<Y, T> {}
+
+export function branch<X extends Runic>(runic: X): branch<Runic.Y<X>, Runic.T<X>>
+export function branch<XA extends Array<Runic>>(
+  runics: XA,
+): branch<Runic.Y<XA[number]> | Rune<never>, { [I in keyof XA]: Runic.T<XA[I]> }>
+export function branch<XR extends Record<keyof any, Runic>>(
+  runics: XR,
+): branch<Runic.Y<XR[keyof XR]> | Rune<never>, { [K in keyof XR]: Runic.T<XR[K]> }>
+export function* branch(value: Runic | Array<Runic> | Record<keyof any, Runic>): branch<Rune, any> {
+  const parent = yield* self
+  const { globals } = parent
+  if (Array.isArray(value)) {
+    const runners = value.map((runic) => {
+      const state = context.get()
+      const fiberConfig: FiberConfig = {
+        T: null!,
+        globals,
+        state,
+      }
+      return () => run(runic, fiberConfig)
+    })
+    return yield* rune(() => Promise.all(runners.map((runner) => runner())))
+  } else if (typeof value === "object") {
+    const runners = Object.entries(value).map(([key, runic]) => {
+      const state = context.get()
+      const fiberConfig: FiberConfig = {
+        T: null!,
+        globals,
+        state,
+      }
+      return async () => [key, await run(runic, fiberConfig)]
+    })
+    return yield* rune(() => Promise.all(runners.map((runner) => runner())).then(Object.fromEntries))
+  }
+  const state = context.get()
+  const fiberConfig: FiberConfig = {
+    T: null!,
+    globals,
+    state,
+  }
+  return yield* rune(() => run(typeof value === "function" ? value() : value, fiberConfig))
+}

package/L/emit.ts

@@ -0,0 +1,10 @@
+import type { EnsureNarrow } from "liminal-util"
+import { handler } from "../Fiber.ts"
+import type { Rune } from "../Rune.ts"
+import { rune } from "./rune.ts"
+
+export interface emit<E> extends Generator<Rune<E>, void> {}
+
+export function* emit<const E>(event: EnsureNarrow<E>): emit<E> {
+  yield* rune((fiberConfig) => handler(fiberConfig, event))<E>()
+}

package/L/fork.ts

@@ -0,0 +1,20 @@
+// import type { FiberConfig } from "../Fiber.ts"
+// import type { Rune } from "../Rune.ts"
+// import type { Runic } from "../Runic.ts"
+// import { runic as runic_ } from "./runic.ts"
+// import { self } from "./self.ts"
+
+// export interface fork<Y extends Rune, T> extends Generator<Rune<any> | Y, FiberConfig<T>> {}
+
+// export function* fork<Y extends Rune, T>(runic: Runic<Y, T>): fork<Y, T> {
+//   const parent = yield* self
+//   const { globals, state, signal } = parent
+//   const controller = new AbortController()
+//   const fiberConfig: FiberConfig = {
+//     T: null!,
+//     globals,
+//     signal: controller.signal,
+//     state: state?.clone(),
+//   }
+//   return (yield* runic_(runic, fiberConfig)) as never
+// }

package/L/join.ts

@@ -0,0 +1,9 @@
+import type { Fiber } from "../Fiber.ts"
+import type { Rune } from "../Rune.ts"
+import { rune } from "./rune.ts"
+
+export interface join<X extends Fiber> extends Generator<Rune<never>, X["T"]> {}
+
+export function* join<X extends Fiber>(fiber: X): join<X> {
+  return yield* rune((_fiber) => fiber.run())
+}

package/L/model.ts

@@ -0,0 +1,12 @@
+import type { Model } from "../Model.ts"
+import type { Rune } from "../Rune.ts"
+import { context } from "../state/Context.ts"
+import { ModelRegistry } from "../state/ModelRegistry.ts"
+
+export interface model extends Generator<Rune<never>, void> {}
+
+export function* model(model: Model): model {
+  const state = context.get()
+  const modelRegistry = state.getOrInit(ModelRegistry.make)
+  modelRegistry.register(model)
+}

package/L/namespace.ts

@@ -0,0 +1,11 @@
+// import type { Rune } from "../Rune"
+// import type { Runic } from "../Runic"
+
+// export function* namespace<K extends keyof any, X extends Runic>(
+//   key: K,
+//   runic: X,
+// ): Generator<Rune<never> | Runic.Y<X>, Runic.T<X>> {
+//   const { globals, state } = self_
+//   const namespace = globals.namespace(key)
+//   return yield* rune((fiber) => Fiber(fiber.globals, fiber.parent, runic, state.clone()))
+// }

package/L/rune.ts

@@ -0,0 +1,19 @@
+import type { FiberConfig } from "../Fiber.ts"
+import { type Rune, RuneKey } from "../Rune.ts"
+
+export interface rune<T> extends Iterable<Rune<never>, T> {
+  <E>(): Generator<Rune<E>, T>
+}
+
+export function rune<R>(source: (fiberConfig: FiberConfig) => R): rune<Awaited<R>> {
+  return Object.assign(
+    function*<E>(): Generator<Rune<E>, Awaited<R>> {
+      return yield Object.assign(source, { [RuneKey]: {} as never })
+    },
+    {
+      *[Symbol.iterator](): Generator<Rune<never>, Awaited<R>> {
+        return yield Object.assign(source, { [RuneKey]: {} as never })
+      },
+    },
+  )
+}

package/L/self.ts

@@ -0,0 +1,13 @@
+import type { FiberConfig } from "../Fiber.ts"
+import type { Rune } from "../Rune.ts"
+import { rune } from "./rune.ts"
+
+export interface self {
+  [Symbol.iterator](): Generator<Rune<never>, FiberConfig>
+}
+
+export const self: self = {
+  *[Symbol.iterator]() {
+    return yield* rune((fiberConfig) => fiberConfig)
+  },
+}

package/L/system.ts

@@ -0,0 +1,13 @@
+import { isTemplateStringsArray } from "liminal-util"
+import type { LEvent } from "../LEvent.ts"
+import type { Rune } from "../Rune.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 }])
+}

package/L/user.ts

@@ -0,0 +1,13 @@
+import { isTemplateStringsArray } from "liminal-util"
+import type { LEvent } from "../LEvent.ts"
+import type { Rune } from "../Rune.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 }])
+}

package/LEvent.ts

@@ -0,0 +1,58 @@
+import type { SchemaObject } from "liminal-schema"
+import { EventBase } from "./EventBase.ts"
+import type { Message } from "./Message.ts"
+
+export type LEvent = InferenceRequested | Inferred | MessageAppended | FiberCreated | FiberStarted | FiberResolved
+
+export const LEventTag: unique symbol = Symbol.for("liminal/LEvent")
+export type LEventTag = typeof LEventTag
+
+export class InferenceRequested extends EventBase<LEventTag, "inference_requested"> {
+  declare schema?: SchemaObject
+  constructor(
+    readonly requestId: number,
+    schema?: SchemaObject | undefined,
+  ) {
+    super(LEventTag, "inference_requested")
+    if (schema) {
+      this.schema = schema
+    }
+  }
+}
+
+export class Inferred extends EventBase<LEventTag, "inferred"> {
+  constructor(
+    readonly requestId: number,
+    readonly inference: string,
+  ) {
+    super(LEventTag, "inferred")
+  }
+}
+
+export class MessageAppended extends EventBase<LEventTag, "message_appended"> {
+  constructor(readonly message: Message) {
+    super(LEventTag, "message_appended")
+  }
+}
+
+export class FiberCreated extends EventBase<LEventTag, "fiber_created"> {
+  constructor() {
+    super(LEventTag, "fiber_created")
+  }
+}
+
+export class FiberStarted extends EventBase<LEventTag, "fiber_started"> {
+  constructor() {
+    super(LEventTag, "fiber_started")
+  }
+}
+
+export class FiberResolved extends EventBase<LEventTag, "fiber_resolved"> {
+  constructor(readonly value: any) {
+    super(LEventTag, "fiber_resolved")
+  }
+}
+
+export function isLEvent(value: unknown): value is LEvent {
+  return typeof value === "object" && value !== null && LEventTag in value
+}

package/Message.ts

@@ -1,94 +1,15 @@
-export type Message = Messages[keyof Messages]
-export type Messages = {
-  system: SystemMessage
-  user: UserMessage
-  assistant: AssistantMessage
-  tool: ToolMessage
+export interface Message {
+  readonly role: MessageRole
+  readonly content: Array<ContentPart>
 }
 
-export interface SystemMessage extends MessageBase<"system"> {}
-export interface UserMessage extends MessageBase<"user"> {}
-export interface AssistantMessage extends MessageBase<"assistant"> {}
-export interface ToolMessage extends MessageBase<"tool"> {}
+export type MessageRole = "system" | "user" | "assistant"
 
-interface MessageBase<R extends MessageRole> {
-  readonly role: R
-  readonly content: MessageContents[R]
-}
-
-export type MessageRole = "system" | "user" | "assistant" | "tool"
-
-export type MessageContents = {
-  system: string
-  user: UserContent
-  assistant: AssistantContent
-  tool: ToolContent
-}
-
-export type AssistantContent =
-  | string
-  | ReadonlyArray<TextPart | FilePart | ReasoningPart | RedactedReasoningPart | ToolCallPart>
-
-export type UserContent = string | Array<TextPart | ImagePart | FilePart>
-
-export type ToolContent = Array<ToolContentPart>
-export interface ToolContentPart {
-  readonly type: "tool-result"
-  readonly toolCallId: string
-  readonly toolName: string
-  readonly result: unknown
-  readonly isError?: boolean
-}
-
-export interface TextPart {
-  readonly type: "text"
-  readonly text: string
-}
-
-// TODO: URL?
-export type DataContent = string | Uint8Array | ArrayBuffer | Buffer
-
-export interface FilePart {
-  type: "file"
-  /**
-   * File data. Can either be:
-   *
-   * - data: a base64-encoded string, a Uint8Array, an ArrayBuffer, or a Buffer
-   * - URL: a URL that points to the image
-   */
-  readonly data: DataContent | URL
-  /** Optional filename of the file.  */
-  readonly filename?: string
-  /** Mime type of the file.  */
-  readonly mimeType: string
-}
-
-export interface ReasoningPart {
-  readonly type: "reasoning"
-  /** The reasoning text. */
-  readonly text: string
-  /** An optional signature for verifying that the reasoning originated from the model. */
-  readonly signature?: string
-}
-
-export interface RedactedReasoningPart {
-  readonly type: "redacted-reasoning"
-  /** Redacted reasoning data. */
-  readonly data: string
-}
-
-export interface ToolCallPart {
-  readonly type: "tool-call"
-  /** ID of the tool call. This ID is used to match the tool call with the tool result.  */
-  readonly toolCallId: string
-  /** Name of the tool that is being called.  */
-  readonly toolName: string
-  /** Arguments of the tool call. This is a JSON-serializable object that matches the tool's input schema. */
-  readonly args: unknown
-}
-
-export interface ImagePart {
-  readonly type: "image"
-  readonly image: DataContent | URL
-  readonly mimeType?: string
+export type ContentPart = {
+  readonly part: string
+  readonly alt?: never
+} | {
+  readonly part: URL
+  readonly alt: string
+  readonly mime?: string
 }

package/Model.ts

@@ -1,26 +1,13 @@
-import type { StandardSchemaV1 } from "@standard-schema/spec"
-import type { Action } from "./Action.ts"
-import type { Agent } from "./Agent.ts"
-import type { JSONObject } from "./util/JSONObject.ts"
+import type { Schema } from "liminal-schema"
+import type { Message } from "./Message.ts"
 
-export type Model = LanguageModel | EmbeddingModel
-
-export interface LanguageModel extends ModelBase<"language"> {
-  infer: (type: StandardSchemaV1<JSONObject, any> | undefined) => Agent<Action, any>
-}
-
-export interface EmbeddingModel extends ModelBase<"embedding"> {
-  embed: (value: string) => Promise<Array<number>>
+export interface Model {
+  resolve(messages: Array<Message>, schema?: Schema): Promise<string>
 }
 
-interface ModelBase<K extends ModelType> {
-  type: K
-  vendor: string
-}
-
-export type ModelType = "language" | "embedding"
-
-export type Models = {
-  language: LanguageModel
-  embedding: EmbeddingModel
-}
+// export interface ModelCapabilities {
+//   readonly url: boolean
+//   readonly mimes: Set<string>
+//   readonly reasoning: boolean
+//   readonly structures: boolean
+// }