liminal 0.5.1 → 0.5.2

package/Agent.ts

@@ -0,0 +1,10 @@
+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/CHANGELOG.md

@@ -1,5 +1,11 @@
 # liminal
 
+## 0.5.2
+
+### Patch Changes
+
+- de74823: Various API changes, such as infer as a callable object (the object of which implements Symbol.iterator and yields the actual action). Introduced initial "section" action. Also created an adapter for Ollama.
+
 ## 0.5.1
 
 ### Patch Changes

package/Exec.ts

@@ -1,5 +1,5 @@
 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"
@@ -7,27 +7,18 @@ import { RootScope, type Scope } from "./Scope.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] ? {
@@ -38,26 +29,23 @@ export type ExtractExecConfig<Y extends Action> =
       }
   )
 
-export function Exec<Y extends Action, T>(
-  createActor: () => Actor<Y, T>,
+export async function exec<Y extends Action, T>(
+  createAgent: () => Agent<Y, T>,
   config: ExtractExecConfig<Y>,
-): Exec<Y, T> {
-  // TODO: consider `Result` type.
-  return async (handler, options) => {
-    let scope: Scope = RootScope(config.default, config.args, handler as never, options?.signal)
-    scope = await scope.reduce(createActor())
-    const { signal: { aborted, reason } } = scope.controller
-    if (aborted) {
-      scope.event({
-        type: "aborted",
-        reason,
-      })
-      throw reason
-    }
+): Promise<T> {
+  let scope: Scope = RootScope(config as never)
+  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
 }

package/L.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"
 

package/LiminalConfig.ts

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

package/Model.ts

@@ -1,12 +1,12 @@
 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"> {
@@ -15,6 +15,12 @@ export interface EmbeddingModel extends ModelBase<"embedding"> {
 
 interface ModelBase<K extends ModelType> {
   type: K
+  vendor: string
 }
 
 export type ModelType = "language" | "embedding"
+
+export type Models = {
+  language: LanguageModel
+  embedding: EmbeddingModel
+}

package/PathLike.ts

@@ -3,17 +3,15 @@ import type { JSONKey } from "./util/JSONKey.ts"
 
 export type Path = Array<JSONKey>
 export declare namespace Path {
-  export type FromPathLike<P extends PathLike> = Extract<
-    {
-      [K in keyof P]: P[K] extends _ ? JSONKey : P[K]
-    },
-    Path
-  >
+  export 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 {
-  export type FromPath<P extends Path> = {
-    [K in keyof P]: P[K] | _
-  }
+  export type FromPath<P extends Path> = P extends [infer E0, ...infer ERest extends Path]
+    ? [E0 | _, ...FromPath<ERest>]
+    : []
 }

package/Scope.ts

@@ -1,7 +1,8 @@
 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 { 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"
@@ -15,7 +16,7 @@ export interface ChildScope extends ScopeBase<ChildScopeType> {
 }
 
 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> {
@@ -33,18 +34,28 @@ export interface ScopeBase<Type extends ScopeType> {
   readonly handler?: EventHandler
   readonly childForkCounts: Record<JSONKey, number>
   readonly index: number
+  readonly sections: Set<Section>
 
-  reduce(actor: Actor): Promise<Scope>
-  fork(source: ChildScopeType, subpath: Array<JSONKey>): Scope
+  reduce(agent: Agent): Promise<Scope>
+  fork(
+    source: ChildScopeType,
+    subpath: Array<JSONKey>,
+    overrides?: Partial<ChildScope>,
+  ): Scope
   event(event: LEvent): void
 }
 
-export function RootScope(
-  defaultLanguageModel: LanguageModel,
-  args?: Record<JSONKey, any>,
-  handler: EventHandler = () => {},
-  signal?: AbortSignal,
-): RootScope {
+export interface Section {
+  sectionKey: JSONKey
+  messages: Set<Message>
+}
+
+export function RootScope({
+  signal,
+  args,
+  handler,
+  default: defaultLanguageModel,
+}: ExecConfig): RootScope {
   const controller = new AbortController()
   signal?.addEventListener("abort", () => {
     controller.abort()
@@ -60,6 +71,7 @@ export function RootScope(
     languageModels: new Set([defaultLanguageModel]),
     embeddingModels: new Set(),
     childForkCounts: {},
+    sections: new Set(),
     index: 0,
     reduce,
     fork,
@@ -68,19 +80,19 @@ export function RootScope(
   }
 }
 
-async function reduce(this: Scope, actor: Actor): Promise<Scope> {
+async function reduce(this: Scope, agent: Agent): Promise<Scope> {
   const { signal } = this.controller
   let scope = { ...this }
   if (signal.aborted) return scope
   let value: unknown
   try {
-    let current = await actor.next()
+    let current = await agent.next()
     while (!current.done) {
       const { value } = current
       if (signal.aborted) return scope
       scope = await (value as Action).reducer(scope)
       if (signal.aborted) return scope
-      current = await actor.next(scope.nextArg)
+      current = await agent.next(scope.nextArg)
     }
     value = current.value
   } catch (thrown: unknown) {
@@ -93,7 +105,12 @@ async function reduce(this: Scope, actor: Actor): Promise<Scope> {
   }
 }
 
-function fork(this: Scope, type: ChildScopeType, subpath: Array<JSONKey>): ChildScope {
+function fork(
+  this: Scope,
+  type: ChildScopeType,
+  subpath: Array<JSONKey>,
+  overrides?: Partial<ChildScope>,
+): ChildScope {
   const subpathStr = subpath.join(" ")
   let index = this.childForkCounts[subpathStr]
   if (typeof index === "number") {
@@ -116,9 +133,11 @@ function fork(this: Scope, type: ChildScopeType, subpath: Array<JSONKey>): Child
     parent: this,
     value: undefined,
     index,
+    sections: new Set(this.sections),
     reduce,
     fork,
     event,
+    ...overrides ?? {},
   }
   f.event({ type: "forked" })
   return f

package/Tool.ts

@@ -1,6 +1,6 @@
 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 { Scope } from "./Scope.ts"
 import { assert } from "./util/assert.ts"
 import { isJSONValue } from "./util/isJSONValue.ts"
@@ -27,7 +27,7 @@ export function Tool<K extends JSONKey>(config: ToolConfig<K>): Tool<K> {
   }
 }
 
-export type ToolImplementation = (params: any) => Actor<Action, ToolResult> | PromiseOr<ToolResult>
+export type ToolImplementation = (params: any) => Agent<Action, ToolResult> | PromiseOr<ToolResult>
 
 export type ToolExecutor = (args: any) => Promise<JSONValue>
 
@@ -48,7 +48,7 @@ function executor(this: Tool, scope: Scope): ToolExecutor {
       return { value: initial }
     }
     const fork = scope.fork("tool", [this.toolKey])
-    const { value } = await fork.reduce(initial as Actor)
+    const { value } = await fork.reduce(initial as Agent)
     fork.event({
       type: "returned",
       value,

package/actions/actions_derived/clear.ts

@@ -1,6 +1,6 @@
-import { setMessages } from "../../actions/setMessages.ts"
 import type { MessagesSet } from "../../events/MessagesSet.ts"
+import { messages } from "../messages.ts"
 
 export function clear() {
-  return setMessages(() => [])
+  return messages(() => [])
 }

package/actions/actions_derived/declareModel.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from "bun:test"
 import type { LEvent } from "../../events/LEvent.ts"
-import { Exec } from "../../Exec.ts"
+import { exec } from "../../Exec.ts"
 import * as L from "../../L.ts"
 import { TestEmbeddingModel } from "../../testing/TestEmbeddingModel.ts"
 import { TestLanguageModel } from "../../testing/TestLanguageModel.ts"
@@ -8,15 +8,15 @@ import { TestLanguageModel } from "../../testing/TestLanguageModel.ts"
 describe("Model", () => {
   it("generates the expected event sequence", async () => {
     const events: Array<LEvent> = []
-    await Exec(function*() {
-      const a = yield* L.declareModel("secondary")
+    await exec(function*() {
+      const a = yield* L.declareModel("secondary", "language")
       yield* L.branch("fork-key", function*() {
-        const b = yield* L.declareModel("child_a")
-        const c = yield* L.declareModel("child_b")
+        const b = yield* L.declareModel("child_a", "language")
+        const c = yield* L.declareModel("child_b", "embedding")
         yield* b
         yield* c
       })
-      const c = yield* L.declareModel("tertiary")
+      const c = yield* L.declareModel("tertiary", "embedding")
       yield* a
       yield* c
     }, {
@@ -27,7 +27,10 @@ describe("Model", () => {
         child_b: TestEmbeddingModel(),
         tertiary: TestEmbeddingModel(),
       },
-    })((event) => events.push(event))
+      handler(event) {
+        events.push(event)
+      },
+    })
     expect(JSON.stringify(events, null, 2)).toMatchSnapshot()
   })
 })

package/actions/actions_derived/declareModel.ts

@@ -1,9 +1,9 @@
-import type { Model } from "../../Model.ts"
+import type { Models, ModelType } from "../../Model.ts"
 import type { JSONKey } from "../../util/JSONKey.ts"
 import { declareArg } from "../declareArg.ts"
 import { pushModel } from "../pushModel.ts"
 
-export function* declareModel<K extends JSONKey>(key: K) {
-  const model = yield* declareArg(key)<Model>()
+export function* declareModel<K extends JSONKey, M extends ModelType>(key: K, _modelType: M) {
+  const model = yield* declareArg(key)<Models[M]>()
   return yield* pushModel(key, model)
 }

package/actions/actions_derived/messages.ts

@@ -1,4 +1,3 @@
-import type { MessageRemoved } from "../../events/MessageRemoved.ts"
 import type { AssistantContent, UserContent } from "../../Message.ts"
 import { normalizeTaggableArgs, type TaggableArgs } from "../../util/Taggable.ts"
 import { appendMessage } from "../appendMessage.ts"

package/actions/actions_derived/readers_derived.ts

@@ -0,0 +1,15 @@
+import { scope } from "../scope.ts"
+
+export const tools = {
+  *[Symbol.iterator]() {
+    const scope_ = yield* scope
+    return scope_.tools
+  },
+}
+
+export const signal = {
+  *[Symbol.iterator]() {
+    const scope_ = yield* scope
+    return scope_.controller.signal
+  },
+}

package/actions/appendMessage.ts

@@ -1,13 +1,16 @@
 import { Action } from "../Action.ts"
 import type { MessageAppended } from "../events/MessageAppended.ts"
+import type { MessageRemoved } from "../events/MessageRemoved.ts"
 import type { Message, MessageContents, MessageRole, Messages } from "../Message.ts"
 import type { Spec } from "../Spec.ts"
-import { removeMessage } from "./removeMessage.ts"
+import { peekLast } from "../util/peekLast.ts"
 
-export interface appendMessage<M extends Message>
+export interface appendMessage<M extends Message = Message>
   extends Action<"append_message", Spec.Make<{ Event: MessageAppended<M> }>>
 {}
 
+export interface removeMessage extends Action<"remove_message", Spec.Make<{ Event: MessageRemoved }>> {}
+
 export function* appendMessage<R extends MessageRole>(
   role: R,
   content: MessageContents[R],
@@ -17,13 +20,34 @@ export function* appendMessage<R extends MessageRole>(
       role,
       content,
     } as Messages[R] // <-- why isn't this inferred?
+    const section = peekLast(scope.sections)
+    if (section) {
+      section.messages.add(message)
+    }
     scope.event({
       type: "message_appended",
       message,
     })
     return {
       ...scope,
-      nextArg: removeMessage(message),
+      nextArg: (function*(): Generator<removeMessage> {
+        return yield Action("remove_message", (scope) => {
+          scope.event({
+            type: "message_removed",
+            message,
+          })
+          const messages = new Set(scope.messages)
+          messages.delete(message)
+          if (section) {
+            section.messages.delete(message)
+          }
+          return {
+            ...scope,
+            nextArg: message,
+            messages,
+          }
+        })
+      })(),
       messages: new Set([...scope.messages, message]),
     }
   })

package/actions/branch.ts

@@ -1,14 +1,5 @@
 import { Action } from "../Action.ts"
-import type {
-  Actor,
-  ActorLike,
-  ActorLikeArray,
-  ActorLikeRecord,
-  ActorLikesT,
-  ActorLikeT,
-  ActorLikeY,
-} from "../Actor.ts"
-import type { ActorLikes } from "../Actor.ts"
+import type { Agent, AgentLike, AgentLikeT, AgentLikeY } from "../Agent.ts"
 import type { Spec } from "../Spec.ts"
 import type { JSONKey } from "../util/JSONKey.ts"
 import { unwrapDeferred } from "../util/unwrapDeferred.ts"
@@ -19,7 +10,7 @@ export function branch<
   T,
 >(
   key: K,
-  actorLike: ActorLike<Y, T>,
+  agentLike: AgentLike<Y, T>,
 ): Generator<
   Action<
     "branch",
@@ -31,7 +22,7 @@ export function branch<
   >,
   T
 >
-export function branch<K extends JSONKey, const A extends ActorLikeArray>(name: K, actorLikeArray: A): Generator<
+export function branch<K extends JSONKey, const A extends Array<AgentLike>>(name: K, agentLikes: A): Generator<
   Action<
     "branch",
     Spec.Make<{
@@ -39,18 +30,18 @@ export function branch<K extends JSONKey, const A extends ActorLikeArray>(name:
         K,
         {
           [L in keyof A]: Spec.Make<{
-            Child: [L, ActorLikeY<A[L]>[""]]
-            Entry: ActorLikeY<A[L]>[""]["Entry"]
-            Value: ActorLikeT<A[L]>
+            Child: [L, AgentLikeY<A[L]>[""]]
+            Entry: AgentLikeY<A[L]>[""]["Entry"]
+            Value: AgentLikeT<A[L]>
           }>
         }[keyof A],
       ]
-      Entry: ActorLikeY<A[number]>[""]["Entry"]
+      Entry: AgentLikeY<A[number]>[""]["Entry"]
     }>
   >,
-  ActorLikesT<A>
+  AgentLikesT<A>
 >
-export function branch<K extends JSONKey, A extends ActorLikeRecord>(name: K, actorLikeRecord: A): Generator<
+export function branch<K extends JSONKey, A extends Record<JSONKey, AgentLike>>(name: K, agentLikes: A): Generator<
   Action<
     "branch",
     Spec.Make<{
@@ -58,23 +49,23 @@ export function branch<K extends JSONKey, A extends ActorLikeRecord>(name: K, ac
         K,
         {
           [L in Exclude<keyof A, symbol>]: Spec.Make<{
-            Child: [L, ActorLikeY<A[L]>[""]]
-            Entry: ActorLikeY<A[L]>[""]["Entry"]
-            Value: ActorLikeT<A[L]>
+            Child: [L, AgentLikeY<A[L]>[""]]
+            Entry: AgentLikeY<A[L]>[""]["Entry"]
+            Value: AgentLikeT<A[L]>
           }>
         }[Exclude<keyof A, symbol>],
       ]
-      Entry: ActorLikeY<A[keyof A]>[""]["Entry"]
+      Entry: AgentLikeY<A[keyof A]>[""]["Entry"]
     }>
   >,
-  ActorLikesT<A>
+  AgentLikesT<A>
 >
-export function* branch(key: JSONKey, implementation: ActorLike | ActorLikes): Generator<Action<"branch">, any> {
+export function* branch(key: JSONKey, a1: AgentLike | AgentLikes): Generator<Action<"branch">, any> {
   return yield Action("branch", async (scope) => {
-    if (typeof implementation === "function") {
+    if (typeof a1 === "function") {
       const branchScope = scope.fork("branch", [key])
-      const actor = unwrapDeferred(implementation as ActorLike)
-      const { value } = await branchScope.reduce(actor)
+      const agent = unwrapDeferred(a1 as AgentLike)
+      const { value } = await branchScope.reduce(agent)
       branchScope.event({
         type: "returned",
         value,
@@ -84,20 +75,20 @@ export function* branch(key: JSONKey, implementation: ActorLike | ActorLikes): G
         nextArg: value,
       }
     }
-    const armKeys = Array.isArray(implementation)
-      ? Array.from({ length: implementation.length }, (_0, i) => i)
-      : Reflect.ownKeys(implementation) as Array<string>
+    const armKeys = Array.isArray(a1)
+      ? Array.from({ length: a1.length }, (_0, i) => i)
+      : Reflect.ownKeys(a1) as Array<string>
     const values = await Promise.all(armKeys.map(async (armKey) => {
       const branchArmScope = scope.fork("branch_arm", [key, armKey])
-      const actor = unwrapDeferred(implementation[armKey as never]) as Actor
-      const { value } = await branchArmScope.reduce(actor)
+      const agent = unwrapDeferred(a1[armKey as never]) as Agent
+      const { value } = await branchArmScope.reduce(agent)
       branchArmScope.event({
         type: "returned",
         value,
       })
       return value
     }))
-    const value = Array.isArray(implementation)
+    const value = Array.isArray(a1)
       ? values
       : Object.fromEntries(armKeys.map((key, i) => [key, values[i]]))
     return {
@@ -106,3 +97,10 @@ export function* branch(key: JSONKey, implementation: ActorLike | ActorLikes): G
     }
   })
 }
+
+export type AgentLikes = Array<AgentLike> | Record<JSONKey, AgentLike>
+export type AgentLikesT<A extends AgentLikes> =
+  & {
+    -readonly [K in keyof A]: A[K] extends AgentLike<Action, infer T> ? T : never
+  }
+  & {}

package/actions/catch.ts

@@ -1,5 +1,5 @@
 import { Action } from "../Action.ts"
-import type { ActorLike } from "../Actor.ts"
+import type { AgentLike } from "../Agent.ts"
 import type { Spec } from "../Spec.ts"
 import type { JSONKey } from "../util/JSONKey.ts"
 import type { Result } from "../util/Result.ts"
@@ -8,7 +8,7 @@ import { unwrapDeferred } from "../util/unwrapDeferred.ts"
 export { catch_ as catch }
 function* catch_<K extends JSONKey, Y extends Action, T>(
   key: K,
-  actorLike: ActorLike<Y, T>,
+  agentLike: AgentLike<Y, T>,
 ): Generator<
   Action<
     "catch",
@@ -22,7 +22,7 @@ function* catch_<K extends JSONKey, Y extends Action, T>(
   return yield Action("catch", async (scope) => {
     const catchScope = scope.fork("catch", [key])
     try {
-      const { value } = await catchScope.reduce(unwrapDeferred(actorLike))
+      const { value } = await catchScope.reduce(unwrapDeferred(agentLike))
       catchScope.event({
         type: "returned",
         value,

package/actions/embed.ts

@@ -3,12 +3,13 @@ import type { Embedded } from "../events/Embedded.ts"
 import type { EmbeddingRequested } from "../events/EmbeddingRequested.ts"
 import type { Spec } from "../Spec.ts"
 import { assert } from "../util/assert.ts"
+import { peekLast } from "../util/peekLast.ts"
 
 export interface embed extends Action<"embed", Spec.Make<{ Event: EmbeddingRequested | Embedded }>> {}
 
 export function* embed(value: string): Generator<embed, Array<number>> {
   return yield Action("embed", async (scope) => {
-    const model = scope.embeddingModels.values().next().value
+    const model = peekLast(scope.embeddingModels)
     assert(model)
     scope.event({
       type: "embedding_requested",

package/actions/enableTool.ts

@@ -1,6 +1,6 @@
 import type { StandardSchemaV1 } from "@standard-schema/spec"
 import { Action } from "../Action.ts"
-import type { Actor } from "../Actor.ts"
+import type { Agent } from "../Agent.ts"
 import type { ToolCalled } from "../events/ToolCalled.ts"
 import type { ToolEnabled } from "../events/ToolEnabled.ts"
 import type { Spec } from "../Spec.ts"
@@ -34,7 +34,7 @@ export function enableTool<
   key: K,
   description: string,
   params: StandardSchemaV1<JSONObject, A>,
-  implementation: (params: A) => Actor<Y, T>,
+  implementation: (params: A) => Agent<Y, T>,
 ): Generator<
   Action<
     "enable_tool",