effect-assistant 0.2.0 → 0.4.0

package/src/AssistantEvent.ts

@@ -2,7 +2,7 @@
  * Defines the events that can happen in a chat.
  *
  * A chat is an append-only log of these events, and the log is the source of truth. A chat client
- * receives the part of the log its user sees (`ChatView`), and the model's history is rebuilt
+ * receives the part of the log its user sees (its `Timeline`), and the model's history is rebuilt
  * from the log before every model call. Besides the library's events ({@link AssistantEvent}), a
  * log holds the application's own events ({@link StoredAppEvent}).
  *
@@ -11,8 +11,10 @@
 import * as Response from "effect/ai/Response"
 import * as Predicate from "effect/Predicate"
 import * as Schema from "effect/Schema"
+import type * as SchemaAST from "effect/SchemaAST"
 import { ChatId } from "./ChatId.ts"
 import { InputId, make as makeInputId } from "./InputId.ts"
+import { inputKey } from "./internal/input.ts"
 import { RunId } from "./RunId.ts"
 
 /**
@@ -138,13 +140,30 @@ export class SpecialistFinished extends Schema.TaggedClass<SpecialistFinished>()
   error: Schema.optional(Schema.String)
 }) {}
 
+/**
+ * Represents the user's decision on a tool call that waits for their approval: `"approved"`, so
+ * the call runs, or `"rejected"`, with an optional short reason the model reads.
+ *
+ * Its id is fixed per call (see `ToolApproval.approve`), so a decision is stored once. A decision on
+ * a call that isn't waiting any more (decided, or expired) isn't stored.
+ *
+ * @category schemas
+ * @since 0.4.0
+ */
+export class ApprovalDecision extends Schema.TaggedClass<ApprovalDecision>()("ApprovalDecision", {
+  id: InputId,
+  callId: Schema.String,
+  decision: Schema.Literals(["approved", "rejected"]),
+  reason: Schema.optional(Schema.String.check(Schema.isMaxLength(500)))
+}) {}
+
 /**
  * Schema for every input `Assistant.submit` accepts.
  *
  * @category schemas
  * @since 0.1.0
  */
-export const Input = Schema.Union([UserMessage, BlockAnswer, SpecialistFinished])
+export const Input = Schema.Union([UserMessage, BlockAnswer, SpecialistFinished, ApprovalDecision])
 
 /**
  * Represents an input to an assistant.
@@ -155,7 +174,8 @@ export const Input = Schema.Union([UserMessage, BlockAnswer, SpecialistFinished]
 export type Input = typeof Input.Type
 
 /**
- * Schema for the inputs from the chat's user, which are messages and block answers.
+ * Schema for the inputs from the chat's user, which are messages, block answers, and decisions on
+ * tool calls that wait for their approval.
  *
  * A turn owes each one a reply. It is also what a chat client usually may submit, since the app's
  * events come from the server.
@@ -163,7 +183,7 @@ export type Input = typeof Input.Type
  * @category schemas
  * @since 0.1.0
  */
-export const UserInput = Schema.Union([UserMessage, BlockAnswer])
+export const UserInput = Schema.Union([UserMessage, BlockAnswer, ApprovalDecision])
 
 /**
  * Represents an input from the chat's user.
@@ -398,6 +418,36 @@ export class BlocksClosed extends Schema.TaggedClass<BlocksClosed>()("BlocksClos
   messageIds: Schema.Array(Schema.String)
 }) {}
 
+/**
+ * Represents a tool call that waits for the user's approval instead of running: its tool needs
+ * approval (Effect's `needsApproval`).
+ *
+ * **Details**
+ *
+ * It holds the call's id, the tool, and its params, in JSON, as the model wrote them. The model
+ * reads it as the call's result, saying it waits for the user; the user's
+ * {@link ApprovalDecision} decides it, and an approved call runs then, with the same id.
+ *
+ * @category schemas
+ * @since 0.4.0
+ */
+export class ApprovalRequested extends Schema.TaggedClass<ApprovalRequested>()("ApprovalRequested", {
+  callId: Schema.String,
+  tool: Schema.String,
+  params: Schema.Json
+}) {}
+
+/**
+ * Represents tool calls that waited for the user's approval and won't run: the user moved on, like
+ * the ones `ToolApproval.closeStale` expires. The model reads that they weren't approved.
+ *
+ * @category schemas
+ * @since 0.4.0
+ */
+export class ApprovalsExpired extends Schema.TaggedClass<ApprovalsExpired>()("ApprovalsExpired", {
+  callIds: Schema.Array(Schema.String)
+}) {}
+
 /**
  * Schema for every event the library defines.
  *
@@ -417,6 +467,9 @@ export const AssistantEvent = Schema.Union([
   SpecialistStarted,
   SpecialistFinished,
   BlocksClosed,
+  ApprovalRequested,
+  ApprovalDecision,
+  ApprovalsExpired,
   ChatDeleted
 ])
 
@@ -444,19 +497,43 @@ const libraryTags: ReadonlySet<string> = new Set(
  */
 export const AppTag = Schema.String.pipe(Schema.brand("~effect-assistant/AppTag"))
 
+/**
+ * Represents the schema of one of the application's own events, as `Assistant.make`'s `events`
+ * takes it.
+ *
+ * **Details**
+ *
+ * It is a tagged struct or class (`Schema.TaggedStruct`, `Schema.TaggedClass`) whose `_tag` is a
+ * string literal other than the library's, and that needs no services. The log stores the event in
+ * the schema's JSON form.
+ *
+ * @category models
+ * @since 0.3.0
+ */
+export type AppEventSchema = Schema.Codec<{ readonly _tag: string }, { readonly _tag: string }> & {
+  readonly fields: { readonly _tag: { readonly ast: SchemaAST.AST } }
+}
+
 /**
  * Schema for one of the application's own events as it is stored, with its `_tag` and its fields
  * in JSON.
  *
- * An assistant made with `events: [AppEvent.make(Summary)]` decodes it to a `Summary` in
- * `CurrentChat`'s `entries` and in its `subscribe`.
+ * **Details**
+ *
+ * An assistant made with `events: [Summary]` decodes it to a `Summary` in `CurrentChat`'s
+ * `entries` and in its `subscribe`.
+ *
+ * An event that came in through the assistant's `submit`, from outside a turn, is an input, and the
+ * log marks it with a `"~effect-assistant/input": true` key (see {@link isAppInput}); one a turn
+ * appended has none. Decoding drops the key, so the app's schemas never see it.
  *
  * @category schemas
  * @since 0.1.0
  */
-export const StoredAppEvent = Schema.StructWithRest(Schema.Struct({ _tag: AppTag }), [
-  Schema.Record(Schema.String, Schema.Json)
-]).check(Schema.makeFilter((event) => !libraryTags.has(event._tag) || `${event._tag} is one of the library's events`))
+export const StoredAppEvent = Schema.StructWithRest(
+  Schema.Struct({ _tag: AppTag, [inputKey]: Schema.optionalKey(Schema.Literal(true)) }),
+  [Schema.Record(Schema.String, Schema.Json)]
+).check(Schema.makeFilter((event) => !libraryTags.has(event._tag) || `${event._tag} is one of the library's events`))
 
 /**
  * Represents one of the application's own events, as it is stored.
@@ -474,6 +551,18 @@ export type StoredAppEvent = typeof StoredAppEvent.Type
  */
 export const isLibraryEvent = (event: { readonly _tag: string }): event is AssistantEvent => libraryTags.has(event._tag)
 
+/**
+ * Returns whether one of the application's events, as the log stores it, is an input: it came in
+ * through the assistant's `submit`, from outside a turn, so storing it woke a turn. An event a turn
+ * appended (`CurrentChat`'s `append`) isn't, and neither is a decoded one, which no longer has the
+ * mark.
+ *
+ * @category guards
+ * @since 0.3.0
+ */
+export const isAppInput = (event: { readonly _tag: string }): boolean =>
+  !isLibraryEvent(event) && Predicate.hasProperty(event, inputKey) && event[inputKey] === true
+
 /**
  * Represents a chat's entry with any event in it, either the library's or the application's own
  * (decoded or not).
@@ -516,10 +605,10 @@ export type Entry = typeof Entry.Type
 
 /**
  * Returns whether an event is one of the library's inputs, which are a user message, a block
- * answer, or a finished specialist run.
+ * answer, a finished specialist run, or a decision on a tool call waiting for approval.
  *
- * The application's events that wake a turn are inputs too, but only their assistant knows which
- * (see `AppEvent`).
+ * The application's events that came in through the assistant's `submit` are inputs too (see
+ * {@link isAppInput}).
  *
  * @category guards
  * @since 0.1.0
@@ -527,7 +616,8 @@ export type Entry = typeof Entry.Type
 export const isInput = (event: { readonly _tag: string }): event is Input =>
   Predicate.isTagged(event, "UserMessage") ||
   Predicate.isTagged(event, "BlockAnswer") ||
-  Predicate.isTagged(event, "SpecialistFinished")
+  Predicate.isTagged(event, "SpecialistFinished") ||
+  Predicate.isTagged(event, "ApprovalDecision")
 
 /**
  * Returns whether an input starts a turn, which every input does except a run the assistant
@@ -546,7 +636,9 @@ export const isWaking = (input: Input): boolean =>
  * @since 0.1.0
  */
 export const isUserInput = (input: Input): input is UserInput =>
-  Predicate.isTagged(input, "UserMessage") || Predicate.isTagged(input, "BlockAnswer")
+  Predicate.isTagged(input, "UserMessage") ||
+  Predicate.isTagged(input, "BlockAnswer") ||
+  Predicate.isTagged(input, "ApprovalDecision")
 
 /**
  * Returns whether an event ends a turn, and so says how far the assistant has read.

package/src/AssistantLoop.ts

@@ -161,8 +161,10 @@ const toolsOf = <T extends Record<string, Tool.Any>>(toolkit: Toolkit.Toolkit<T>
  * the step's result and decides what comes next, with `AssistantLoop.next(state)` or
  * `AssistantLoop.stop()`.
  *
- * A tool with Effect's `needsApproval` set fails the loop before the model is called: the
- * library doesn't run calls that wait for approval (see the guide on involving the user).
+ * In a turn's loop, a call to a tool with Effect's `needsApproval` doesn't run: the step emits an
+ * `ApprovalRequested` for it, and ends the turn, which waits for the user (see `ToolApproval`). A
+ * call the user approved runs at the start of the next step, before the model is called. A
+ * specialist's run can't wait for the user: such a call fails, and the run reads why.
  *
  * @category constructors
  * @since 0.1.0

package/src/BlockKit.ts

@@ -14,7 +14,7 @@ import * as Predicate from "effect/Predicate"
 import * as Schema from "effect/Schema"
 import * as AssistantEvent from "./AssistantEvent.ts"
 import type * as Block from "./Block.ts"
-import type * as ChatView from "./ChatView.ts"
+import type * as Timeline from "./Timeline.ts"
 import { CurrentChat } from "./CurrentChat.ts"
 import * as InputId from "./InputId.ts"
 
@@ -210,8 +210,8 @@ export interface RenderOptions {
 }
 
 /**
- * Creates a client-side renderer for the blocks on a chat view's messages
- * (`ChatView.AssistantMessage`).
+ * Creates a client-side renderer for the blocks on the assistant's messages in a chat's timeline
+ * (`Timeline.AssistantMessage`).
  *
  * **Details**
  *
@@ -241,7 +241,7 @@ export interface RenderOptions {
  *   order_draft: ({ props }) => <button onClick={() => placeOrder(props)}>Place order</button>
  * })
  *
- * // For each AssistantMessage in the chat's view:
+ * // For each AssistantMessage in the chat's timeline:
  * renderBlock(message, { respond: (answer) => submit(answer) })
  * ```
  *
@@ -251,13 +251,13 @@ export interface RenderOptions {
 export function toClient<Kit extends BlockKit, Out>(
   kit: Kit,
   renderers: Renderers<Kit, Out>
-): (message: ChatView.AssistantMessage, options: RenderOptions) => Out | undefined
+): (message: Timeline.AssistantMessage, options: RenderOptions) => Out | undefined
 // The overload above checks that every kind has a renderer; here each one takes any block's
 // arguments.
 export function toClient<Out>(
   kit: BlockKit,
   renderers: Readonly<Record<string, (args: RenderArgs<Block.Any>) => Out>>
-): (message: ChatView.AssistantMessage, options: RenderOptions) => Out | undefined {
+): (message: Timeline.AssistantMessage, options: RenderOptions) => Out | undefined {
   return (message, options) => {
     if (message.block === undefined) return undefined
 

package/src/Compaction.ts

@@ -18,6 +18,8 @@ import * as AssistantActivity from "./AssistantActivity.ts"
 import * as AssistantEvent from "./AssistantEvent.ts"
 import * as BlockKit from "./BlockKit.ts"
 import { userText } from "./internal/history.ts"
+import { toJsonText } from "./internal/schema.ts"
+import * as ToolApproval from "./ToolApproval.ts"
 
 /**
  * Represents the fields a summary event must have: its text and the last `seq` it covers.
@@ -54,7 +56,7 @@ export const inputTokens = (entries: ReadonlyArray<AssistantEvent.AnyEntry>): nu
 
 /**
  * Returns the items that were open at `throughSeq` and are still open: blocks the user hasn't
- * answered, and specialists that are working. The result is text for
+ * answered, specialists that are working, and tool calls waiting for the user's approval. The result is text for
  * the model, or `None` when nothing is open.
  *
  * @category utils
@@ -100,9 +102,24 @@ export const openItems = (
       : []
   )
 
+  const approvals = [...ToolApproval.fromEntries(entries).values()].flatMap((approval) =>
+    approval.status === "pending" &&
+    opened(
+      seqOf(
+        (event) =>
+          AssistantEvent.isLibraryEvent(event) &&
+          Predicate.isTagged(event, "ApprovalRequested") &&
+          event.callId === approval.request.callId
+      )
+    )
+      ? [`- your call to ${approval.request.tool} (${approval.request.callId}): ${toJsonText(approval.request.params)}`]
+      : []
+  )
+
   const sections = [
     blocks.length > 0 ? `Blocks the user hasn't answered:\n${blocks.join("\n")}` : "",
-    specialists.length > 0 ? `Specialists still working:\n${specialists.join("\n")}` : ""
+    specialists.length > 0 ? `Specialists still working:\n${specialists.join("\n")}` : "",
+    approvals.length > 0 ? `Calls waiting for the user's approval:\n${approvals.join("\n")}` : ""
   ].filter((section) => section.length > 0)
 
   return sections.length === 0 ? Option.none() : Option.some(sections.join("\n\n"))
@@ -138,10 +155,14 @@ export const attachedFiles = (
  * ({@link openItems}), followed by the entries after the summary. When the chat has no summary,
  * the view returns every entry.
  *
+ * The app's other events after the summary stay entries, which the model doesn't read: map those
+ * it should read to messages after this view, as with any history view (see
+ * `Assistant.HistoryView`). A summary the handler appends wakes no turn.
+ *
  * **Example** (Compacting a long chat after each turn)
  *
  * ```ts
- * import { AppEvent, Assistant, type AssistantEvent, Compaction } from "effect-assistant"
+ * import { Assistant, type AssistantEvent, Compaction } from "effect-assistant"
  * import * as LanguageModel from "effect/ai/LanguageModel"
  * import * as Effect from "effect/Effect"
  * import * as Schema from "effect/Schema"
@@ -154,7 +175,7 @@ export const attachedFiles = (
  *
  * declare const transcript: (entries: ReadonlyArray<AssistantEvent.AnyEntry>) => string
  *
- * export const MyAssistant = Assistant.make("my-assistant", { events: [AppEvent.make(Summary)] })
+ * export const MyAssistant = Assistant.make("my-assistant", { events: [Summary] })
  *
  * const MyAssistantLive = MyAssistant.toLayer((turn) => {
  *   const compact = Effect.gen(function* () {

package/src/CurrentChat.ts

@@ -40,7 +40,8 @@ export class CurrentChat extends Context.Service<
     /**
      * Appends events after the chat's last entry and sends them to the chat's subscribers. The
      * events can be the library's or the assistant's own (registered with its `events` option),
-     * such as a summary. An event that wakes a turn is handled by the next turn.
+     * such as a summary. An app event appended here wakes no turn: only one that comes in through
+     * the assistant's `submit` does.
      */
     readonly append: (...events: ReadonlyArray<{ readonly _tag: string }>) => Effect.Effect<void>
   }

package/src/Skill.ts

@@ -1,13 +1,19 @@
 /**
  * Defines skills, which are playbooks with step-by-step instructions for a kind of task.
  *
- * A loop lists its skills as a catalog in the prompt, with each skill's name and description
- * ({@link withCatalog}). The model loads a skill's instructions with the `load_skill` tool when a
- * task matches.
+ * A list of skills becomes a toolkit with one tool, `load_skill` ({@link toolkit}). Its
+ * description is the catalog, each skill's name and when to use it, and the model calls it to read
+ * a skill's instructions when a task matches. Merge it into a loop's toolkit like any other.
  *
  * @since 0.1.0
  */
-import type * as Instructions from "./Instructions.ts"
+import * as Tool from "effect/ai/Tool"
+import * as AiToolkit from "effect/ai/Toolkit"
+import * as Effect from "effect/Effect"
+import type * as Layer from "effect/Layer"
+import * as Schema from "effect/Schema"
+import * as Instructions from "./Instructions.ts"
+import * as ToolFailure from "./ToolFailure.ts"
 
 /**
  * Represents a skill.
@@ -32,7 +38,7 @@ export interface Skill<R = never> {
  *
  * Write the description as a trigger ("Use when…"), since it's all the model sees until it loads
  * the skill. The instructions are text, or an Effect that is resolved each time the skill is
- * loaded.
+ * loaded. Offer skills to a loop with {@link toolkit}.
  *
  * **Example** (Defining a playbook for ordering campaigns)
  *
@@ -45,10 +51,6 @@ export interface Skill<R = never> {
  * 2. You need who it should reach and a budget. Ask for what's missing, one question at a time.
  * 3. When you have both, call start_campaign.`
  * })
- *
- * const MyAssistantLive = MyAssistant.toLayer((turn) =>
- *   turn.loop({ instructions, skills: [orderingCampaigns] })
- * )
  * ```
  *
  * @category constructors
@@ -72,20 +74,128 @@ export const make = <R = never>(
  */
 export type Services<S> = S extends Skill<infer R> ? R : never
 
+const loadSkill = (description: string) =>
+  Tool.make("load_skill", {
+    description,
+    parameters: Schema.Struct({ name: Schema.String }),
+    success: Schema.String,
+    failure: ToolFailure.ToolFailure
+  })
+
 /**
- * Returns the prompt with the skills' catalog appended, or the prompt unchanged when there are no
- * skills.
+ * Represents the `load_skill` tool, which reads a skill's instructions by name.
  *
- * @category utils
- * @since 0.1.0
+ * @category models
+ * @since 0.4.0
+ */
+export type LoadSkill = ReturnType<typeof loadSkill>
+
+/**
+ * Represents a list of skills as a toolkit: the `load_skill` tool, and the layer with its handler.
+ *
+ * `R` is the services the skills' instructions need, which the layer requires.
+ *
+ * @category models
+ * @since 0.4.0
+ */
+export interface Toolkit<R = never> extends AiToolkit.Toolkit<{ readonly load_skill: LoadSkill }> {
+  /** The handler of `load_skill`, which resolves the instructions of these skills. */
+  readonly layer: Layer.Layer<Tool.Handler<"load_skill">, never, R>
+}
+
+const catalog = (skills: ReadonlyArray<Skill<unknown>>): string =>
+  [
+    "Load a skill, a playbook for a kind of task, by name, and follow it for the rest of the task. When one matches what you're doing, load it in the same step as your first lookups, not in a step of its own.",
+    "",
+    "Skills:",
+    ...skills.map((skill) => `- ${skill.name}: ${skill.description}`)
+  ].join("\n")
+
+function toolkitOf<const Skills extends ReadonlyArray<Skill<unknown>>>(
+  skills: Skills
+): Toolkit<Services<Skills[number]>>
+// The overload states what the layer requires: the services of these skills' instructions.
+function toolkitOf(skills: ReadonlyArray<Skill<unknown>>): Toolkit<unknown> {
+  const byName = new Map(skills.map((skill) => [skill.name, skill]))
+  const tools = AiToolkit.make(loadSkill(catalog(skills)))
+
+  const layer = tools.toLayer(
+    Effect.gen(function* () {
+      const context = yield* Effect.context<unknown>()
+
+      return {
+        load_skill: Effect.fnUntraced(function* ({ name }) {
+          const skill = byName.get(name)
+
+          if (skill === undefined) {
+            return yield* ToolFailure.fail(
+              `No skill named ${name}. The skills are: ${skills.map((known) => known.name).join(", ")}.`
+            )
+          }
+
+          const resolved = yield* Instructions.resolve(skill.instructions).pipe(Effect.provideContext(context))
+
+          return resolved.text
+        })
+      }
+    })
+  )
+
+  return Object.assign(tools, { layer })
+}
+
+/**
+ * Creates a toolkit from a list of skills: the `load_skill` tool, whose description lists each
+ * skill's name and when to use it, and its handler's `layer`.
+ *
+ * **Details**
+ *
+ * Merge the toolkit into a loop's own with `Toolkit.merge`, and provide its `layer`, which requires
+ * the services the skills' instructions need. The model loads a skill by name; a name that isn't
+ * in the list is a failure the model reads, with the names there are.
+ *
+ * The handler resolves only the skills of its own list. To offer each user the skills they may
+ * use, build the toolkit in the turn from that user's list, and provide its layer to the loop's
+ * stream (`Stream.provide(skills.layer)`): building one does no work.
+ *
+ * **Example** (Giving an assistant its playbooks)
+ *
+ * ```ts
+ * import { Skill } from "effect-assistant"
+ * import * as Layer from "effect/Layer"
+ * import * as Toolkit from "effect/ai/Toolkit"
+ *
+ * const AssistantSkills = Skill.toolkit([orderingCampaigns, sharingAssets])
+ *
+ * const MyAssistantLive = MyAssistant.toLayer((turn) =>
+ *   turn.loop({ instructions, toolkit: Toolkit.merge(MyTools, AssistantSkills) })
+ * ).pipe(Layer.provide([MyToolsLive, AssistantSkills.layer]))
+ * ```
+ *
+ * **Example** (Offering each user the skills their role allows)
+ *
+ * ```ts
+ * import { Skill } from "effect-assistant"
+ * import * as Effect from "effect/Effect"
+ * import * as Stream from "effect/Stream"
+ * import * as Toolkit from "effect/ai/Toolkit"
+ *
+ * const MyAssistantLive = MyAssistant.toLayer((turn) =>
+ *   Stream.unwrap(
+ *     Effect.map(roleOf(turn.chatId), (role) => {
+ *       const skills = Skill.toolkit(allSkills.filter((skill) => allowed(role, skill)))
+ *
+ *       return turn
+ *         .loop({ instructions, toolkit: Toolkit.merge(MyTools, skills) })
+ *         .pipe(Stream.provide(skills.layer))
+ *     })
+ *   )
+ * )
+ * ```
+ *
+ * @category constructors
+ * @since 0.4.0
  */
-export const withCatalog = <R>(prompt: string, skills: ReadonlyArray<Skill<R>>): string =>
-  skills.length === 0
-    ? prompt
-    : [
-        prompt,
-        "",
-        "## Skills",
-        "Playbooks for common tasks. When one matches what you're doing, load it with load_skill in the same step as your first lookups, and follow it.",
-        ...skills.map((skill) => `- ${skill.name}: ${skill.description}`)
-      ].join("\n")
+export const toolkit: <const Skills extends ReadonlyArray<Skill<unknown>>>(
+  skills: Skills
+) => Toolkit<Services<Skills[number]>> = toolkitOf

package/src/Specialist.ts

@@ -23,7 +23,6 @@ import type { ChatId } from "./ChatId.ts"
 import type { CurrentChat } from "./CurrentChat.ts"
 import type * as Instructions from "./Instructions.ts"
 import type { RunId } from "./RunId.ts"
-import type { Skill } from "./Skill.ts"
 
 const TypeId = "~effect-assistant/Specialist"
 
@@ -123,12 +122,13 @@ export type RunServices = CurrentChat | Runner | LanguageModel.LanguageModel
  * @category models
  * @since 0.1.0
  */
-export interface LoopOptions<T extends Record<string, Tool.Any> = Record<never, never>, RS = never> {
+export interface LoopOptions<T extends Record<string, Tool.Any> = Record<never, never>> {
   readonly instructions: string | Instructions.Resolved
-  /** The loop's tools, as a native toolkit whose handlers come from the layer. */
+  /**
+   * The loop's tools, as a native toolkit whose handlers come from the layer. Merge in a
+   * `Skill.toolkit(...)` for playbooks.
+   */
   readonly toolkit?: Toolkit.Toolkit<T> | undefined
-  /** Playbooks, listed as a catalog in the prompt and loaded with `load_skill` when one matches. */
-  readonly skills?: ReadonlyArray<Skill<RS>> | undefined
   /** The model calls allowed per brief. Defaults to 8. */
   readonly maxSteps?: number | undefined
 }
@@ -149,13 +149,13 @@ export interface Run {
    * (follow-ups and steering). Read it before every model call, as the loop does.
    */
   readonly history: Effect.Effect<ReadonlyArray<Prompt.Message>>
-  /** Runs the agent loop over the run's history, with the given instructions, tools, and skills. */
-  readonly loop: <T extends Record<string, Tool.Any> = Record<never, never>, RS = never>(
-    options: LoopOptions<T, RS>
+  /** Runs the agent loop over the run's history, with the given instructions and tools. */
+  readonly loop: <T extends Record<string, Tool.Any> = Record<never, never>>(
+    options: LoopOptions<T>
   ) => Stream.Stream<
     AssistantLoop.Event,
     AiError.AiError,
-    LanguageModel.LanguageModel | AssistantLoop.ToolkitServices<T> | RS
+    LanguageModel.LanguageModel | AssistantLoop.ToolkitServices<T>
   >
 }