liminal 0.5.2 → 0.5.3

package/events/EventResolved.ts

@@ -1,30 +0,0 @@
-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

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

package/events/InferenceRequested.ts

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

package/events/Inferred.ts

@@ -1,6 +0,0 @@
-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

@@ -1,40 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

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

package/events/SectionCleared.ts

@@ -1,6 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

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

package/events/ToolCalled.ts

@@ -1,7 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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/testing/AgentAssertions.ts

@@ -1,17 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

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

package/testing/takeFirstAction.ts

@@ -1,8 +0,0 @@
-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/types/AssertDiagnostics.ts

@@ -1,183 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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>
-}

package/types/JSONType.ts

@@ -1,27 +0,0 @@
-import type { JSONArrayType } from "./array.ts"
-import type { JSONBooleanType } from "./boolean.ts"
-import type { JSONConstType } from "./const.ts"
-import type { JSONEnumType } from "./enum.ts"
-import type { JSONIntegerType } from "./integer.ts"
-import type { JSONNullType } from "./null.ts"
-import type { JSONNumberType } from "./number.ts"
-import type { JSONObjectType } from "./object.ts"
-import type { JSONRefType } from "./ref.ts"
-import type { JSONStringType } from "./string.ts"
-import type { JSONUnionType } from "./union.ts"
-
-export type JSONIdentifiedType = JSONArrayType | JSONObjectType | JSONUnionType
-
-export type JSONAnonymousType =
-  | JSONNullType
-  | JSONBooleanType
-  | JSONIntegerType
-  | JSONNumberType
-  | JSONStringType
-  | JSONEnumType
-
-export type ConstableType = JSONAnonymousType | JSONIdentifiedType
-
-export type JSONRootableType = ConstableType | JSONConstType
-
-export type JSONType = JSONRootableType | JSONRefType

package/types/JSONTypeBase.ts

@@ -1,3 +0,0 @@
-export interface JSONTypeBase {
-  description?: string
-}

package/types/Metatype/MetatypeDescriptor.ts

@@ -1,80 +0,0 @@
-import { array } from "../array.ts"
-import { enum as enum_ } from "../enum.ts"
-import { type JSONObjectType, object } from "../object.ts"
-import { ref } from "../ref.ts"
-import { string } from "../string.ts"
-import type { Type } from "../Type.ts"
-import { taggedUnion } from "../types_derived/taggedUnion.ts"
-import type { JSONUnionType } from "../union.ts"
-
-export type MetatypeRootDescriptor = {
-  type: "record"
-  value: {
-    description: string
-    fields: Array<{
-      description: string
-      key: string
-      value: MetatypeDescriptor
-    }>
-  }
-}
-
-const recordFields = {
-  description: string,
-  fields: array({
-    description: string,
-    key: string,
-    value: ref(() => MetatypeDescriptor),
-  }),
-}
-
-export const MetatypeRootDescriptor: Type<MetatypeRootDescriptor, JSONObjectType> = object({
-  type: "record",
-  value: recordFields,
-})
-
-export type MetatypeDescriptor = MetatypeRootDescriptor | {
-  type: "atom"
-  value: {
-    description: string
-    atomType: "boolean" | "integer" | "number" | "string"
-  }
-} | {
-  type: "enum"
-  value: {
-    description: string
-    variants: Array<string>
-  }
-} | {
-  type: "array"
-  value: {
-    description: string
-    items: MetatypeDescriptor
-  }
-} | {
-  type: "union"
-  value: {
-    description: string
-    members: Array<MetatypeDescriptor>
-  }
-}
-
-export const MetatypeDescriptor: Type<MetatypeDescriptor, JSONUnionType> = taggedUnion({
-  atom: {
-    description: string,
-    atomType: enum_("boolean", "integer", "number", "string"),
-  },
-  enum: {
-    description: string,
-    variants: array(string),
-  },
-  array: {
-    description: string,
-    items: ref(() => MetatypeDescriptor),
-  },
-  record: recordFields,
-  union: {
-    description: string,
-    members: array(ref(() => MetatypeDescriptor)),
-  },
-})