liminal 0.5.1 → 0.5.2

package/actions/enableTool.type-test.ts

@@ -1,11 +1,11 @@
 import type { AssertTrue, IsExact } from "conditional-type-checks"
-import type { ActorLike } from "../Actor.ts"
+import type { AgentLike } from "../Agent.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 { AgentAssertions } from "../testing/AgentAssertions.ts"
 import { emit } from "./emit.ts"
 import { enableTool } from "./enableTool.ts"
 
@@ -19,7 +19,7 @@ const arrowTool = L.enableTool("Tool", "", P, (params) => {
   type _ = [AssertTrue<IsExact<typeof params, P>>]
 })
 
-ActorAssertions(arrowTool).assertSpec<{
+AgentAssertions(arrowTool).assertSpec<{
   Event:
     | ToolEnabled<"Tool">
     | ToolCalled<"Tool", {
@@ -34,7 +34,7 @@ ActorAssertions(arrowTool).assertSpec<{
 
 function* _0() {
   const detach = yield* arrowTool
-  ActorAssertions(detach).assertSpec<{
+  AgentAssertions(detach).assertSpec<{
     Event: ToolDisabled<"Tool">
     Child: never
     Throw: never
@@ -49,7 +49,7 @@ const genTool = enableTool("tool-key", "", P, function*(params) {
   return ""
 })
 
-ActorAssertions(genTool).assertSpec<{
+AgentAssertions(genTool).assertSpec<{
   Event:
     | ToolEnabled<"tool-key">
     | ToolCalled<"tool-key", {
@@ -77,9 +77,9 @@ function* parent() {
   })
 }
 
-type g = typeof parent extends ActorLike<infer Y> ? Y[""] : never
+type g = typeof parent extends AgentLike<infer Y> ? Y[""] : never
 
-ActorAssertions(parent).assertSpec<
+AgentAssertions(parent).assertSpec<
   {
     Event:
       | ToolEnabled<"parent-tool">

package/actions/infer.ts

@@ -5,6 +5,7 @@ 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"
+import { peekLast } from "../util/peekLast.ts"
 
 export { infer_ as infer }
 
@@ -17,12 +18,24 @@ interface infer_<_T> extends
   >
 {}
 
-function* infer_<T extends JSONValue = string>(type?: StandardSchemaV1<JSONObject, T>): Generator<infer_<T>, T> {
+const infer_ = Object.assign(
+  function* infer_<T extends JSONValue>(type: StandardSchemaV1<JSONObject, T>): Generator<infer_<T>, T> {
+    return yield* impl(type)
+  },
+  {
+    *[Symbol.iterator](): Iterator<infer_<string>, string> {
+      return yield* impl()
+    },
+  },
+)
+Object.defineProperty(infer_, "name", { value: "infer" })
+
+function* impl(type?: StandardSchemaV1<JSONObject, any>): Generator<infer_<any>, any> {
   return yield Action("infer", async (scope) => {
     scope.event({
       type: "inference_requested",
     })
-    const model = scope.languageModels.values().next().value!
+    const model = peekLast(scope.languageModels)!
     scope = await scope.reduce(model.infer(type))
     scope.event({
       type: "inferred",
@@ -34,4 +47,3 @@ function* infer_<T extends JSONValue = string>(type?: StandardSchemaV1<JSONObjec
     }
   })
 }
-Object.defineProperty(infer_, "name", { value: "infer" })

package/actions/messages.ts

@@ -0,0 +1,62 @@
+import { Action } from "../Action.ts"
+import type { Agent } from "../Agent.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"
+import { type getScope, scope } from "./scope.ts"
+
+interface messages extends Iterable<getScope, Set<Message>> {
+  (messages: Array<Message>): Generator<Action<"set_messages", Spec.Make<{ Event: MessagesSet }>>, Array<Message>>
+  (
+    setter: (messages: Array<Message>) => PromiseOr<Array<Message>>,
+  ): Generator<Action<"set_messages", Spec.Make<{ Event: MessagesSet }>>, Array<Message>>
+  <K extends JSONKey, Y extends Action>(
+    key: K,
+    setter: (messages: Array<Message>) => Agent<Y, void>,
+  ): Generator<
+    Action<
+      "set_messages",
+      Spec.Make<{ Event: MessagesSet; Child: [K, Y[""]]; Entry: Y[""]["Entry"]; Value: Array<Message> }>
+    >,
+    Array<Message>
+  >
+}
+
+export const messages: messages = Object.assign(messages_, {
+  *[Symbol.iterator]() {
+    const scope_ = yield* scope
+    return scope_.messages
+  },
+}) as never
+
+function* messages_(
+  setterOrKey: JSONKey | ((messages: Array<Message>) => PromiseOr<Array<Message>>),
+  maybeSetter?: (messages: Array<Message>) => Agent<Action, void>,
+): 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 { messages } = reduced
+      setterScope.event({
+        type: "messages_set",
+        messages: [...messages],
+      })
+      return {
+        ...scope,
+        messages,
+        nextArg: scope.messages,
+      }
+    }
+    const messages = new Set(Array.isArray(setterOrKey) ? setterOrKey : await setterOrKey([...scope.messages]))
+    return {
+      ...scope,
+      messages,
+      nextArg: scope.messages,
+    }
+  })
+}
+Object.defineProperty(messages_, "name", { value: "messages" })

package/actions/pushModel.ts

@@ -1,15 +1,19 @@
 import { Action } from "../Action.ts"
 import type { ModelPushed } from "../events/ModelPushed.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"
-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 interface removeModel<K extends JSONKey, M extends ModelType>
+  extends Action<"remove_model", Spec.Make<{ Event: ModelRemoved<K, M> }>>
+{}
+
 export function* pushModel<K extends JSONKey, M extends Model>(
   modelKey: K,
   model: M,
@@ -26,7 +30,23 @@ export function* pushModel<K extends JSONKey, M extends Model>(
         models.add(model)
         return models
       }),
-      nextArg: removeModel(modelKey, model),
+      nextArg: (function*(): 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/scope.ts

@@ -0,0 +1,13 @@
+import { Action } from "../Action.ts"
+import type { Scope } from "../Scope.ts"
+
+export interface getScope extends Action<"get_scope", never> {}
+
+export const scope = {
+  *[Symbol.iterator](): Iterator<getScope, Scope> {
+    return yield Action("get_scope", (scope) => ({
+      ...scope,
+      nextArg: scope,
+    }))
+  },
+}

package/actions/section.ts

@@ -0,0 +1,105 @@
+import { Action } from "../Action.ts"
+import type { Agent, AgentLike } from "../Agent.ts"
+import type { SectionCleared } from "../events/SectionCleared.ts"
+import type { Sectioned } from "../events/Sectioned.ts"
+import type { Message } from "../Message.ts"
+import type { Section } from "../Scope.ts"
+import type { Spec } from "../Spec.ts"
+import type { JSONKey } from "../util/JSONKey.ts"
+import { unwrapDeferred } from "../util/unwrapDeferred.ts"
+
+export interface section<K extends JSONKey> extends Action<"section", Spec.Make<{ Event: Sectioned<K> }>> {}
+
+export interface SectionHandle<K extends JSONKey> {
+  clear: Generator<Action<"clear_section", Spec.Make<{ Event: SectionCleared<K> }>>, void>
+  getMessages: () => Generator<Action<"get_section_messages", never>, Set<Message>>
+
+  <L extends JSONKey, Y extends Action, T>(key: L, agentLike: AgentLike<Y, T>): Generator<
+    Action<
+      "run_section",
+      Spec.Make<{
+        Child: [L, Y[""]]
+        Entry: Y[""]["Entry"]
+        Value: T
+      }>
+    >,
+    T
+  >
+}
+
+export function* section<K extends JSONKey>(sectionKey: K): Generator<section<K>, SectionHandle<K>> {
+  return yield Action("section", (scope) => {
+    scope.event({
+      type: "sectioned",
+      sectionKey,
+    })
+    const section: Section = {
+      sectionKey,
+      messages: new Set(),
+    }
+    scope.sections.add(section)
+    return {
+      ...scope,
+      nextArg: Object.assign(
+        function*<L extends JSONKey, Y extends Action, T>(key: L, agentLike: AgentLike<Y, T>): Generator<
+          Action<
+            "run_section",
+            Spec.Make<{
+              Child: [L, Y[""]]
+              Entry: Y[""]["Entry"]
+              Value: T
+            }>
+          >,
+          T
+        > {
+          return yield Action("run_section", async (scope) => {
+            const sectionScope = scope.fork("run_section", [key], {
+              messages: new Set(section.messages),
+            })
+            const reduced = await sectionScope.reduce(unwrapDeferred(agentLike))
+            const { value } = reduced
+            sectionScope.event({
+              type: "returned",
+              value,
+            })
+            return {
+              ...scope,
+              nextArg: value,
+            }
+          })
+        },
+        {
+          getMessages: (function*(): Generator<Action<"get_section_messages", never>, Set<Message>> {
+            return yield Action("get_section_messages", (scope) => ({
+              ...scope,
+              nextArg: new Set(section.messages),
+            }))
+          })(),
+        },
+        {
+          clear:
+            (function*(): Generator<Action<"clear_section", Spec.Make<{ Event: SectionCleared<K> }>>, Set<Message>> {
+              return yield Action("clear_section", (scope) => {
+                const sections = new Set(scope.sections)
+                sections.delete(section)
+                const messages = new Set(scope.messages)
+                section.messages.forEach((message) => {
+                  messages.delete(message)
+                })
+                scope.event({
+                  type: "section_cleared",
+                  sectionKey,
+                })
+                return {
+                  ...scope,
+                  nextArg: messages,
+                  sections,
+                  messages,
+                }
+              })
+            })(),
+        },
+      ),
+    }
+  })
+}

package/cli/cli_common.ts

@@ -1,3 +1,4 @@
 export interface CliCtx {
   ctl: AbortController
+  error(message: string): never
 }

package/cli/main.ts

@@ -9,7 +9,12 @@ const args = process.argv.slice(2)
 const command = L.enum("exec").assert(args.shift())
 const ctl = new AbortController()
 
-const cliCtx: CliCtx = { ctl }
+const cliCtx: CliCtx = {
+  ctl,
+  error(message) { // TODO
+    throw new Error(message)
+  },
+}
 
 switch (command) {
   case "exec": {

package/cli/runExec.ts

@@ -1,6 +1,6 @@
 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 Agent, type EventResolved, exec, L, type LiminalConfig } from "../index.ts"
 import type { CliCtx } from "./cli_common.ts"
 import { WriteHandler } from "./WriteHandler.ts"
 
@@ -32,18 +32,23 @@ export async function runExec(ctx: CliCtx, args: Array<string>) {
   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
+  const agentPathInitial = L.string.assert(positionals[0])
+  let agentPathResolved: string
+  if (isAbsolute(agentPathInitial)) {
+    agentPathResolved = agentPathInitial
   } else {
-    actorPathResolved = resolve(configDir, ...config.actors ? [config.actors] : [], actorPathInitial)
+    agentPathResolved = resolve(configDir, ...config.agents ? [config.agents] : [], agentPathInitial)
   }
-  if (!actorPathResolved.endsWith(".ts")) {
-    actorPathResolved = `${actorPathResolved}.ts`
+  if (!agentPathResolved.endsWith(".ts")) {
+    agentPathResolved = `${agentPathResolved}.ts`
+  }
+  const parsedPath = parse(agentPathResolved)
+  let agentLike: () => Agent
+  try {
+    agentLike = await import(agentPathResolved).then(({ default: default_ }) => default_ as () => Agent)
+  } catch (_e: unknown) {
+    ctx.error(`Could not fine agent file at "${agentPathResolved}".`)
   }
-  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({
@@ -55,14 +60,13 @@ export async function runExec(ctx: CliCtx, args: Array<string>) {
     })
     : undefined
   const printHandlerOrNoop = config.silent ? undefined : (event: EventResolved) => console.log(event)
-  const exec = Exec(actorLike, {
+  await exec(agentLike, {
     default: config.default,
     args: config.args!,
-  })
-  await exec((event) => {
-    printHandlerOrNoop?.(event)
-    writeHandlerOrNoop?.(event)
-  }, {
+    handler(event) {
+      printHandlerOrNoop?.(event)
+      writeHandlerOrNoop?.(event)
+    },
     signal: ctx.ctl.signal,
   })
 }

package/dist/Agent.d.ts

@@ -0,0 +1,7 @@
+import type { Action } from "./Action.ts";
+import type { DeferredOr } from "./util/DeferredOr.ts";
+import type { IteratorLike } from "./util/IteratorLike.ts";
+export type Agent<Y extends Action = Action, R = any> = IteratorLike<Y, R>;
+export type AgentLike<Y extends Action = Action, R = any> = DeferredOr<Agent<Y, R>>;
+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;

package/dist/Agent.js

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

package/dist/Agent.js.map

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

package/dist/Exec.d.ts

@@ -1,22 +1,20 @@
 import type { Action } from "./Action.ts";
-import type { Actor } from "./Actor.ts";
+import type { Agent } from "./Agent.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;
+    handler?: EventHandler;
 }
 export type ExtractExecConfig<Y extends Action> = {
     default: LanguageModel;
+    signal?: AbortSignal;
+    handler?: EventHandler<Extract<ExtractEventResolved<Y[""]> & {}, EventResolved>>;
 } & ([
     Y[""]["Entry"]
 ] extends [never] ? {
@@ -24,4 +22,4 @@ export type ExtractExecConfig<Y extends Action> = {
 } : {
     args: FromEntries<Y[""]["Entry"]>;
 });
-export declare function Exec<Y extends Action, T>(createActor: () => Actor<Y, T>, config: ExtractExecConfig<Y>): Exec<Y, T>;
+export declare function exec<Y extends Action, T>(createAgent: () => Agent<Y, T>, config: ExtractExecConfig<Y>): Promise<T>;

package/dist/Exec.js

@@ -1,22 +1,19 @@
 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;
-        }
+export async function exec(createAgent, config) {
+    let scope = RootScope(config);
+    scope = await scope.reduce(createAgent());
+    const { signal: { aborted, reason } } = scope.controller;
+    if (aborted) {
         scope.event({
-            type: "returned",
-            value: scope.value,
+            type: "aborted",
+            reason,
         });
-        return scope.value;
-    };
+        throw reason;
+    }
+    scope.event({
+        type: "returned",
+        value: scope.value,
+    });
+    return scope.value;
 }
 //# sourceMappingURL=Exec.js.map

package/dist/Exec.js.map

@@ -1 +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"}
+{"version":3,"file":"Exec.js","sourceRoot":"","sources":["../Exec.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,SAAS,EAAc,MAAM,YAAY,CAAA;AA0BlD,MAAM,CAAC,KAAK,UAAU,IAAI,CACxB,WAA8B,EAC9B,MAA4B;IAE5B,IAAI,KAAK,GAAU,SAAS,CAAC,MAAe,CAAC,CAAA;IAC7C,KAAK,GAAG,MAAM,KAAK,CAAC,MAAM,CAAC,WAAW,EAAE,CAAC,CAAA;IACzC,MAAM,EAAE,MAAM,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE,EAAE,GAAG,KAAK,CAAC,UAAU,CAAA;IACxD,IAAI,OAAO,EAAE,CAAC;QACZ,KAAK,CAAC,KAAK,CAAC;YACV,IAAI,EAAE,SAAS;YACf,MAAM;SACP,CAAC,CAAA;QACF,MAAM,MAAM,CAAA;IACd,CAAC;IACD,KAAK,CAAC,KAAK,CAAC;QACV,IAAI,EAAE,UAAU;QAChB,KAAK,EAAE,KAAK,CAAC,KAAK;KACnB,CAAC,CAAA;IACF,OAAO,KAAK,CAAC,KAAK,CAAA;AACpB,CAAC"}

package/dist/L.d.ts

@@ -2,9 +2,8 @@ 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/actions_derived/readers_derived.ts";
 export * from "./actions/appendMessage.ts";
 export * from "./actions/await.ts";
 export * from "./actions/branch.ts";
@@ -14,13 +13,11 @@ 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/messages.ts";
 export * from "./actions/pushModel.ts";
-export * from "./actions/removeModel.ts";
-export * from "./actions/setMessages.ts";
+export * from "./actions/scope.ts";
+export * from "./actions/section.ts";
 export * from "./actions/throw.ts";
 export * from "./types/factories.ts";
 export * from "./actions/actions_derived/metatype.ts";

package/dist/L.js

@@ -2,9 +2,8 @@ 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/actions_derived/readers_derived.js";
 export * from "./actions/appendMessage.js";
 export * from "./actions/await.js";
 export * from "./actions/branch.js";
@@ -14,13 +13,11 @@ 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/messages.js";
 export * from "./actions/pushModel.js";
-export * from "./actions/removeModel.js";
-export * from "./actions/setMessages.js";
+export * from "./actions/scope.js";
+export * from "./actions/section.js";
 export * from "./actions/throw.js";
 export * from "./types/factories.js";
 export * from "./actions/actions_derived/metatype.js";

package/dist/L.js.map

@@ -1 +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"}
+{"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,uCAAuC,CAAA;AACrD,cAAc,8CAA8C,CAAA;AAC5D,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,oBAAoB,CAAA;AAClC,cAAc,uBAAuB,CAAA;AACrC,cAAc,wBAAwB,CAAA;AACtC,cAAc,oBAAoB,CAAA;AAClC,cAAc,sBAAsB,CAAA;AACpC,cAAc,oBAAoB,CAAA;AAClC,cAAc,sBAAsB,CAAA;AAEpC,cAAc,uCAAuC,CAAA"}

package/dist/LiminalConfig.d.ts

@@ -1,6 +1,6 @@
 import type { ExecConfig } from "./Exec.ts";
 export interface LiminalConfig extends ExecConfig {
-    actors?: string;
+    agents?: string;
     silent?: boolean;
     write?: boolean | string;
 }

package/dist/Model.d.ts

@@ -1,16 +1,21 @@
 import type { StandardSchemaV1 } from "@standard-schema/spec";
 import type { Action } from "./Action.ts";
-import type { Actor } from "./Actor.ts";
+import type { Agent } from "./Agent.ts";
 import type { JSONObject } from "./util/JSONObject.ts";
 export type Model = LanguageModel | EmbeddingModel;
 export interface LanguageModel extends ModelBase<"language"> {
-    infer: (type: StandardSchemaV1<JSONObject, any> | undefined) => Actor<Action, any>;
+    infer: (type: StandardSchemaV1<JSONObject, any> | undefined) => Agent<Action, any>;
 }
 export interface EmbeddingModel extends ModelBase<"embedding"> {
     embed: (value: string) => Promise<Array<number>>;
 }
 interface ModelBase<K extends ModelType> {
     type: K;
+    vendor: string;
 }
 export type ModelType = "language" | "embedding";
+export type Models = {
+    language: LanguageModel;
+    embedding: EmbeddingModel;
+};
 export {};

package/dist/PathLike.d.ts

@@ -2,13 +2,10 @@ import type { _ } from "./_.ts";
 import type { JSONKey } from "./util/JSONKey.ts";
 export type Path = Array<JSONKey>;
 export declare namespace Path {
-    type FromPathLike<P extends PathLike> = Extract<{
-        [K in keyof P]: P[K] extends _ ? JSONKey : P[K];
-    }, Path>;
+    type FromPathLike<P extends PathLike> = P extends [infer E0 extends KeyLike, ...infer ERest extends PathLike] ? [E0 extends JSONKey ? E0 : JSONKey, ...FromPathLike<ERest>] : [];
 }
-export type PathLike = Array<JSONKey | _>;
+export type KeyLike = JSONKey | _;
+export type PathLike = Array<KeyLike>;
 export declare namespace PathLike {
-    type FromPath<P extends Path> = {
-        [K in keyof P]: P[K] | _;
-    };
+    type FromPath<P extends Path> = P extends [infer E0, ...infer ERest extends Path] ? [E0 | _, ...FromPath<ERest>] : [];
 }

package/dist/Scope.d.ts

@@ -1,6 +1,7 @@
-import type { Actor } from "./Actor.ts";
+import type { Agent } from "./Agent.ts";
 import type { EventHandler } from "./events/EventHandler.ts";
 import type { LEvent } from "./events/LEvent.ts";
+import type { ExecConfig } from "./Exec.ts";
 import type { Message } from "./Message.ts";
 import type { EmbeddingModel, LanguageModel } from "./Model.ts";
 import type { Tool } from "./Tool.ts";
@@ -12,7 +13,7 @@ export interface ChildScope extends ScopeBase<ChildScopeType> {
     readonly parent: Scope;
 }
 export type RootScopeType = "root";
-export type ChildScopeType = "catch" | "tool" | "branch" | "branch_arm" | "set_messages";
+export type ChildScopeType = "catch" | "tool" | "branch" | "branch_arm" | "set_messages" | "run_section";
 export type ScopeType = RootScopeType | ChildScopeType;
 export interface ScopeBase<Type extends ScopeType> {
     readonly type: Type;
@@ -29,8 +30,13 @@ export interface ScopeBase<Type extends ScopeType> {
     readonly handler?: EventHandler;
     readonly childForkCounts: Record<JSONKey, number>;
     readonly index: number;
-    reduce(actor: Actor): Promise<Scope>;
-    fork(source: ChildScopeType, subpath: Array<JSONKey>): Scope;
+    readonly sections: Set<Section>;
+    reduce(agent: Agent): Promise<Scope>;
+    fork(source: ChildScopeType, subpath: Array<JSONKey>, overrides?: Partial<ChildScope>): Scope;
     event(event: LEvent): void;
 }
-export declare function RootScope(defaultLanguageModel: LanguageModel, args?: Record<JSONKey, any>, handler?: EventHandler, signal?: AbortSignal): RootScope;
+export interface Section {
+    sectionKey: JSONKey;
+    messages: Set<Message>;
+}
+export declare function RootScope({ signal, args, handler, default: defaultLanguageModel, }: ExecConfig): RootScope;