liminal 0.4.1 → 0.5.2

package/events/Aborted.ts

@@ -0,0 +1,5 @@
+import type { EventBase } from "./EventBase.ts"
+
+export interface Aborted<E = any> extends EventBase<"aborted"> {
+  reason: E
+}

package/events/Embedded.ts

@@ -0,0 +1,6 @@
+import type { EventBase } from "./EventBase.ts"
+
+export interface Embedded extends EventBase<"embedded"> {
+  value: string
+  embedding: Array<number>
+}

package/events/EmbeddingRequested.ts

@@ -0,0 +1,5 @@
+import type { EventBase } from "./EventBase.ts"
+
+export interface EmbeddingRequested extends EventBase<"embedding_requested"> {
+  value: string
+}

package/events/Emitted.ts

@@ -0,0 +1,5 @@
+import type { EventBase } from "./EventBase.ts"
+
+export interface Emitted<E = any> extends EventBase<"emitted"> {
+  value: E
+}

package/events/EventBase.ts

@@ -0,0 +1,3 @@
+export interface EventBase<K extends string> {
+  type: K
+}

package/events/EventHandler.ts

@@ -0,0 +1,3 @@
+import type { EventResolved } from "./EventResolved.ts"
+
+export type EventHandler<E extends EventResolved = EventResolved> = (event: E) => any

package/events/EventResolved.ts

@@ -0,0 +1,30 @@
+import type { Spec } from "../Spec.ts"
+import type { Expand } from "../util/Expand.ts"
+import type { JSONKey } from "../util/JSONKey.ts"
+import type { Forked } from "./Forked.ts"
+import type { LEvent } from "./LEvent.ts"
+import type { Returned } from "./Returned.ts"
+
+export type EventResolved<E extends LEvent = LEvent> = E & {
+  scope: Array<JSONKey>
+  index: number
+}
+
+export type ExtractEventResolved<S extends Spec, P extends Array<JSONKey> = []> =
+  | ([S["Event"]] extends [never] ? never
+    : Expand<
+      {
+        scope: P
+        index: number
+      } & (S["Event"] | (P extends [] ? never : Forked))
+    >)
+  | ([S["Child"]] extends [infer C extends [JSONKey, Spec]] ? {
+      [L in C[0]]: ExtractEventResolved<Extract<C, [L, Spec]>[1], [...P, L]>
+    }[C[0]]
+    : never)
+  | ([S["Value"]] extends [never] ? never : Expand<
+    {
+      scope: P
+      index: number
+    } & Returned<S["Value"]>
+  >)

package/events/Forked.ts

@@ -0,0 +1,3 @@
+import type { EventBase } from "./EventBase"
+
+export interface Forked extends EventBase<"forked"> {}

package/events/InferenceRequested.ts

@@ -0,0 +1,3 @@
+import type { EventBase } from "./EventBase.ts"
+
+export interface InferenceRequested extends EventBase<"inference_requested"> {}

package/events/Inferred.ts

@@ -0,0 +1,6 @@
+import type { JSONValue } from "../util/JSONValue.ts"
+import type { EventBase } from "./EventBase.ts"
+
+export interface Inferred extends EventBase<"inferred"> {
+  value: JSONValue
+}

package/events/LEvent.ts

@@ -0,0 +1,40 @@
+import type { Aborted } from "./Aborted.ts"
+import type { Embedded } from "./Embedded.ts"
+import type { EmbeddingRequested } from "./EmbeddingRequested.ts"
+import type { Emitted } from "./Emitted.ts"
+import type { Forked } from "./Forked.ts"
+import type { InferenceRequested } from "./InferenceRequested.ts"
+import type { Inferred } from "./Inferred.ts"
+import type { MessageAppended } from "./MessageAppended.ts"
+import type { MessageRemoved } from "./MessageRemoved.ts"
+import type { MessagesSet } from "./MessagesSet.ts"
+import type { ModelPushed } from "./ModelPushed.ts"
+import type { ModelRemoved } from "./ModelRemoved.ts"
+import type { Returned } from "./Returned.ts"
+import type { SectionCleared } from "./SectionCleared.ts"
+import type { Sectioned } from "./Sectioned.ts"
+import type { Threw } from "./Threw.ts"
+import type { ToolCalled } from "./ToolCalled.ts"
+import type { ToolDisabled } from "./ToolDisabled.ts"
+import type { ToolEnabled } from "./ToolEnabled.ts"
+
+export type LEvent =
+  | Embedded
+  | EmbeddingRequested
+  | Emitted
+  | Inferred
+  | InferenceRequested
+  | MessageAppended
+  | MessagesSet
+  | Returned
+  | Threw
+  | ToolCalled
+  | ToolDisabled
+  | ToolEnabled
+  | Aborted
+  | MessageRemoved
+  | Forked
+  | ModelPushed
+  | ModelRemoved
+  | Sectioned
+  | SectionCleared

package/events/MessageAppended.ts

@@ -0,0 +1,6 @@
+import type { Message } from "../Message.ts"
+import type { EventBase } from "./EventBase.ts"
+
+export interface MessageAppended<M extends Message = Message> extends EventBase<"message_appended"> {
+  message: M
+}

package/events/MessageRemoved.ts

@@ -0,0 +1,6 @@
+import type { Message } from "../Message.ts"
+import type { EventBase } from "./EventBase.ts"
+
+export interface MessageRemoved extends EventBase<"message_removed"> {
+  message: Message
+}

package/events/MessagesSet.ts

@@ -0,0 +1,6 @@
+import type { Message } from "../Message.ts"
+import type { EventBase } from "./EventBase.ts"
+
+export interface MessagesSet extends EventBase<"messages_set"> {
+  messages: Array<Message>
+}

package/events/ModelPushed.ts

@@ -0,0 +1,10 @@
+import type { ModelType } from "../Model.ts"
+import type { JSONKey } from "../util/JSONKey.ts"
+import type { EventBase } from "./EventBase.ts"
+
+export interface ModelPushed<K extends JSONKey = JSONKey, M extends ModelType = ModelType>
+  extends EventBase<"model_pushed">
+{
+  modelKey: K
+  modelType: M
+}

package/events/ModelRemoved.ts

@@ -0,0 +1,10 @@
+import type { ModelType } from "../Model.ts"
+import type { JSONKey } from "../util/JSONKey.ts"
+import type { EventBase } from "./EventBase.ts"
+
+export interface ModelRemoved<K extends JSONKey = JSONKey, M extends ModelType = ModelType>
+  extends EventBase<"model_removed">
+{
+  modelKey: K
+  modelType: M
+}

package/events/Returned.ts

@@ -0,0 +1,5 @@
+import type { EventBase } from "./EventBase.ts"
+
+export interface Returned<T = any> extends EventBase<"returned"> {
+  value: T
+}

package/events/SectionCleared.ts

@@ -0,0 +1,6 @@
+import type { JSONKey } from "../util/JSONKey.ts"
+import type { EventBase } from "./EventBase.ts"
+
+export interface SectionCleared<K extends JSONKey = JSONKey> extends EventBase<"section_cleared"> {
+  sectionKey: K
+}

package/events/Sectioned.ts

@@ -0,0 +1,6 @@
+import type { JSONKey } from "../util/JSONKey.ts"
+import type { EventBase } from "./EventBase.ts"
+
+export interface Sectioned<K extends JSONKey = JSONKey> extends EventBase<"sectioned"> {
+  sectionKey: K
+}

package/events/Threw.ts

@@ -0,0 +1,5 @@
+import type { EventBase } from "./EventBase.ts"
+
+export interface Threw extends EventBase<"threw"> {
+  thrown: unknown
+}

package/events/ToolCalled.ts

@@ -0,0 +1,7 @@
+import type { JSONKey } from "../util/JSONKey.ts"
+import type { EventBase } from "./EventBase.ts"
+
+export interface ToolCalled<K extends JSONKey = JSONKey, A = any> extends EventBase<"tool_called"> {
+  tool: K
+  args: A
+}

package/events/ToolDisabled.ts

@@ -0,0 +1,6 @@
+import type { JSONKey } from "../util/JSONKey.ts"
+import type { EventBase } from "./EventBase.ts"
+
+export interface ToolDisabled<K extends JSONKey = JSONKey> extends EventBase<"tool_disabled"> {
+  tool: K
+}

package/events/ToolEnabled.ts

@@ -0,0 +1,8 @@
+import type { JSONKey } from "../util/JSONKey.ts"
+import type { EventBase } from "./EventBase.ts"
+
+export interface ToolEnabled<K extends JSONKey = JSONKey> extends EventBase<"tool_enabled"> {
+  tool: K
+  description: string
+  schema: object
+}

package/events/isScopeChildEvent.ts

@@ -0,0 +1,15 @@
+import { type _ } from "../_.ts"
+import type { Path, PathLike } from "../PathLike.ts"
+import type { Expand } from "../util/Expand.ts"
+import type { EventResolved } from "./EventResolved.ts"
+import { isScopeDescendantEvent } from "./isScopeDescendantEvent.ts"
+
+export function isScopeChildEvent<E extends EventResolved, const P extends PathLike.FromPath<E["scope"]>>(
+  event: E,
+  path: P,
+): event is Expand<Extract<E, { scope: Path.FromPathLike<P> }>> {
+  if (event.scope.length !== path.length) {
+    return false
+  }
+  return isScopeDescendantEvent(event, path as never)
+}

package/events/isScopeDescendantEvent.ts

@@ -0,0 +1,30 @@
+import { type _, is_ } from "../_.ts"
+import type { Path, PathLike } from "../PathLike.ts"
+import type { Expand } from "../util/Expand.ts"
+import type { JSONKey } from "../util/JSONKey.ts"
+import type { EventResolved } from "./EventResolved.ts"
+
+export function isScopeDescendantEvent<
+  E extends EventResolved,
+  const P extends PathLike.FromPath<Subscope<E["scope"]>>,
+>(
+  event: E,
+  path: P,
+): event is Expand<Extract<E, { scope: Subscope.Select<E["scope"], Path.FromPathLike<P>> }>> {
+  for (let i = 0; i < path.length; i++) {
+    const currentMatchKey = path[i]!
+    const currentActualKey = event.scope[i]!
+    if (currentActualKey !== currentMatchKey || !is_(currentMatchKey)) {
+      return false
+    }
+  }
+  return true
+}
+
+export type Subscope<A extends Array<JSONKey>> = A extends
+  [infer E0 extends JSONKey, ...infer ERest extends Array<JSONKey>] ? [E0, ...([] | Subscope<ERest>)]
+  : []
+
+export declare namespace Subscope {
+  export type Select<A extends Array<JSONKey>, S extends Array<JSONKey>> = Extract<A, [...S, ...Array<JSONKey>]>
+}

package/index.ts

@@ -0,0 +1,41 @@
+export * from "./Action.ts"
+export * from "./actions/appendMessage.ts"
+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 "./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"

package/package.json

@@ -1,12 +1,35 @@
 {
   "name": "liminal",
-  "version": "0.4.1",
-  "description": "Deprecated",
-  "repository": "",
-  "homepage": "",
-  "main": "lib/index.js",
-  "license": "ISC",
-  "scripts": {},
-  "devDependencies": {},
-  "dependencies": {}
+  "publishConfig": {
+    "access": "public"
+  },
+  "version": "0.5.2",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/harrysolovay/liminal.git",
+    "directory": "liminal"
+  },
+  "type": "module",
+  "description": "Liminal is a model-agnostic library for conversation state management.",
+  "bin": {
+    "liminal": "./dist/cli/main.js"
+  },
+  "exports": {
+    ".": "./dist/index.js",
+    "./testing": "./dist/testing/index.js",
+    "./types": "./dist/types/index.js"
+  },
+  "dependencies": {
+    "standard-json-schema": "^0.1.1"
+  },
+  "peerDependencies": {
+    "@standard-schema/spec": "^1.0.0",
+    "conditional-type-checks": "^1.0.6"
+  },
+  "peerDependenciesMeta": {
+    "conditional-type-checks": {
+      "optional": true
+    }
+  }
 }

package/testing/AgentAssertions.ts

@@ -0,0 +1,17 @@
+import type { IsExact } from "conditional-type-checks"
+import type { Action } from "../Action.ts"
+import type { AgentLike } from "../Agent.ts"
+import type { Spec } from "../Spec.ts"
+import type { Expand } from "../util/Expand.ts"
+
+export interface AgentAssertions<S extends Spec> {
+  assertSpec<A extends Spec>(
+    ...[passes]: IsExact<S, Expand<A>> extends true ? [passes?: true] : [passes: false]
+  ): void
+}
+
+export function AgentAssertions<Y extends Action, R>(_agentLike: AgentLike<Y, R>): AgentAssertions<Y[""]> {
+  return {
+    assertSpec: () => {},
+  }
+}

package/testing/TestEmbeddingModel.ts

@@ -0,0 +1,19 @@
+import type { EmbeddingModel } from "../Model.ts"
+
+export interface TestEmbeddingModelConfig {
+  getEmbedding: () => Promise<Array<number>>
+}
+
+export const defaultTestingEmbeddingModelConfig: TestEmbeddingModelConfig = {
+  getEmbedding: () => Promise.resolve([]),
+}
+
+export function TestEmbeddingModel({
+  getEmbedding,
+}: TestEmbeddingModelConfig = defaultTestingEmbeddingModelConfig): EmbeddingModel {
+  return {
+    type: "embedding",
+    vendor: "liminal_testing",
+    embed: getEmbedding,
+  }
+}

package/testing/TestLanguageModel.ts

@@ -0,0 +1,33 @@
+import { assistant } from "../actions/actions_derived/messages.ts"
+import type { LanguageModel } from "../Model.ts"
+import type { JSONValue } from "../util/JSONValue.ts"
+
+export interface TestLanguageModelConfig {
+  getObject: () => JSONValue
+  getText: () => string
+}
+
+export const defaultTestLanguageModelConfig: TestLanguageModelConfig = {
+  getObject: () => ({}),
+  getText: () => "",
+}
+
+export function TestLanguageModel({
+  getObject,
+  getText,
+}: TestLanguageModelConfig = defaultTestLanguageModelConfig): LanguageModel {
+  return {
+    type: "language",
+    vendor: "liminal_testing",
+    async *infer(type) {
+      if (type) {
+        const object = getObject()
+        yield* assistant`${JSON.stringify(object)}`
+        return object
+      }
+      const text = getText()
+      yield* assistant`${text}`
+      return text
+    },
+  }
+}

package/testing/index.ts

@@ -0,0 +1,4 @@
+export * from "./AgentAssertions.ts"
+export * from "./takeFirstAction.ts"
+export * from "./TestEmbeddingModel.ts"
+export * from "./TestLanguageModel.ts"

package/testing/takeFirstAction.ts

@@ -0,0 +1,8 @@
+import type { Action } from "../Action.ts"
+import type { AgentLike } from "../Agent.ts"
+import { unwrapDeferred } from "../util/unwrapDeferred.ts"
+
+export async function takeFirstAction<Y extends Action>(f: AgentLike<Y>): Promise<Y | undefined> {
+  const { value } = await unwrapDeferred(f).next()
+  return value
+}

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../tsconfig.base",
+  "compilerOptions": {
+    "noEmit": false,
+    "outDir": "dist"
+  },
+  "include": ["."]
+}

package/types/AssertDiagnostics.ts

@@ -0,0 +1,183 @@
+import { assert } from "../util/assert.ts"
+import { isJSONValue } from "../util/isJSONValue.ts"
+import { jsonEquals } from "../util/jsonEquals.ts"
+import type { JSONKey } from "../util/JSONKey.ts"
+import type { JSONValue } from "../util/JSONValue.ts"
+import type { JSONType } from "./JSONType.ts"
+import type { Type } from "./Type.ts"
+import { TypeVisitor } from "./TypeVisitor.ts"
+
+export type AssertDiagnostics = Array<Diagnostic>
+
+export type Diagnostic = ReturnType<typeof Diagnostic>
+export function Diagnostic(path: AssertPath, type: Type, error: unknown) {
+  return {
+    path,
+    type,
+    error,
+    message,
+    formatPath,
+  }
+
+  function message() {
+    return error instanceof Error ? error.message : JSON.stringify(error)
+  }
+
+  function formatPath() {
+    let formatted = ""
+    for (let i = 0; i < path.length; i++) {
+      const key = path[i]!
+      if (typeof key === "string") {
+        try {
+          const int = parseInt(key)
+          if (Number.isInteger(int)) {
+            formatted += `[${int}]`
+          } else {
+            formatted += `.${key}`
+          }
+        } catch (_e: unknown) {
+          formatted += `.${key}`
+        }
+      } else {
+        formatted += `[${key}]`
+      }
+    }
+    return formatted
+  }
+}
+
+export type AssertPath = Array<JSONKey>
+
+// Possibly: `nullUnionFieldsAsOptional?: boolean`
+export interface AssertDiagnosticsConfig {}
+
+export function AssertDiagnostics<T extends JSONValue, J extends JSONType>(
+  config: AssertDiagnosticsConfig,
+  type: Type<T, J>,
+  value: unknown,
+): Array<Diagnostic> {
+  const state = ValueVisitorState()
+  visit([config, false], type)(value, state)
+  return state.diagnostics
+}
+
+type ValueVisitorState = ReturnType<typeof ValueVisitorState>
+function ValueVisitorState(
+  diagnostics: Array<Diagnostic> = [],
+  path: Array<number | string> = [],
+) {
+  return {
+    diagnostics,
+    path,
+    next,
+  }
+
+  function next(key?: JSONKey) {
+    return ValueVisitorState(diagnostics, [...path, ...key !== undefined ? [key] : []])
+  }
+}
+
+const visit: TypeVisitor<AssertDiagnosticsConfig, (value: unknown, vState: ValueVisitorState) => void> = TypeVisitor(
+  {
+    hook(next, tState, type) {
+      return (value, vState) => {
+        try {
+          next(tState, type)(value, vState)
+        } catch (error) {
+          vState.diagnostics.push(Diagnostic(vState.path, type, error))
+        }
+      }
+    },
+    null() {
+      return (value) => {
+        assert(value === null)
+      }
+    },
+    boolean() {
+      return (value) => {
+        assert(typeof value === "boolean")
+      }
+    },
+    integer() {
+      return (value) => {
+        assert(typeof value === "number" && Number.isInteger(value))
+      }
+    },
+    number() {
+      return (value) => {
+        assert(typeof value === "number")
+      }
+    },
+    string() {
+      return (value) => {
+        assert(typeof value === "string")
+      }
+    },
+    const(_tState, _type, _valueType, value_) {
+      return (value) => {
+        assert(isJSONValue(value) && jsonEquals(value_, value))
+      }
+    },
+    _array(tState, _type, element) {
+      const visitElement = visit(tState, element)
+      return (value, vState) => {
+        assert(Array.isArray(value))
+        value.forEach((e, i) => visitElement(e, vState.next(i)))
+      }
+    },
+    enum(_tState, _type, ...values) {
+      return (value) => {
+        assert(typeof value == "string")
+        assert(values.includes(value))
+      }
+    },
+    _union(tState, _type, ...members) {
+      return (value, vState) => {
+        assert(members.some((member) => {
+          const memberState = vState.next()
+          visit(tState, member)(value, memberState)
+          return !memberState.diagnostics.length
+        }))
+      }
+    },
+    _object(tState, _type, fields) {
+      return (value, vState) => {
+        assert(typeof value === "object" && value !== null)
+        if (Array.isArray(fields)) {
+          fields.forEach((v, i) => {
+            visitField(tState, vState, value, i, v)
+          })
+        } else {
+          Object.entries(fields).forEach(([k, v]) => {
+            visitField(tState, vState, value, k, v)
+          })
+        }
+      }
+    },
+    ref(tState, _type, getType) {
+      return (value, vState) => {
+        visit(tState, getType())(value, vState)
+      }
+    },
+  },
+)
+
+function visitField(
+  tState: AssertDiagnosticsConfig,
+  vState: ValueVisitorState,
+  value: object,
+  key: JSONKey,
+  type: Type,
+) {
+  assert(key in value)
+  const childValue = value[key as never]
+  assert(childValue !== undefined)
+  visit(tState, type)(childValue, vState.next(key))
+}
+
+// TODO: serialize signature
+export function formatAssertDiagnostics(diagnostics: AssertDiagnostics) {
+  return diagnostics
+    .map((diagnostic) => `Error "${diagnostic.message()}"; encountered at ${diagnostic.formatPath()}`)
+    .join("\n")
+}

package/types/JSONRootType.ts

@@ -0,0 +1,8 @@
+import type { JSONIdentifiedType, JSONType } from "./JSONType.ts"
+
+export const JSONSchema$schema = "http://json-schema.org/draft-07/schema#"
+
+export type JSONRootType<J extends JSONType> = J & {
+  $schema: typeof JSONSchema$schema
+  $defs: Record<string, JSONIdentifiedType | undefined>
+}