liminal 0.1.0-beta.25

package/esm/util/ArrayOfLength.d.ts

@@ -0,0 +1,2 @@
+export type ArrayOfLength<T, L extends number, A extends T[] = []> = number extends L ? T[] : L extends A["length"] ? A : ArrayOfLength<T, L, [...A, T]>;
+//# sourceMappingURL=ArrayOfLength.d.ts.map

package/esm/util/ArrayOfLength.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ArrayOfLength.d.ts","sourceRoot":"","sources":["../../src/util/ArrayOfLength.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,aAAa,CACvB,CAAC,EACD,CAAC,SAAS,MAAM,EAChB,CAAC,SAAS,CAAC,EAAE,GAAG,EAAE,IAChB,MAAM,SAAS,CAAC,GAAG,CAAC,EAAE,GAAG,CAAC,SAAS,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,GAAG,aAAa,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA"}

package/esm/util/ArrayOfLength.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ArrayOfLength.js.map

package/esm/util/ArrayOfLength.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ArrayOfLength.js","sourceRoot":"","sources":["../../src/util/ArrayOfLength.ts"],"names":[],"mappings":""}

package/esm/util/PromiseOr.d.ts

@@ -0,0 +1,2 @@
+export type PromiseOr<T> = T | Promise<T>;
+//# sourceMappingURL=PromiseOr.d.ts.map

package/esm/util/PromiseOr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PromiseOr.d.ts","sourceRoot":"","sources":["../../src/util/PromiseOr.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAA"}

package/esm/util/PromiseOr.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=PromiseOr.js.map

package/esm/util/PromiseOr.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PromiseOr.js","sourceRoot":"","sources":["../../src/util/PromiseOr.ts"],"names":[],"mappings":""}

package/esm/util/WeakMemo.d.ts

@@ -0,0 +1,7 @@
+export declare class WeakMemo<K extends WeakKey, T> {
+    #private;
+    private f;
+    constructor(f: (key: K) => T);
+    getOrInit: (key: K) => T;
+}
+//# sourceMappingURL=WeakMemo.d.ts.map

package/esm/util/WeakMemo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WeakMemo.d.ts","sourceRoot":"","sources":["../../src/util/WeakMemo.ts"],"names":[],"mappings":"AAAA,qBAAa,QAAQ,CAAC,CAAC,SAAS,OAAO,EAAE,CAAC;;IAE5B,OAAO,CAAC,CAAC;gBAAD,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC;IAEpC,SAAS,QAAS,CAAC,KAAG,CAAC,CAOtB;CACF"}

package/esm/util/WeakMemo.js

@@ -0,0 +1,32 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _WeakMemo_cache;
+export class WeakMemo {
+    constructor(f) {
+        Object.defineProperty(this, "f", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: f
+        });
+        _WeakMemo_cache.set(this, new WeakMap());
+        Object.defineProperty(this, "getOrInit", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (key) => {
+                if (__classPrivateFieldGet(this, _WeakMemo_cache, "f").has(key)) {
+                    return __classPrivateFieldGet(this, _WeakMemo_cache, "f").get(key);
+                }
+                const value = this.f(key);
+                __classPrivateFieldGet(this, _WeakMemo_cache, "f").set(key, value);
+                return value;
+            }
+        });
+    }
+}
+_WeakMemo_cache = new WeakMap();
+//# sourceMappingURL=WeakMemo.js.map

package/esm/util/WeakMemo.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"WeakMemo.js","sourceRoot":"","sources":["../../src/util/WeakMemo.ts"],"names":[],"mappings":";;;;;;AAAA,MAAM,OAAO,QAAQ;IAEnB,YAAoB,CAAgB;QAAxB;;;;mBAAQ,CAAC;WAAe;QADpC,0BAAS,IAAI,OAAO,EAAQ,EAAA;QAG5B;;;;mBAAY,CAAC,GAAM,EAAK,EAAE;gBACxB,IAAI,uBAAA,IAAI,uBAAO,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;oBACzB,OAAO,uBAAA,IAAI,uBAAO,CAAC,GAAG,CAAC,GAAG,CAAE,CAAA;gBAC9B,CAAC;gBACD,MAAM,KAAK,GAAG,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAA;gBACzB,uBAAA,IAAI,uBAAO,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAA;gBAC3B,OAAO,KAAK,CAAA;YACd,CAAC;WAAA;IATsC,CAAC;CAUzC"}

package/esm/util/collect.d.ts

@@ -0,0 +1,2 @@
+export declare function collect<T>(iterable: AsyncIterable<T>): Promise<T[]>;
+//# sourceMappingURL=collect.d.ts.map

package/esm/util/collect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collect.d.ts","sourceRoot":"","sources":["../../src/util/collect.ts"],"names":[],"mappings":"AAAA,wBAAsB,OAAO,CAAC,CAAC,EAAE,QAAQ,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC,CAMzE"}

package/esm/util/collect.js

@@ -0,0 +1,8 @@
+export async function collect(iterable) {
+    const result = [];
+    for await (const item of iterable) {
+        result.push(item);
+    }
+    return result;
+}
+//# sourceMappingURL=collect.js.map

package/esm/util/collect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"collect.js","sourceRoot":"","sources":["../../src/util/collect.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,KAAK,UAAU,OAAO,CAAI,QAA0B;IACzD,MAAM,MAAM,GAAa,EAAE,CAAA;IAC3B,IAAI,KAAK,EAAE,MAAM,IAAI,IAAI,QAAQ,EAAE,CAAC;QAClC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;IACnB,CAAC;IACD,OAAO,MAAM,CAAA;AACf,CAAC"}

package/esm/util/isPromise.d.ts

@@ -0,0 +1,2 @@
+export declare function isPromise(value: unknown): value is Promise<unknown>;
+//# sourceMappingURL=isPromise.d.ts.map

package/esm/util/isPromise.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isPromise.d.ts","sourceRoot":"","sources":["../../src/util/isPromise.ts"],"names":[],"mappings":"AAAA,wBAAgB,SAAS,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,OAAO,CAAC,OAAO,CAAC,CAOnE"}

package/esm/util/isPromise.js

@@ -0,0 +1,7 @@
+export function isPromise(value) {
+    return (value !== null
+        && (typeof value === "object" || typeof value === "function")
+        && "then" in value && typeof value.then === "function"
+        && "catch" in value && typeof value.catch === "function");
+}
+//# sourceMappingURL=isPromise.js.map

package/esm/util/isPromise.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isPromise.js","sourceRoot":"","sources":["../../src/util/isPromise.ts"],"names":[],"mappings":"AAAA,MAAM,UAAU,SAAS,CAAC,KAAc;IACtC,OAAO,CACL,KAAK,KAAK,IAAI;WACX,CAAC,OAAO,KAAK,KAAK,QAAQ,IAAI,OAAO,KAAK,KAAK,UAAU,CAAC;WAC1D,MAAM,IAAI,KAAK,IAAI,OAAO,KAAK,CAAC,IAAI,KAAK,UAAU;WACnD,OAAO,IAAI,KAAK,IAAI,OAAO,KAAK,CAAC,KAAK,KAAK,UAAU,CACzD,CAAA;AACH,CAAC"}

package/esm/util/isTemplateStringsArray.d.ts

@@ -0,0 +1,2 @@
+export declare function isTemplateStringsArray(value: unknown): value is TemplateStringsArray;
+//# sourceMappingURL=isTemplateStringsArray.d.ts.map

package/esm/util/isTemplateStringsArray.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isTemplateStringsArray.d.ts","sourceRoot":"","sources":["../../src/util/isTemplateStringsArray.ts"],"names":[],"mappings":"AAAA,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,oBAAoB,CAEpF"}

package/esm/util/isTemplateStringsArray.js

@@ -0,0 +1,4 @@
+export function isTemplateStringsArray(value) {
+    return Array.isArray(value) && "raw" in value && Array.isArray(value.raw);
+}
+//# sourceMappingURL=isTemplateStringsArray.js.map

package/esm/util/isTemplateStringsArray.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isTemplateStringsArray.js","sourceRoot":"","sources":["../../src/util/isTemplateStringsArray.ts"],"names":[],"mappings":"AAAA,MAAM,UAAU,sBAAsB,CAAC,KAAc;IACnD,OAAO,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,KAAK,IAAI,KAAK,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAA;AAC3E,CAAC"}

package/esm/util/mod.d.ts

@@ -0,0 +1,10 @@
+export * from "./ArrayOfLength.js";
+export * from "./collect.js";
+export * from "./isPromise.js";
+export * from "./isTemplateStringsArray.js";
+export * from "./PromiseOr.js";
+export * from "./recombine.js";
+export * from "./splitLast.js";
+export * from "./type_util.js";
+export * from "./WeakMemo.js";
+//# sourceMappingURL=mod.d.ts.map

package/esm/util/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../src/util/mod.ts"],"names":[],"mappings":"AAEA,cAAc,oBAAoB,CAAA;AAClC,cAAc,cAAc,CAAA;AAC5B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,6BAA6B,CAAA;AAC3C,cAAc,gBAAgB,CAAA;AAC9B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,eAAe,CAAA"}

package/esm/util/mod.js

@@ -0,0 +1,11 @@
+// moderate
+export * from "./ArrayOfLength.js";
+export * from "./collect.js";
+export * from "./isPromise.js";
+export * from "./isTemplateStringsArray.js";
+export * from "./PromiseOr.js";
+export * from "./recombine.js";
+export * from "./splitLast.js";
+export * from "./type_util.js";
+export * from "./WeakMemo.js";
+//# sourceMappingURL=mod.js.map

package/esm/util/mod.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.js","sourceRoot":"","sources":["../../src/util/mod.ts"],"names":[],"mappings":"AAAA,WAAW;AAEX,cAAc,oBAAoB,CAAA;AAClC,cAAc,cAAc,CAAA;AAC5B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,6BAA6B,CAAA;AAC3C,cAAc,gBAAgB,CAAA;AAC9B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,eAAe,CAAA"}

package/esm/util/recombine.d.ts

@@ -0,0 +1,2 @@
+export declare function recombine(template: TemplateStringsArray, values: Array<unknown>): string;
+//# sourceMappingURL=recombine.d.ts.map

package/esm/util/recombine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recombine.d.ts","sourceRoot":"","sources":["../../src/util/recombine.ts"],"names":[],"mappings":"AAAA,wBAAgB,SAAS,CAAC,QAAQ,EAAE,oBAAoB,EAAE,MAAM,EAAE,KAAK,CAAC,OAAO,CAAC,GAAG,MAAM,CASxF"}

package/esm/util/recombine.js

@@ -0,0 +1,11 @@
+export function recombine(template, values) {
+    const segments = [];
+    for (let i = 0; i < template.length; i++) {
+        segments.push(template[i]);
+        if (i < values.length) {
+            segments.push(String(values[i]));
+        }
+    }
+    return segments.join("");
+}
+//# sourceMappingURL=recombine.js.map

package/esm/util/recombine.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"recombine.js","sourceRoot":"","sources":["../../src/util/recombine.ts"],"names":[],"mappings":"AAAA,MAAM,UAAU,SAAS,CAAC,QAA8B,EAAE,MAAsB;IAC9E,MAAM,QAAQ,GAAG,EAAE,CAAA;IACnB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACzC,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAA;QAC1B,IAAI,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC;YACtB,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;QAClC,CAAC;IACH,CAAC;IACD,OAAO,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC,CAAA;AAC1B,CAAC"}

package/esm/util/splitLast.d.ts

@@ -0,0 +1,2 @@
+export declare function splitLast(value: string, search: string): undefined | [string, string];
+//# sourceMappingURL=splitLast.d.ts.map

package/esm/util/splitLast.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"splitLast.d.ts","sourceRoot":"","sources":["../../src/util/splitLast.ts"],"names":[],"mappings":"AAAA,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,SAAS,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAMrF"}

package/esm/util/splitLast.js

@@ -0,0 +1,8 @@
+export function splitLast(value, search) {
+    const lastI = value.lastIndexOf(search);
+    if (lastI === -1) {
+        return undefined;
+    }
+    return [value.slice(0, lastI), value.slice(lastI + search.length)];
+}
+//# sourceMappingURL=splitLast.js.map

package/esm/util/splitLast.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"splitLast.js","sourceRoot":"","sources":["../../src/util/splitLast.ts"],"names":[],"mappings":"AAAA,MAAM,UAAU,SAAS,CAAC,KAAa,EAAE,MAAc;IACrD,MAAM,KAAK,GAAG,KAAK,CAAC,WAAW,CAAC,MAAM,CAAC,CAAA;IACvC,IAAI,KAAK,KAAK,CAAC,CAAC,EAAE,CAAC;QACjB,OAAO,SAAS,CAAA;IAClB,CAAC;IACD,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC,KAAK,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,CAAA;AACpE,CAAC"}

package/esm/util/type_util.d.ts

@@ -0,0 +1,5 @@
+export type Expand<T> = T extends T ? {
+    [K in keyof T]: T[K];
+} : never;
+export type U2I<T> = (T extends any ? (x: T) => any : never) extends (x: infer R) => any ? R : never;
+//# sourceMappingURL=type_util.d.ts.map

package/esm/util/type_util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type_util.d.ts","sourceRoot":"","sources":["../../src/util/type_util.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,MAAM,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG;KAAG,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CAAE,GAAG,KAAK,CAAA;AAEtE,MAAM,MAAM,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,GAAG,GAAG,CAAC,CAAC,EAAE,CAAC,KAAK,GAAG,GAAG,KAAK,CAAC,SAAS,CAAC,CAAC,EAAE,MAAM,CAAC,KAAK,GAAG,GAAG,CAAC,GAAG,KAAK,CAAA"}

package/esm/util/type_util.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=type_util.js.map

package/esm/util/type_util.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"type_util.js","sourceRoot":"","sources":["../../src/util/type_util.ts"],"names":[],"mappings":""}

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "liminal",
+  "version": "0.1.0-beta.25",
+  "description": "A library for modeling types for and with LLMs",
+  "repository": "github:harrysolovay/liminal.git",
+  "license": "Apache-2.0",
+  "main": "./esm/mod.js",
+  "module": "./esm/mod.js",
+  "exports": {
+    ".": {
+      "import": "./esm/mod.js"
+    },
+    "./openai": {
+      "import": "./esm/providers/OpenAI/mod.js"
+    }
+  },
+  "type": "module",
+  "_generatedBy": "dnt@dev",
+  "peerDependencies": {
+    "openai": "^4.76.0"
+  }
+}

package/src/_dnt.shims.ts

@@ -0,0 +1,60 @@
+const dntGlobals = {
+};
+export const dntGlobalThis = createMergeProxy(globalThis, dntGlobals);
+
+function createMergeProxy<T extends object, U extends object>(
+  baseObj: T,
+  extObj: U,
+): Omit<T, keyof U> & U {
+  return new Proxy(baseObj, {
+    get(_target, prop, _receiver) {
+      if (prop in extObj) {
+        return (extObj as any)[prop];
+      } else {
+        return (baseObj as any)[prop];
+      }
+    },
+    set(_target, prop, value) {
+      if (prop in extObj) {
+        delete (extObj as any)[prop];
+      }
+      (baseObj as any)[prop] = value;
+      return true;
+    },
+    deleteProperty(_target, prop) {
+      let success = false;
+      if (prop in extObj) {
+        delete (extObj as any)[prop];
+        success = true;
+      }
+      if (prop in baseObj) {
+        delete (baseObj as any)[prop];
+        success = true;
+      }
+      return success;
+    },
+    ownKeys(_target) {
+      const baseKeys = Reflect.ownKeys(baseObj);
+      const extKeys = Reflect.ownKeys(extObj);
+      const extKeysSet = new Set(extKeys);
+      return [...baseKeys.filter((k) => !extKeysSet.has(k)), ...extKeys];
+    },
+    defineProperty(_target, prop, desc) {
+      if (prop in extObj) {
+        delete (extObj as any)[prop];
+      }
+      Reflect.defineProperty(baseObj, prop, desc);
+      return true;
+    },
+    getOwnPropertyDescriptor(_target, prop) {
+      if (prop in extObj) {
+        return Reflect.getOwnPropertyDescriptor(extObj, prop);
+      } else {
+        return Reflect.getOwnPropertyDescriptor(baseObj, prop);
+      }
+    },
+    has(_target, prop) {
+      return prop in extObj || prop in baseObj;
+    },
+  }) as any;
+}

package/src/client/Adapter.ts

@@ -0,0 +1,50 @@
+import type { Falsy } from "../deps/jsr.io/@std/assert/1.0.10/mod.js"
+import type { Type } from "../core/mod.js"
+
+export interface AdapterDescriptor {
+  /** Supported model names. */
+  model: string
+  /** Supported completion message roles. */
+  role: string
+  /** Provider completion. */
+  completion: unknown
+  /** Provider-specific input message. */
+  I: unknown
+  /** Provider-specific output message. */
+  O: unknown
+}
+
+export interface Adapter<D extends AdapterDescriptor> {
+  /** Default configuration for the provider. */
+  defaults: AdapterDefaults<D>
+  /** Format text into the provider's message type. */
+  formatInput: (texts: Array<Falsy | string>, role?: D["role"]) => D["I"]
+  /** Request a text completion. */
+  text: (messages: Array<D["I" | "O"]>, config?: TextConfig<D>) => Promise<D["completion"]>
+  /** Request a structured output completion. */
+  value: <T>(type: Type<T>, params: ValueConfig<D>) => Promise<D["completion"]>
+  /** Unwrap the message from the completion. */
+  unwrapOutput: (message: D["completion"]) => D["O"]
+  /** Unwrap the content from within the completion message. */
+  unwrapRaw: (message: D["O"]) => string
+}
+
+export interface AdapterDefaults<D extends AdapterDescriptor> {
+  /** What model to use when none specified. */
+  model: D["model"]
+  /** What role to use in constructing a message when none specified. */
+  role: D["role"]
+  /** Opening message to include in value completion when no message history nor messages supplied. */
+  opening: D["I"]
+}
+
+export interface TextConfig<D extends AdapterDescriptor> {
+  model?: D["model"]
+}
+
+export interface ValueConfig<D extends AdapterDescriptor> extends TextConfig<D> {
+  messages?: Array<D["I" | "O"]>
+  name?: string
+  description?: string
+  refine?: boolean
+}

package/src/client/Liminal.ts

@@ -0,0 +1,113 @@
+import { AssertionError } from "../deps/jsr.io/@std/assert/1.0.10/mod.js"
+import { deserialize, L, type Type } from "../core/mod.js"
+import type { MetaTypeMigration } from "../json_schema/mod.js"
+import type { Adapter, AdapterDescriptor, TextConfig, ValueConfig } from "./Adapter.js"
+import { Tool, type ToolConfig } from "./Tool.js"
+
+export class Liminal<D extends AdapterDescriptor = AdapterDescriptor> {
+  constructor(readonly adapter: Adapter<D>, public history: Array<D["I" | "O"]> = []) {}
+
+  #completions: Set<ReadableStreamDefaultController<D["completion"]>> = new Set()
+  completions = (): ReadableStream<D["completion"]> => {
+    const abort = new AbortController()
+    return new ReadableStream({
+      start: (ctl) => {
+        this.#completions.add(ctl)
+        abort.signal.addEventListener("abort", () => this.#completions.delete(ctl))
+      },
+      cancel(reason) {
+        abort.abort(reason)
+      },
+    })
+  }
+
+  #messages: Set<ReadableStreamDefaultController<D["I" | "O"]>> = new Set()
+  messages = (): ReadableStream<D["I" | "O"]> => {
+    const abort = new AbortController()
+    return new ReadableStream({
+      start: (ctl) => {
+        this.#messages.add(ctl)
+        abort.signal.addEventListener("abort", () => this.#messages.delete(ctl))
+      },
+      cancel(reason) {
+        abort.abort(reason)
+      },
+    })
+  }
+
+  #tools: Set<Tool<D, unknown>> = new Set()
+  tool = <T>(type: Type<T>, config: ToolConfig<T>): Tool<D, T> => {
+    const tool = new Tool(this, type, config)
+    this.#tools.add(tool)
+    config.signal?.addEventListener("abort", () => {
+      this.#tools.delete(tool)
+    })
+    return tool
+  }
+
+  text = async (messages: Array<D["I"]>, config?: TextConfig<D>): Promise<string> => {
+    if (!messages.length) {
+      messages = [this.adapter.defaults.opening]
+    }
+    const completion = this.adapter.text([...this.history, ...messages], config)
+    const message = await completion.then(this.adapter.unwrapOutput)
+    this.#onMessages(...messages, completion)
+    return this.adapter.unwrapRaw(message)
+  }
+
+  type = (_messages: Array<D["I"]>, _config?: TextConfig<D>): Promise<Type<unknown>> => {
+    throw 0
+  }
+
+  migration = (
+    _type: Type<unknown>,
+    _messages: Array<D["I"]>,
+    _config?: TextConfig<D>,
+  ): Promise<MetaTypeMigration<never>["T"]> => {
+    throw 0
+  }
+
+  // TODO: disallow `O` messages.
+  value = async <T>(type: Type<T>, config?: ValueConfig<D>): Promise<T> => {
+    type = L.transform(L.Tuple(type), ([e]) => e)
+    const messages = config?.messages?.length
+      ? config.messages
+      : [this.adapter.defaults.opening]
+    const completion = await this.adapter.value(type, {
+      messages: [...this.history, ...messages],
+    })
+    const output = this.adapter.unwrapOutput(completion)
+    this.#onMessages(...messages, output)
+    return deserialize(type, this.adapter.unwrapRaw(output))
+  }
+
+  assert = async (value: unknown, statement: string): Promise<void> => {
+    const reason = await this.value(AssertionResult, {
+      name: "liminal_assert",
+      messages: [this.adapter.formatInput([`
+        Does the value satisfy the assertion?
+
+        ## The value:
+
+        \`\`\`json
+        ${JSON.stringify(value, null, 2)}
+        \`\`\
+
+        ## The assertion: ${statement}
+      `])],
+    })
+    if (reason) {
+      throw new AssertionError(reason)
+    }
+  }
+
+  #onMessages = (...messages: Array<D["I" | "O"]>) => {
+    this.history.push(
+      ...this.history.length ? [] : [this.adapter.defaults.opening],
+      ...messages,
+    )
+    this.#messages.forEach((listener) => messages.forEach(listener.enqueue))
+  }
+}
+
+const AssertionResult = L.Option(L.string`Reason behind assertion failure.`)

package/src/client/Tool.ts

@@ -0,0 +1,17 @@
+import type { Type } from "../core/mod.js"
+import type { AdapterDescriptor } from "./Adapter.js"
+import type { Liminal } from "./Liminal.js"
+
+export interface ToolConfig<T = any> {
+  description: string
+  f: (value: T) => unknown
+  signal?: AbortSignal
+}
+
+export class Tool<D extends AdapterDescriptor, T> {
+  constructor(
+    readonly liminal: Liminal<D>,
+    readonly type: Type<T>,
+    readonly config: ToolConfig,
+  ) {}
+}

package/src/client/constants.ts

@@ -0,0 +1,6 @@
+export const DEFAULT_INSTRUCTIONS: string = `
+  You are an expert type-theorist and ontologist.
+  Your role is to analyze, synthesize, and generate structured outputs based on
+  precise type-theoretical and ontological principles. Ensure your responses are
+  logically consistent, clear, and follow the requested format.
+`

package/src/client/mod.ts

@@ -0,0 +1,6 @@
+// moderate
+
+export * from "./Adapter.js"
+export * from "./constants.js"
+export * from "./Liminal.js"
+export * from "./Tool.js"

package/src/core/DescriptionContext.ts

@@ -0,0 +1,89 @@
+import { recombine } from "../util/mod.js"
+import { DescriptionParamKey } from "./annotations/mod.js"
+import type { PartialType } from "./mod.js"
+import type { Type } from "./Type.js"
+
+export function description(type: Type<unknown>): string | undefined {
+  return new DescriptionContext(new Map(), {}).format(type)
+}
+
+export class DescriptionContext {
+  constructor(
+    readonly pins: Map<PartialType, string> = new Map(),
+    readonly args: Record<symbol, unknown> = {},
+  ) {}
+
+  pin = (type: PartialType): string => {
+    let pin = this.pins.get(type)
+    if (!pin) {
+      pin = this.pins.size.toString()
+      this.pins.set(type, pin)
+    }
+    return pin
+  }
+
+  format = (type: Type<unknown>): undefined | string => {
+    const assertionDescriptions: Array<string> = []
+    let segments: Array<string> = []
+    type.annotations.forEach((annotation) => {
+      if (annotation) {
+        if (typeof annotation === "string") {
+          segments.push(annotation)
+        } else {
+          switch (annotation.type) {
+            case "Template": {
+              segments.push(recombine(
+                annotation.template,
+                annotation.parts.map((part) => {
+                  if (typeof part === "string") {
+                    return part
+                  }
+                  switch (part.type) {
+                    case "Param": {
+                      return this.args[part.key]
+                    }
+                    case "Type": {
+                      return this.pin(part)
+                    }
+                  }
+                }),
+              ))
+              break
+            }
+            case "Type": {
+              segments.push(this.pin(annotation))
+              break
+            }
+            case "Param": {
+              const arg = this.args[annotation.key]
+              if (typeof arg === "string") {
+                segments.push(arg)
+              } else if (typeof arg === "object" && arg !== null && DescriptionParamKey in arg) {
+                segments.push(arg[DescriptionParamKey] as string)
+              }
+              break
+            }
+            case "Arg": {
+              this.args[annotation.key] = annotation.value
+              break
+            }
+            case "Assertion": {
+              assertionDescriptions.push(annotation.description)
+              break
+            }
+          }
+        }
+      }
+    })
+    segments = [
+      ...segments,
+      ...assertionDescriptions.length
+        ? [
+          "\n\nEnsure:\n\n",
+          ...assertionDescriptions.map((d) => `- ${d}`).join("\n"),
+        ]
+        : [],
+    ]
+    return segments.length ? segments.join(" ") : undefined
+  }
+}

package/src/core/L.ts

@@ -0,0 +1,3 @@
+export * from "./annotations/mod.js"
+export * from "./intrinsics.js"
+export * from "./utility/mod.js"

package/src/core/ReduceDependencies.ts

@@ -0,0 +1,9 @@
+import type { Arg, Param } from "./annotations/mod.js"
+
+// TODO: disallow args with no corresponding params?
+export type ReduceDependencies<D extends symbol, A extends Array<unknown>> = A extends
+  [infer Part0, ...infer PartRest] ? ReduceDependencies<
+    Part0 extends Param<infer K> ? D | K : Part0 extends Arg<infer K> ? Exclude<D, K> : D,
+    PartRest
+  >
+  : D