effect-assistant 0.3.0 → 0.5.0

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"))

package/src/Skill.ts

@@ -1,14 +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 Tool from "effect/ai/Tool"
-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.
@@ -24,11 +29,6 @@ export interface Skill<R = never> {
   readonly description: string
   /** Text, or an Effect resolved each time the skill is loaded. */
   readonly instructions: Instructions.Instructions<R>
-  /**
-   * The tools its instructions use. A loop offers the skill only when its toolkit has every one of
-   * them, matched by name. Unset, a loop always offers it.
-   */
-  readonly tools?: ReadonlyArray<Tool.Any> | undefined
 }
 
 /**
@@ -38,12 +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.
- *
- * `tools` lists the tools the instructions use. A loop whose toolkit lacks any of them, matched by
- * name, leaves the skill out of its catalog and of `load_skill`, so a loop that gets its tools per
- * user (by role, say) never offers a playbook it can't follow. A tool that only `ToolDiscovery`
- * finds isn't in the toolkit, so it doesn't count. Without `tools`, every loop offers the skill.
+ * loaded. Offer skills to a loop with {@link toolkit}.
  *
  * **Example** (Defining a playbook for ordering campaigns)
  *
@@ -56,30 +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] })
- * )
- * ```
- *
- * **Example** (Offering a skill only with the tools it uses)
- *
- * ```ts
- * import { Skill } from "effect-assistant"
- * import * as Tool from "effect/ai/Tool"
- * import * as Schema from "effect/Schema"
- *
- * const StartCampaign = Tool.make("start_campaign", {
- *   parameters: Schema.Struct({ campaignId: Schema.String, budget: Schema.Finite }),
- *   success: Schema.String
- * })
- *
- * // Left out of a loop whose toolkit has no start_campaign, like a viewer's.
- * const orderingCampaigns = Skill.make("Ordering a campaign", {
- *   description: "Use when the user wants to order or start a campaign.",
- *   instructions: "When you know who it should reach and the budget, call start_campaign.",
- *   tools: [StartCampaign]
- * })
  * ```
  *
  * @category constructors
@@ -92,10 +63,8 @@ export const make = <R = never>(
     readonly description: string
     /** Text, or an Effect resolved each time the skill is loaded. */
     readonly instructions: Instructions.Instructions<R>
-    /** The tools its instructions use: a loop whose toolkit lacks one leaves the skill out. */
-    readonly tools?: ReadonlyArray<Tool.Any> | undefined
   }
-): Skill<R> => ({ name, description: options.description, instructions: options.instructions, tools: options.tools })
+): Skill<R> => ({ name, description: options.description, instructions: options.instructions })
 
 /**
  * Extracts the services that skills need when they're loaded.
@@ -105,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,15 +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. */
-  readonly toolkit?: Toolkit.Toolkit<T> | undefined
   /**
-   * Playbooks, listed as a catalog in the prompt and loaded with `load_skill` when one matches. A
-   * skill made with `tools` is left out when the toolkit lacks one of them.
+   * The loop's tools, as a native toolkit whose handlers come from the layer. Merge in a
+   * `Skill.toolkit(...)` for playbooks.
    */
-  readonly skills?: ReadonlyArray<Skill<RS>> | undefined
+  readonly toolkit?: Toolkit.Toolkit<T> | undefined
   /** The model calls allowed per brief. Defaults to 8. */
   readonly maxSteps?: number | undefined
 }
@@ -152,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>
   >
 }
 

package/src/Timeline.ts

@@ -2,8 +2,9 @@
  * This module provides a chat's timeline: the chat as its user sees it. A chat client receives the
  * timeline and nothing else.
  *
- * A {@link Timeline} holds the chat's items: the messages with their blocks, and the app's own
- * events it shows (each typed with its event, see {@link EventItem}). It also holds the chat's
+ * A {@link Timeline} holds the chat's items: the messages with their blocks, the app's own events
+ * it shows (each typed with its event, see {@link EventItem}), and the tool calls waiting for the
+ * user's approval ({@link ApprovalItem}). It also holds the chat's
  * {@link Activity}, and whether the last turn failed or the chat was deleted. It never contains the
  * model's output, tool calls or results, what the model read, or why a turn failed. The server
  * streams {@link Change}s by piping the assistant's `subscribe` through {@link changes}, and the
@@ -20,6 +21,7 @@
 import { dual } from "effect/Function"
 import * as Match from "effect/Match"
 import * as Option from "effect/Option"
+import * as Predicate from "effect/Predicate"
 import * as Schema from "effect/Schema"
 import * as SchemaTransformation from "effect/SchemaTransformation"
 import * as Stream from "effect/Stream"
@@ -29,6 +31,7 @@ import * as AssistantEvent from "./AssistantEvent.ts"
 import * as BlockKit from "./BlockKit.ts"
 import { InputId } from "./InputId.ts"
 import * as AppEvents from "./internal/events.ts"
+import * as ToolApproval from "./ToolApproval.ts"
 import { toJson } from "./internal/schema.ts"
 
 /**
@@ -61,7 +64,9 @@ export const Block = Schema.Struct({
   kind: Schema.String,
   props: Schema.Json,
   status: BlockStatus,
-  answer: Schema.optional(Schema.Json)
+  answer: Schema.optional(Schema.Json),
+  /** For a block that shows a tool's result (`Block.fromToolResult`): the result, as the tool's success schema encodes it. */
+  result: Schema.optional(Schema.Json)
 })
 
 /**
@@ -135,8 +140,43 @@ export type EventItem<E> = E extends { readonly _tag: infer Tag extends string }
   : never
 
 /**
- * Represents an item in the chat's timeline: a message the user or the assistant sent, or one of
- * the app's own events it shows (see {@link EventItem}).
+ * Schema for a tool call that waits, or waited, for the user's approval, as an item on the
+ * timeline.
+ *
+ * **Details**
+ *
+ * It is only the yes or no: the assistant's own message tells the user what it asks them to
+ * approve, so the item carries no params. `id` is the call's id, which the decision is for (see
+ * `ToolApproval.approve`), and `tool` the tool's name, for a label. `status` is where the call stands
+ * (`ToolApproval.Status`); `reason` is the user's, when they rejected it with one; `outcome` is how
+ * the approved call went, once it ran. `at` is when the call started waiting, in epoch
+ * milliseconds. A change updates the item in place as the call is decided and run.
+ *
+ * @category schemas
+ * @since 0.4.0
+ */
+export const ApprovalItem = Schema.TaggedStruct("ToolApproval", {
+  id: Schema.String,
+  tool: Schema.String,
+  status: Schema.Literals(["pending", "approved", "rejected", "expired"]),
+  reason: Schema.optional(Schema.String),
+  outcome: Schema.optional(AssistantEvent.ToolOutcome),
+  at: Schema.Finite
+})
+
+/**
+ * Represents a tool call that waits, or waited, for the user's approval, as an item on the
+ * timeline.
+ *
+ * @category models
+ * @since 0.4.0
+ */
+export type ApprovalItem = typeof ApprovalItem.Type
+
+/**
+ * Represents an item in the chat's timeline: a message the user or the assistant sent, one of the
+ * app's own events it shows (see {@link EventItem}), or a tool call waiting for the user's approval
+ * (see {@link ApprovalItem}).
  *
  * **Example** (Showing each item of a chat)
  *
@@ -158,7 +198,7 @@ export type EventItem<E> = E extends { readonly _tag: infer Tag extends string }
  * @category models
  * @since 0.3.0
  */
-export type Item<Events = never> = UserMessage | AssistantMessage | EventItem<Events>
+export type Item<Events = never> = UserMessage | AssistantMessage | EventItem<Events> | ApprovalItem
 
 /**
  * Schema for a specialist that is working for the assistant. It holds the specialist's name and
@@ -227,7 +267,7 @@ export interface Timeline<Events = never> {
  * **Details**
  *
  * A change holds each item that is new or changed (for example, a message whose block was
- * answered or closed), in full. It also holds the current activity, whether the last turn failed,
+ * answered or closed, or a call the user approved), in full. It also holds the current activity, whether the last turn failed,
  * and whether the chat was deleted. `seq` is the position in the chat's log that the change is up
  * to.
  *
@@ -250,7 +290,10 @@ function makeChange<const Events extends ReadonlyArray<AssistantEvent.AppEventSc
 ): Schema.Codec<Change<Events[number]["Type"]>, Schema.Json>
 // The overload states the decoded type: an item per given schema, each typed with its own event.
 function makeChange(events: ReadonlyArray<AssistantEvent.AppEventSchema> = []): Schema.Top {
-  const AnyItem = Schema.toCodecJson(Schema.Union([UserMessage, AssistantMessage, ...events.map(eventItem)]))
+  const AnyItem = Schema.toCodecJson(
+    Schema.Union([UserMessage, AssistantMessage, ApprovalItem, ...events.map(eventItem)])
+  )
+
   const decodeItem = Schema.decodeUnknownOption(AnyItem)
   const encodeItem = Schema.encodeUnknownSync(AnyItem)
 
@@ -280,7 +323,8 @@ function makeChange(events: ReadonlyArray<AssistantEvent.AppEventSchema> = []):
  * **Details**
  *
  * It is the success schema of the RPC that streams a chat's timeline: name the events the chat's
- * users see, the same ones the handler passes to {@link changes} as `show`. Each item decodes its
+ * users see, the same ones the handler passes to {@link changes} as `show`. Tool calls waiting for
+ * approval are always in it, as {@link ApprovalItem}s. Each item decodes its
  * event with that event's schema, so the client gets `Change<Events>` typed with them and folds it
  * with {@link fold}, no definition needed. `Change()` carries no app events.
  *
@@ -417,10 +461,12 @@ interface AnyEventItem {
   readonly event: { readonly _tag: string }
 }
 
+type AnyItem = UserMessage | AssistantMessage | AnyEventItem | ApprovalItem
+
 // What the fold below builds: the overloads that use it type its items with the events shown.
 interface AnyChange {
   readonly seq: number
-  readonly items: ReadonlyArray<UserMessage | AssistantMessage | AnyEventItem>
+  readonly items: ReadonlyArray<AnyItem>
   readonly activity: Activity
   readonly failed: boolean
   readonly deleted: boolean
@@ -575,14 +621,17 @@ const sameActivity = (a: Activity, b: Activity) =>
 
 const folding = (show: ReadonlyArray<AssistantEvent.AppEventSchema>): Folding => {
   const shown = new Map(show.map((schema) => [AppEvents.tagOf(schema), schema]))
+  let approvals: ReadonlyMap<string, ToolApproval.State> = new Map()
   let seq = 0
   let failed = false
   let deleted = false
   let activity = AssistantActivity.empty
   let blocks: ReadonlyMap<string, BlockKit.State> = new Map()
   // The items in order, and the assistant's messages as stored: their blocks change as the chat goes on.
-  const items = new Map<string, UserMessage | AssistantMessage | AnyEventItem>()
+  const items = new Map<string, AnyItem>()
   const sent = new Map<string, AssistantEvent.AssistantMessage>()
+  // The results a block can show, by id: a message shows one stored before it.
+  const results = new Map<string, Schema.Json>()
 
   const blockOf = (message: AssistantEvent.AssistantMessage): Block | undefined => {
     if (message.block === undefined) return undefined
@@ -590,8 +639,11 @@ const folding = (show: ReadonlyArray<AssistantEvent.AppEventSchema>): Folding =>
     const state = blocks.get(message.id)
     const status = state === undefined || state.open ? "open" : state.answer === undefined ? "closed" : "answered"
     const block: Block = { kind: message.block.kind, props: toJson(message.block.props), status }
+    const { resultId } = message.block
+    const result = resultId === undefined ? undefined : results.get(resultId)
+    const shown = result === undefined ? block : { ...block, result }
 
-    return state?.answer === undefined ? block : { ...block, answer: toJson(state.answer.value) }
+    return state?.answer === undefined ? shown : { ...shown, answer: toJson(state.answer.value) }
   }
 
   const itemOf = (message: AssistantEvent.AssistantMessage, at: number): AssistantMessage => {
@@ -634,6 +686,13 @@ const folding = (show: ReadonlyArray<AssistantEvent.AppEventSchema>): Folding =>
           return [answer.messageId]
         },
         BlocksClosed: (closed) => closed.messageIds,
+        ApprovalRequested: () => [],
+        ApprovalDecision: () => {
+          failed = false
+
+          return []
+        },
+        ApprovalsExpired: () => [],
         TurnFailed: () => {
           failed = true
 
@@ -641,7 +700,13 @@ const folding = (show: ReadonlyArray<AssistantEvent.AppEventSchema>): Folding =>
         },
         ModelOutput: () => [],
         ToolStarted: () => [],
-        ToolResult: () => [],
+        ToolResult: (result) => {
+          if (result.resultId !== undefined && result.outcome === "success") {
+            results.set(result.resultId, result.full ?? result.result)
+          }
+
+          return []
+        },
         TurnStarted: () => [],
         TurnCompleted: () => [],
         SpecialistStarted: () => [],
@@ -670,8 +735,38 @@ const folding = (show: ReadonlyArray<AssistantEvent.AppEventSchema>): Folding =>
     }))
   }
 
+  const callsOf = (event: AssistantEvent.AssistantEvent): ReadonlyArray<string> =>
+    Predicate.isTagged(event, "ApprovalsExpired")
+      ? event.callIds
+      : Predicate.isTagged(event, "ApprovalRequested") ||
+          Predicate.isTagged(event, "ApprovalDecision") ||
+          Predicate.isTagged(event, "ToolResult")
+        ? [event.callId]
+        : []
+
+  // The items of the calls this entry changed.
+  const approvalItems = (event: AssistantEvent.AssistantEvent, before: ReadonlyMap<string, ToolApproval.State>) =>
+    callsOf(event).flatMap((callId) => {
+      const state = approvals.get(callId)
+
+      if (state === undefined || state === before.get(callId)) return []
+
+      const item = ApprovalItem.make({
+        id: callId,
+        tool: state.request.tool,
+        status: state.status,
+        reason: state.reason,
+        outcome: state.outcome,
+        at: state.at
+      })
+
+      items.set(callId, item)
+
+      return [item]
+    })
+
   const step = (entry: AssistantEvent.AnyEntry): AnyChange | undefined => {
-    const before = { activity: activityOf(activity), failed, deleted }
+    const previous = { activity: activityOf(activity), failed, deleted }
     const { event } = entry
 
     seq = entry.seq
@@ -682,7 +777,7 @@ const folding = (show: ReadonlyArray<AssistantEvent.AppEventSchema>): Folding =>
 
       return Option.match(eventItemOf(entry), {
         onNone: () =>
-          sameActivity(before.activity, now) ? undefined : { seq, items: [], activity: now, failed, deleted },
+          sameActivity(previous.activity, now) ? undefined : { seq, items: [], activity: now, failed, deleted },
         onSome: (item) => {
           items.set(item.id, item)
 
@@ -693,6 +788,9 @@ const folding = (show: ReadonlyArray<AssistantEvent.AppEventSchema>): Folding =>
 
     blocks = BlockKit.apply(blocks, event)
 
+    const decidedBefore = approvals
+    approvals = ToolApproval.apply(approvals, entry)
+
     const changed = [...new Set(touched(event, entry.at))].flatMap((id) => {
       const message = sent.get(id)
       const current = items.get(id)
@@ -705,14 +803,15 @@ const folding = (show: ReadonlyArray<AssistantEvent.AppEventSchema>): Folding =>
       return [next]
     })
 
+    const all = [...changed, ...approvalItems(event, decidedBefore)]
     const now = activityOf(activity)
 
-    return changed.length === 0 &&
-      failed === before.failed &&
-      deleted === before.deleted &&
-      sameActivity(before.activity, now)
+    return all.length === 0 &&
+      failed === previous.failed &&
+      deleted === previous.deleted &&
+      sameActivity(previous.activity, now)
       ? undefined
-      : { seq, items: changed, activity: now, failed, deleted }
+      : { seq, items: all, activity: now, failed, deleted }
   }
 
   return {
@@ -728,7 +827,7 @@ const merge = (changes: ReadonlyArray<AnyChange>): AnyChange | undefined => {
 
   if (last === undefined) return undefined
 
-  const items = new Map<string, UserMessage | AssistantMessage | AnyEventItem>()
+  const items = new Map<string, AnyItem>()
 
   for (const change of changes) for (const item of change.items) items.set(item.id, item)