liminal 0.5.2 → 0.5.3

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 { Fiber, type FiberInfo } from "./Fiber.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) {
+      const root = Fiber({
+        globals: {
+          handler: config?.handler ?? (() => {}),
+        },
+        runic,
+        signal: config?.signal,
+      })
+      return root.run().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,15 @@
 # liminal
 
+## 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/Fiber.ts

@@ -0,0 +1,117 @@
+import type { Globals } from "./Globals.ts"
+import { type FiberCreated, type FiberResolved, type FiberStarted, LEventTag } from "./LEvent.ts"
+import type { Rune } from "./Rune.ts"
+import { Runic } from "./Runic.ts"
+import { DefaultStateMap } from "./state/DefaultStateMap.ts"
+import { StateMap } from "./state/StateMap.ts"
+
+export interface Fiber<out T = any> {
+  T: T
+  parent: Fiber<any> | undefined
+  status: FiberStatus<T>
+  fiberId: number
+  state: StateMap
+  globals: Globals
+  run(this: this): Promise<T>
+  handler<E>(event: E): void
+}
+
+export type FiberStatus<T> = {
+  type: "untouched"
+} | {
+  type: "pending"
+  promise: Promise<T>
+} | {
+  type: "resolved"
+  value: T
+} | {
+  type: "rejected"
+  reason?: unknown
+}
+
+export interface FiberInfo {
+  fiber: number
+  timestamp: number
+}
+
+let nextFiberId = 0
+
+export interface FiberConfig<T> {
+  parent?: Fiber<any>
+  globals: Globals
+  runic: Runic<Rune, T>
+  state?: StateMap | undefined
+  signal?: AbortSignal | undefined
+}
+
+export function Fiber<T>(config: FiberConfig<T>): Fiber<T> {
+  const fiber = {
+    state: config.state ?? new DefaultStateMap(),
+    globals: config.globals,
+    parent: config.parent,
+    status: { type: "untouched" },
+    fiberId: nextFiberId++,
+    run,
+    handler,
+  } satisfies Omit<Fiber<T>, "T"> as Fiber<T>
+  fiber.handler<FiberCreated>({
+    [LEventTag]: "fiber_created",
+  })
+  return fiber
+
+  function handler<E>(this: Fiber<T>, event: E): void {
+    config.globals.handler(event, {
+      fiber: this.fiberId,
+      timestamp: Date.now(),
+    })
+  }
+
+  async function run(this: Fiber<T>): Promise<T> {
+    if (this.status.type === "pending") {
+      return await this.status.promise
+    } else if (this.status.type === "resolved") {
+      return this.status.value
+    } else if (this.status.type === "rejected") {
+      throw this.status.reason
+    }
+    this.handler<FiberStarted>({
+      [LEventTag]: "fiber_started",
+    })
+    const { promise, resolve, reject } = Promise.withResolvers<T>()
+    if (config.signal) {
+      if (config.signal.aborted) {
+        reject(config.signal.reason)
+        return await promise
+      } else {
+        config.signal.addEventListener("abort", () => {
+          reject(config.signal?.reason)
+        })
+      }
+    }
+    this.status = {
+      type: "pending",
+      promise,
+    }
+    queueMicrotask(async () => {
+      const iterator = Runic.unwrap(config.runic)
+      let nextArg: any
+      try {
+        let current = await iterator.next(nextArg)
+        while (!current.done) {
+          const rune = current.value
+          const nextArg = await rune(this)
+          current = await iterator.next(nextArg)
+        }
+        const { value } = current
+        this.handler<FiberResolved>({
+          [LEventTag]: "fiber_resolved",
+          value,
+        })
+        resolve(value)
+      } catch (reason: unknown) {
+        reject(reason)
+      }
+    })
+    return await promise
+  }
+}

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,13 @@
+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 "./state.ts"
+export * from "./system.ts"
+export * from "./user.ts"

package/L/_infer.ts

@@ -0,0 +1,35 @@
+import type { SchemaRoot } from "liminal-schema"
+import { assert } from "liminal-util"
+import { type InferenceRequested, type Inferred, type LEvent, LEventTag } from "../LEvent.ts"
+import type { Rune } from "../Rune.ts"
+import { Counter } from "../state/Counter.ts"
+import { MessageRegistry } from "../state/MessageRegistry.ts"
+import { ModelRegistry } from "../state/ModelRegistry.ts"
+import { emit } from "./emit.ts"
+import { rune } from "./rune.ts"
+import { state } from "./state.ts"
+
+export function* _infer(schema?: SchemaRoot): Generator<Rune<LEvent>, string> {
+  const [modelRegistry, { messages }, counter] = yield* state(
+    ModelRegistry,
+    MessageRegistry,
+    InferenceRequestCounter,
+  )
+  const model = modelRegistry.peek()
+  assert(model)
+  const requestId = counter.next()
+  yield* emit<InferenceRequested>({
+    [LEventTag]: "inference_requested",
+    ...schema && { schema },
+    requestId,
+  })
+  const inference = yield* rune(() => model.resolve(messages, schema))
+  yield* emit<Inferred>({
+    [LEventTag]: "inferred",
+    inference,
+    requestId,
+  })
+  return inference
+}
+
+class InferenceRequestCounter extends Counter {}

package/L/_message.ts

@@ -0,0 +1,18 @@
+import { type LEvent, LEventTag, type MessageAppended } from "../LEvent.ts"
+import type { ContentPart, Message, MessageRole } from "../Message.ts"
+import type { Rune } from "../Rune.ts"
+import { MessageRegistry } from "../state/MessageRegistry.ts"
+import { emit } from "./emit.ts"
+import { state } from "./state.ts"
+
+export interface _message extends Generator<Rune<LEvent>, void> {}
+
+export function* _message(role: MessageRole, content: Array<ContentPart>): _message {
+  const [messageRegistry] = yield* state(MessageRegistry)
+  const message: Message = { role, content }
+  yield* emit<MessageAppended>({
+    [LEventTag]: "message_appended",
+    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,34 @@
+import type { StandardSchemaV1 } from "@standard-schema/spec"
+import { type LType, toJSONSchema } from "liminal-schema"
+import type { json } from "liminal-util"
+import { LiminalAssertionError } from "liminal-util"
+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)
+    const result = yield* rune(() => (type as StandardSchemaV1<json.ValueObject, T>)["~standard"].validate(input))
+    if (result.issues) {
+      throw new LiminalAssertionError(JSON.stringify(result.issues, null, 2))
+    }
+    return result.value
+  },
+  {
+    *[Symbol.iterator]() {
+      const inference = yield* _infer()
+      yield* _message("assistant", [{ part: inference }])
+      return inference
+    },
+  },
+)

package/L/branch.ts

@@ -0,0 +1,45 @@
+import { Fiber } from "../Fiber.ts"
+import { type Rune } from "../Rune.ts"
+import type { Runic } from "../Runic.ts"
+import { all } from "./all.ts"
+import { fork } from "./fork.ts"
+import { join } from "./join.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, state } = parent
+  if (Array.isArray(value)) {
+    const fibers = value.map((runic) =>
+      Fiber({
+        globals,
+        parent,
+        runic,
+        state: state.clone(),
+      })
+    )
+    return yield* join(yield* all(...fibers))
+  } else if (typeof value === "object") {
+    const fibers = Object.values(value).map((runic) =>
+      Fiber({
+        globals,
+        parent,
+        runic,
+        state: state.clone(),
+      })
+    )
+    const resolved = yield* join(yield* all(...fibers))
+    return Object.fromEntries(Object.keys(value).map((key, i) => [key, resolved[i]]))
+  }
+  const fiber = yield* fork(typeof value === "function" ? value() : value, state.clone())
+  return yield* join(fiber)
+}

package/L/emit.ts

@@ -0,0 +1,11 @@
+import type { EnsureNarrow } from "liminal-util"
+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((fiber) => {
+    fiber.handler(event)
+  })<E>()
+}

package/L/fork.ts

@@ -0,0 +1,18 @@
+import { Fiber } from "../Fiber.ts"
+import type { Rune } from "../Rune.ts"
+import type { Runic } from "../Runic.ts"
+import type { StateMap } from "../state/StateMap.ts"
+import { rune } from "./rune.ts"
+
+export interface fork<Y extends Rune, T> extends Generator<Rune<never> | Y, Fiber<T>> {}
+
+export function* fork<Y extends Rune, T>(runic: Runic<Y, T>, state?: StateMap): fork<Y, T> {
+  return yield* rune((parent) =>
+    Fiber({
+      globals: parent.globals,
+      parent,
+      runic,
+      state: state?.clone(),
+    })
+  )
+}

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,11 @@
+import type { Model } from "../Model.ts"
+import type { Rune } from "../Rune.ts"
+import { ModelRegistry } from "../state/ModelRegistry.ts"
+import { state } from "./state.ts"
+
+export interface model extends Generator<Rune<never>, void> {}
+
+export function* model(model: Model): model {
+  const [modelRegistry] = yield* state(ModelRegistry)
+  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 { Fiber } 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: (fiber: Fiber) => 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 { Fiber } from "../Fiber.ts"
+import type { Rune } from "../Rune.ts"
+import { rune } from "./rune.ts"
+
+export interface self {
+  [Symbol.iterator](): Generator<Rune<never>, Fiber>
+}
+
+export const self: self = {
+  *[Symbol.iterator]() {
+    return yield* rune((fiber) => fiber)
+  },
+}

package/L/state.ts

@@ -0,0 +1,20 @@
+import type { Rune } from "../Rune.ts"
+import type { StateConstructor } from "../state/StateMap.ts"
+import { rune } from "./rune.ts"
+
+export interface state<CA extends Array<StateConstructor>>
+  extends Generator<Rune<never>, { [I in keyof CA]: InstanceType<CA[I]> }>
+{}
+
+export function* state<CA extends Array<StateConstructor>>(...constructors: CA): state<CA> {
+  return yield* rune((fiber) => {
+    return constructors.map((constructor) => {
+      let instance = fiber.state.get(constructor)
+      if (!instance) {
+        instance = new constructor()
+        fiber.state.set(constructor, instance)
+      }
+      return instance
+    }) as never
+  })
+}

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,35 @@
+import type { SchemaRoot } from "liminal-schema"
+import type { Message } from "./Message.ts"
+
+export type LEvent = InferenceRequested | Inferred | MessageAppended | FiberCreated | FiberStarted | FiberResolved
+
+export interface InferenceRequested extends LEventBase<"inference_requested"> {
+  requestId: number
+  schema?: SchemaRoot
+}
+
+export interface Inferred extends LEventBase<"inferred"> {
+  requestId: number
+  inference: string
+}
+
+export interface MessageAppended extends LEventBase<"message_appended"> {
+  message: Message
+}
+
+export interface FiberCreated extends LEventBase<"fiber_created"> {}
+export interface FiberStarted extends LEventBase<"fiber_started"> {}
+export interface FiberResolved extends LEventBase<"fiber_resolved"> {
+  value: any
+}
+
+interface LEventBase<K extends string> {
+  [LEventTag]: K
+}
+
+export const LEventTag: unique symbol = Symbol.for("liminal/LEvent")
+export type LEventTag = typeof LEventTag
+
+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
 }