liminal 0.4.0 → 0.5.1

package/actions/enableTool.type-test.ts

@@ -0,0 +1,118 @@
+import type { AssertTrue, IsExact } from "conditional-type-checks"
+import type { ActorLike } from "../Actor.ts"
+import type { Emitted } from "../events/Emitted.ts"
+import type { ToolCalled } from "../events/ToolCalled.ts"
+import type { ToolDisabled } from "../events/ToolDisabled.ts"
+import type { ToolEnabled } from "../events/ToolEnabled.ts"
+import * as L from "../L.ts"
+import { ActorAssertions } from "../testing/ActorAssertions.ts"
+import { emit } from "./emit.ts"
+import { enableTool } from "./enableTool.ts"
+
+type P = typeof P["T"]
+const P = L.object({
+  a: L.string,
+  b: L.string,
+})
+
+const arrowTool = L.enableTool("Tool", "", P, (params) => {
+  type _ = [AssertTrue<IsExact<typeof params, P>>]
+})
+
+ActorAssertions(arrowTool).assertSpec<{
+  Event:
+    | ToolEnabled<"Tool">
+    | ToolCalled<"Tool", {
+      a: string
+      b: string
+    }>
+  Child: never
+  Throw: never
+  Entry: never
+  Value: never
+}>()
+
+function* _0() {
+  const detach = yield* arrowTool
+  ActorAssertions(detach).assertSpec<{
+    Event: ToolDisabled<"Tool">
+    Child: never
+    Throw: never
+    Entry: never
+    Value: never
+  }>()
+}
+
+const genTool = enableTool("tool-key", "", P, function*(params) {
+  type _ = [AssertTrue<IsExact<typeof params, P>>]
+  yield* emit("Test")
+  return ""
+})
+
+ActorAssertions(genTool).assertSpec<{
+  Event:
+    | ToolEnabled<"tool-key">
+    | ToolCalled<"tool-key", {
+      a: string
+      b: string
+    }>
+  Child: ["tool-key", {
+    Event: Emitted<"Test">
+    Child: never
+    Throw: never
+    Entry: never
+    Value: never
+  }]
+  Throw: never
+  Entry: never
+  Value: string
+}>()
+
+function* parent() {
+  yield* L.enableTool("parent-tool", "", P, () => {})
+  yield* L.branch("fork-key", {
+    *"arm-key"() {
+      yield* arrowTool
+    },
+  })
+}
+
+type g = typeof parent extends ActorLike<infer Y> ? Y[""] : never
+
+ActorAssertions(parent).assertSpec<
+  {
+    Event:
+      | ToolEnabled<"parent-tool">
+      | ToolCalled<"parent-tool", {
+        a: string
+        b: string
+      }>
+    Child: never
+    Throw: never
+    Entry: never
+    Value: never
+  } | {
+    Event: never
+    Child: ["fork-key", {
+      Event: never
+      Child: ["arm-key", {
+        Event:
+          | ToolEnabled<"Tool">
+          | ToolCalled<"Tool", {
+            a: string
+            b: string
+          }>
+        Child: never
+        Throw: never
+        Entry: never
+        Value: never
+      }]
+      Throw: never
+      Entry: never
+      Value: void
+    }]
+    Throw: never
+    Entry: never
+    Value: never
+  }
+>()

package/actions/getScope.ts

@@ -0,0 +1,11 @@
+import { Action } from "../Action.ts"
+import type { Scope } from "../Scope.ts"
+
+export interface getScope extends Action<"get_scope", never> {}
+
+export function* getScope(): Generator<getScope, Scope> {
+  return yield Action("get_scope", (scope) => ({
+    ...scope,
+    nextArg: scope,
+  }))
+}

package/actions/getSignal.ts

@@ -0,0 +1,10 @@
+import { Action } from "../Action.ts"
+
+export interface getSignal extends Action<"get_signal", never> {}
+
+export function* getSignal(): Generator<getSignal, AbortSignal> {
+  return yield (Action("get_signal", (scope) => ({
+    ...scope,
+    nextArg: scope.controller.signal,
+  })))
+}

package/actions/getTools.ts

@@ -0,0 +1,11 @@
+import { Action } from "../Action.ts"
+import type { Tool } from "../Tool.ts"
+
+export interface getTools extends Action<"get_tools", never> {}
+
+export function* getTools(): Generator<getTools, Set<Tool>> {
+  return yield Action("get_tools", (scope) => ({
+    ...scope,
+    nextArg: scope.tools,
+  }))
+}

package/actions/infer.ts

@@ -0,0 +1,37 @@
+import type { StandardSchemaV1 } from "@standard-schema/spec"
+import { Action } from "../Action.ts"
+import type { InferenceRequested } from "../events/InferenceRequested.ts"
+import type { Inferred } from "../events/Inferred.ts"
+import type { Spec } from "../Spec.ts"
+import type { JSONObject } from "../util/JSONObject.ts"
+import type { JSONValue } from "../util/JSONValue.ts"
+
+export { infer_ as infer }
+
+interface infer_<_T> extends
+  Action<
+    "infer",
+    Spec.Make<{
+      Event: InferenceRequested | Inferred
+    }>
+  >
+{}
+
+function* infer_<T extends JSONValue = string>(type?: StandardSchemaV1<JSONObject, T>): Generator<infer_<T>, T> {
+  return yield Action("infer", async (scope) => {
+    scope.event({
+      type: "inference_requested",
+    })
+    const model = scope.languageModels.values().next().value!
+    scope = await scope.reduce(model.infer(type))
+    scope.event({
+      type: "inferred",
+      value: scope.value,
+    })
+    return {
+      ...scope,
+      nextArg: scope.value,
+    }
+  })
+}
+Object.defineProperty(infer_, "name", { value: "infer" })

package/actions/pushModel.ts

@@ -0,0 +1,32 @@
+import { Action } from "../Action.ts"
+import type { ModelPushed } from "../events/ModelPushed.ts"
+import type { Model, ModelType } from "../Model.ts"
+import type { Spec } from "../Spec.ts"
+import type { JSONKey } from "../util/JSONKey.ts"
+import { applyToModels } from "./actions_common/updateModels.ts"
+import { removeModel } from "./removeModel.ts"
+
+export interface pushModel<K extends JSONKey, M extends ModelType>
+  extends Action<"remove_model", Spec.Make<{ Event: ModelPushed<K, M> }>>
+{}
+
+export function* pushModel<K extends JSONKey, M extends Model>(
+  modelKey: K,
+  model: M,
+): Generator<pushModel<K, M["type"]>, Generator<removeModel<K, M["type"]>, void>> {
+  return yield Action("remove_model", (scope) => {
+    scope.event({
+      type: "model_pushed",
+      modelKey,
+      modelType: model.type,
+    })
+    return {
+      ...scope,
+      ...applyToModels(scope, model, (models) => {
+        models.add(model)
+        return models
+      }),
+      nextArg: removeModel(modelKey, model),
+    }
+  })
+}

package/actions/removeMessage.ts

@@ -0,0 +1,22 @@
+import { Action } from "../Action.ts"
+import type { MessageRemoved } from "../events/MessageRemoved.ts"
+import type { Message } from "../Message.ts"
+import type { Spec } from "../Spec.ts"
+
+export interface removeMessage extends Action<"remove_message", Spec.Make<{ Event: MessageRemoved }>> {}
+
+export function* removeMessage(message: Message): Generator<removeMessage, void> {
+  yield Action("remove_message", (scope) => {
+    scope.event({
+      type: "message_removed",
+      message,
+    })
+    const messages = new Set(scope.messages)
+    messages.delete(message)
+    return {
+      ...scope,
+      nextArg: message,
+      messages,
+    }
+  })
+}

package/actions/removeModel.ts

@@ -0,0 +1,31 @@
+import { Action } from "../Action.ts"
+import type { ModelRemoved } from "../events/ModelRemoved.ts"
+import type { Model, ModelType } from "../Model.ts"
+import type { Spec } from "../Spec.ts"
+import type { JSONKey } from "../util/JSONKey.ts"
+import { applyToModels } from "./actions_common/updateModels.ts"
+
+export interface removeModel<K extends JSONKey, M extends ModelType>
+  extends Action<"remove_model", Spec.Make<{ Event: ModelRemoved<K, M> }>>
+{}
+
+export function* removeModel<K extends JSONKey, M extends Model>(
+  modelKey: K,
+  model: M,
+): Generator<removeModel<K, M["type"]>, void> {
+  yield Action("remove_model", (scope) => {
+    scope.event({
+      type: "model_removed",
+      modelKey,
+      modelType: model.type,
+    })
+    return {
+      ...scope,
+      ...applyToModels(scope, model, (models) => {
+        models.delete(model)
+        return models
+      }),
+      nextArg: undefined,
+    }
+  })
+}

package/actions/setMessages.ts

@@ -0,0 +1,66 @@
+import { Action } from "../Action.ts"
+import type { Actor } from "../Actor.ts"
+import type { MessagesSet } from "../events/MessagesSet.ts"
+import type { Message } from "../Message.ts"
+import type { Spec } from "../Spec.ts"
+import { isPropertyKey } from "../util/isPropertyKey.ts"
+import type { JSONKey } from "../util/JSONKey.ts"
+import type { PromiseOr } from "../util/PromiseOr.ts"
+
+export function setMessages(
+  setter: (messages: Array<Message>) => PromiseOr<Array<Message>>,
+): Generator<
+  Action<
+    "set_messages",
+    Spec.Make<{
+      Event: MessagesSet
+    }>
+  >,
+  Array<Message>
+>
+export function setMessages<K extends JSONKey, Y extends Action>(
+  key: K,
+  setter: (messages: Array<Message>) => Actor<Y, Array<Message>>,
+): Generator<
+  Action<
+    "set_messages",
+    Spec.Make<{
+      Event: MessagesSet
+      Child: [K, Y[""]]
+      Entry: Y[""]["Entry"]
+      Value: Array<Message>
+    }>
+  >,
+  Array<Message>
+>
+export function* setMessages(
+  setterOrKey: JSONKey | ((messages: Array<Message>) => PromiseOr<Array<Message>>),
+  maybeSetter?: (messages: Array<Message>) => Actor<Action, Array<Message>>,
+): Generator<Action<"set_messages">, Array<Message>> {
+  return yield Action("set_messages", async (scope) => {
+    if (isPropertyKey(setterOrKey)) {
+      const setterScope = scope.fork("set_messages", [setterOrKey])
+      const reduced = await setterScope.reduce(maybeSetter!([...scope.messages]))
+      const { value } = reduced
+      setterScope.event({
+        type: "returned",
+        value,
+      })
+      setterScope.event({
+        type: "messages_set",
+        messages: value,
+      })
+      return {
+        ...scope,
+        messages: value,
+        nextArg: scope.messages,
+      }
+    }
+    const messages = await setterOrKey([...scope.messages])
+    return {
+      ...scope,
+      messages,
+      nextArg: scope.messages,
+    }
+  })
+}

package/actions/throw.ts

@@ -0,0 +1,18 @@
+import { Action } from "../Action.ts"
+import type { Spec } from "../Spec.ts"
+import type { EnsureNarrow } from "../util/EnsureNarrow.ts"
+
+export { throw_ as throw }
+
+interface throw_<V> extends Action<"throw", Spec.Make<{ Throw: V }>> {}
+
+function* throw_<V>(value: V, ...[_error]: EnsureNarrow<V>): Generator<throw_<V>, never> {
+  return (yield Action("throw", (scope) => {
+    return {
+      ...scope,
+      thrown: value,
+      nextArg: undefined,
+    }
+  })) as never
+}
+Object.defineProperty(throw_, "name", { value: "throw" })

package/cli/WriteHandler.ts

@@ -0,0 +1,35 @@
+import { mkdir, writeFile } from "node:fs/promises"
+import { type ParsedPath, relative, resolve } from "node:path"
+import type { EventResolved } from "../events/EventResolved.ts"
+
+export async function WriteHandler({
+  stateDir,
+  parsedPath,
+  configDir,
+  startTime,
+}: {
+  stateDir: string
+  execId: string | undefined
+  parsedPath: ParsedPath
+  startTime: number
+  configDir: string
+}): Promise<(event: EventResolved) => Promise<void>> {
+  const destDir = resolve(stateDir, relative(configDir, parsedPath.dir), parsedPath.name, startTime.toString())
+  let ensureDir: undefined | PromiseWithResolvers<void>
+  let i = 0
+  return async (event) => {
+    if (!ensureDir) {
+      ensureDir = Promise.withResolvers()
+      ;(async () => {
+        try {
+          await mkdir(destDir, { recursive: true })
+        } catch (_e: unknown) {}
+        ensureDir.resolve()
+      })()
+    }
+    await ensureDir.promise
+    const key = `${i++}__${event.scope.join("__")}__${event.type}.json`
+    const destPath = resolve(destDir, key)
+    await writeFile(destPath, JSON.stringify(event, null, 2), "utf-8")
+  }
+}

package/cli/cli_common.ts

@@ -0,0 +1,3 @@
+export interface CliCtx {
+  ctl: AbortController
+}

package/cli/main.ts

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+
+import process from "node:process"
+import { L } from "../index.ts"
+import type { CliCtx } from "./cli_common.ts"
+import { runExec } from "./runExec.ts"
+
+const args = process.argv.slice(2)
+const command = L.enum("exec").assert(args.shift())
+const ctl = new AbortController()
+
+const cliCtx: CliCtx = { ctl }
+
+switch (command) {
+  case "exec": {
+    await runExec(cliCtx, args)
+    break
+  }
+}

package/cli/runExec.ts

@@ -0,0 +1,68 @@
+import { dirname, isAbsolute, parse, resolve } from "node:path"
+import { parseArgs, type ParseArgsConfig } from "node:util"
+import { type Actor, type EventResolved, Exec, L, type LEvent, type LiminalConfig } from "../index.ts"
+import type { CliCtx } from "./cli_common.ts"
+import { WriteHandler } from "./WriteHandler.ts"
+
+const options = {
+  config: {
+    type: "string",
+    default: "liminal.ts",
+    short: "c",
+  },
+  execId: {
+    type: "string",
+    short: "i",
+  },
+} satisfies ParseArgsConfig["options"]
+
+export async function runExec(ctx: CliCtx, args: Array<string>) {
+  let {
+    values: {
+      config: configPath,
+      execId,
+    },
+    positionals,
+  } = parseArgs({
+    args,
+    strict: true,
+    allowPositionals: true,
+    options,
+  })
+  const configPathResolved = resolve(configPath)
+  const configDir = dirname(configPathResolved)
+  const config = await import(configPathResolved).then(({ default: default_ }) => default_ as LiminalConfig)
+  const actorPathInitial = L.string.assert(positionals[0])
+  let actorPathResolved: string
+  if (isAbsolute(actorPathInitial)) {
+    actorPathResolved = actorPathInitial
+  } else {
+    actorPathResolved = resolve(configDir, ...config.actors ? [config.actors] : [], actorPathInitial)
+  }
+  if (!actorPathResolved.endsWith(".ts")) {
+    actorPathResolved = `${actorPathResolved}.ts`
+  }
+  const parsedPath = parse(actorPathResolved)
+  const actorLike = await import(actorPathResolved).then(({ default: default_ }) => default_ as () => Actor)
+  const startTime = Date.now()
+  const writeHandlerOrNoop = config.write
+    ? await WriteHandler({
+      configDir,
+      parsedPath,
+      execId,
+      startTime,
+      stateDir: typeof config.write === "string" ? config.write : ".liminal",
+    })
+    : undefined
+  const printHandlerOrNoop = config.silent ? undefined : (event: EventResolved) => console.log(event)
+  const exec = Exec(actorLike, {
+    default: config.default,
+    args: config.args!,
+  })
+  await exec((event) => {
+    printHandlerOrNoop?.(event)
+    writeHandlerOrNoop?.(event)
+  }, {
+    signal: ctx.ctl.signal,
+  })
+}

package/dist/Action.d.ts

@@ -0,0 +1,15 @@
+import type { Scope } from "./Scope.ts";
+import type { Spec } from "./Spec.ts";
+import type { PromiseOr } from "./util/PromiseOr.ts";
+export interface Action<K extends string = string, S extends Spec = Spec> {
+    "": S;
+    type: K;
+    [ActionKey]: true;
+    trace: string;
+    reducer(this: this, scope: Scope): PromiseOr<Scope>;
+}
+export type ActionReducer<K extends string, S extends Spec> = (this: Action<K, S>, scope: Scope) => PromiseOr<Scope>;
+export declare function Action<K extends string, S extends Spec>(type: K, reducer: ActionReducer<K, S>): Action<K, S>;
+export type ActionKey = typeof ActionKey;
+export declare const ActionKey: unique symbol;
+export declare function isAction(value: unknown): value is Action;

package/dist/Action.js

@@ -0,0 +1,13 @@
+export function Action(type, reducer) {
+    return {
+        type,
+        [ActionKey]: true,
+        trace: new Error().stack,
+        reducer,
+    };
+}
+export const ActionKey = Symbol("Liminal/Action");
+export function isAction(value) {
+    return typeof value === "object" && value !== null && ActionKey in value;
+}
+//# sourceMappingURL=Action.js.map

package/dist/Action.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Action.js","sourceRoot":"","sources":["../Action.ts"],"names":[],"mappings":"AAcA,MAAM,UAAU,MAAM,CAAmC,IAAO,EAAE,OAA4B;IAC5F,OAAQ;QACN,IAAI;QACJ,CAAC,SAAS,CAAC,EAAE,IAAI;QACjB,KAAK,EAAE,IAAI,KAAK,EAAE,CAAC,KAAM;QACzB,OAAO;KACmC,CAAA;AAC9C,CAAC;AAGD,MAAM,CAAC,MAAM,SAAS,GAAG,MAAM,CAAC,gBAAgB,CAAC,CAAA;AAEjD,MAAM,UAAU,QAAQ,CAAC,KAAc;IACrC,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,IAAI,SAAS,IAAI,KAAK,CAAA;AAC1E,CAAC"}

package/dist/Actor.d.ts

@@ -0,0 +1,14 @@
+import type { Action } from "./Action.ts";
+import type { DeferredOr } from "./util/DeferredOr.ts";
+import type { IteratorLike } from "./util/IteratorLike.ts";
+import type { JSONKey } from "./util/JSONKey.ts";
+export type Actor<Y extends Action = Action, R = any> = IteratorLike<Y, R>;
+export type ActorLike<Y extends Action = Action, R = any> = DeferredOr<Actor<Y, R>>;
+export type ActorLikeY<A extends ActorLike> = A extends ActorLike<infer Y> ? Y : never;
+export type ActorLikeT<A extends ActorLike> = A extends ActorLike<Action, infer T> ? T : never;
+export type ActorLikes = ActorLikeArray | ActorLikeRecord;
+export type ActorLikeArray = Array<ActorLike>;
+export type ActorLikeRecord = Record<JSONKey, ActorLike>;
+export type ActorLikesT<A extends ActorLikes> = {
+    -readonly [K in keyof A]: A[K] extends ActorLike<Action, infer T> ? T : never;
+} & {};

package/dist/Actor.js

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

package/dist/Actor.js.map

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

package/dist/Exec.d.ts

@@ -0,0 +1,27 @@
+import type { Action } from "./Action.ts";
+import type { Actor } from "./Actor.ts";
+import type { EventHandler } from "./events/EventHandler.ts";
+import type { EventResolved, ExtractEventResolved } from "./events/EventResolved.ts";
+import type { LanguageModel } from "./Model.ts";
+import type { FromEntries } from "./util/FromEntries.ts";
+import type { JSONKey } from "./util/JSONKey.ts";
+export interface Exec<Y extends Action = Action, T = any> {
+    (handler?: EventHandler<Extract<ExtractEventResolved<Y[""]> & {}, EventResolved>>, options?: ExecOptions): Promise<T>;
+}
+export interface ExecConfig {
+    default: LanguageModel;
+    args?: Record<JSONKey, any>;
+}
+export interface ExecOptions {
+    signal?: AbortSignal;
+}
+export type ExtractExecConfig<Y extends Action> = {
+    default: LanguageModel;
+} & ([
+    Y[""]["Entry"]
+] extends [never] ? {
+    args?: undefined;
+} : {
+    args: FromEntries<Y[""]["Entry"]>;
+});
+export declare function Exec<Y extends Action, T>(createActor: () => Actor<Y, T>, config: ExtractExecConfig<Y>): Exec<Y, T>;

package/dist/Exec.js

@@ -0,0 +1,22 @@
+import { RootScope } from "./Scope.js";
+export function Exec(createActor, config) {
+    // TODO: consider `Result` type.
+    return async (handler, options) => {
+        let scope = RootScope(config.default, config.args, handler, options?.signal);
+        scope = await scope.reduce(createActor());
+        const { signal: { aborted, reason } } = scope.controller;
+        if (aborted) {
+            scope.event({
+                type: "aborted",
+                reason,
+            });
+            throw reason;
+        }
+        scope.event({
+            type: "returned",
+            value: scope.value,
+        });
+        return scope.value;
+    };
+}
+//# sourceMappingURL=Exec.js.map

package/dist/Exec.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Exec.js","sourceRoot":"","sources":["../Exec.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,SAAS,EAAc,MAAM,YAAY,CAAA;AAmClD,MAAM,UAAU,IAAI,CAClB,WAA8B,EAC9B,MAA4B;IAE5B,gCAAgC;IAChC,OAAO,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,EAAE;QAChC,IAAI,KAAK,GAAU,SAAS,CAAC,MAAM,CAAC,OAAO,EAAE,MAAM,CAAC,IAAI,EAAE,OAAgB,EAAE,OAAO,EAAE,MAAM,CAAC,CAAA;QAC5F,KAAK,GAAG,MAAM,KAAK,CAAC,MAAM,CAAC,WAAW,EAAE,CAAC,CAAA;QACzC,MAAM,EAAE,MAAM,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE,EAAE,GAAG,KAAK,CAAC,UAAU,CAAA;QACxD,IAAI,OAAO,EAAE,CAAC;YACZ,KAAK,CAAC,KAAK,CAAC;gBACV,IAAI,EAAE,SAAS;gBACf,MAAM;aACP,CAAC,CAAA;YACF,MAAM,MAAM,CAAA;QACd,CAAC;QACD,KAAK,CAAC,KAAK,CAAC;YACV,IAAI,EAAE,UAAU;YAChB,KAAK,EAAE,KAAK,CAAC,KAAK;SACnB,CAAC,CAAA;QACF,OAAO,KAAK,CAAC,KAAK,CAAA;IACpB,CAAC,CAAA;AACH,CAAC"}

package/dist/L.d.ts

@@ -0,0 +1,26 @@
+export * from "./_.ts";
+export * from "./actions/abort.ts";
+export * from "./actions/actions_derived/clear.ts";
+export * from "./actions/actions_derived/declareModel.ts";
+export * from "./actions/actions_derived/declareModel.ts";
+export * from "./actions/actions_derived/getMessages.ts";
+export * from "./actions/actions_derived/messages.ts";
+export * from "./actions/appendMessage.ts";
+export * from "./actions/await.ts";
+export * from "./actions/branch.ts";
+export * from "./actions/catch.ts";
+export * from "./actions/declareArg.ts";
+export * from "./actions/disableTool.ts";
+export * from "./actions/embed.ts";
+export * from "./actions/emit.ts";
+export * from "./actions/enableTool.ts";
+export * from "./actions/getScope.ts";
+export * from "./actions/getSignal.ts";
+export * from "./actions/getTools.ts";
+export * from "./actions/infer.ts";
+export * from "./actions/pushModel.ts";
+export * from "./actions/removeModel.ts";
+export * from "./actions/setMessages.ts";
+export * from "./actions/throw.ts";
+export * from "./types/factories.ts";
+export * from "./actions/actions_derived/metatype.ts";

package/dist/L.js

@@ -0,0 +1,27 @@
+export * from "./_.js";
+export * from "./actions/abort.js";
+export * from "./actions/actions_derived/clear.js";
+export * from "./actions/actions_derived/declareModel.js";
+export * from "./actions/actions_derived/declareModel.js";
+export * from "./actions/actions_derived/getMessages.js";
+export * from "./actions/actions_derived/messages.js";
+export * from "./actions/appendMessage.js";
+export * from "./actions/await.js";
+export * from "./actions/branch.js";
+export * from "./actions/catch.js";
+export * from "./actions/declareArg.js";
+export * from "./actions/disableTool.js";
+export * from "./actions/embed.js";
+export * from "./actions/emit.js";
+export * from "./actions/enableTool.js";
+export * from "./actions/getScope.js";
+export * from "./actions/getSignal.js";
+export * from "./actions/getTools.js";
+export * from "./actions/infer.js";
+export * from "./actions/pushModel.js";
+export * from "./actions/removeModel.js";
+export * from "./actions/setMessages.js";
+export * from "./actions/throw.js";
+export * from "./types/factories.js";
+export * from "./actions/actions_derived/metatype.js";
+//# sourceMappingURL=L.js.map

package/dist/L.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"L.js","sourceRoot":"","sources":["../L.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAA;AACtB,cAAc,oBAAoB,CAAA;AAClC,cAAc,oCAAoC,CAAA;AAClD,cAAc,2CAA2C,CAAA;AACzD,cAAc,2CAA2C,CAAA;AACzD,cAAc,0CAA0C,CAAA;AACxD,cAAc,uCAAuC,CAAA;AACrD,cAAc,4BAA4B,CAAA;AAC1C,cAAc,oBAAoB,CAAA;AAClC,cAAc,qBAAqB,CAAA;AACnC,cAAc,oBAAoB,CAAA;AAClC,cAAc,yBAAyB,CAAA;AACvC,cAAc,0BAA0B,CAAA;AACxC,cAAc,oBAAoB,CAAA;AAClC,cAAc,mBAAmB,CAAA;AACjC,cAAc,yBAAyB,CAAA;AACvC,cAAc,uBAAuB,CAAA;AACrC,cAAc,wBAAwB,CAAA;AACtC,cAAc,uBAAuB,CAAA;AACrC,cAAc,oBAAoB,CAAA;AAClC,cAAc,wBAAwB,CAAA;AACtC,cAAc,0BAA0B,CAAA;AACxC,cAAc,0BAA0B,CAAA;AACxC,cAAc,oBAAoB,CAAA;AAClC,cAAc,sBAAsB,CAAA;AAEpC,cAAc,uCAAuC,CAAA"}