effect-assistant 0.2.0 → 0.3.0

package/src/index.ts

@@ -4,11 +4,6 @@
  * @since 0.1.0
  */
 
-/**
- * @since 0.1.0
- */
-export * as AppEvent from "./AppEvent.ts"
-
 /**
  * @since 0.1.0
  */
@@ -64,11 +59,6 @@ export * as ChatLog from "./ChatLog.ts"
  */
 export * as Chats from "./Chats.ts"
 
-/**
- * @since 0.1.0
- */
-export * as ChatView from "./ChatView.ts"
-
 /**
  * @since 0.1.0
  */
@@ -109,6 +99,11 @@ export * as Skill from "./Skill.ts"
  */
 export * as Specialist from "./Specialist.ts"
 
+/**
+ * @since 0.3.0
+ */
+export * as Timeline from "./Timeline.ts"
+
 /**
  * @since 0.1.0
  */

package/src/internal/chat.ts

@@ -101,7 +101,6 @@ export const make = Effect.fnUntraced(function* (options: {
 }) {
   const { registration, chatId } = options
   const { app } = registration.definition
-  const { wakes } = app
   const storage = yield* ChatLog
   const chats = yield* Chats.Chats
   const initial = yield* storage.read(chatId)
@@ -201,7 +200,8 @@ export const make = Effect.fnUntraced(function* (options: {
 
         if (id !== undefined && (yield* Ref.get(entries)).some(({ event }) => idOf(event) === id)) return
 
-        yield* write([input])
+        // Stored as an input: it came in from outside a turn, so it wakes one, also after a restart.
+        yield* write([AssistantEvent.isLibraryEvent(input) ? input : AppEvents.markInput(input)])
       })
     )
   })
@@ -232,7 +232,7 @@ export const make = Effect.fnUntraced(function* (options: {
 
   const drain: Effect.Effect<void> = Semaphore.withPermit(turnsLock)(
     Effect.gen(function* () {
-      while (!(yield* isDeleted) && History.needsTurn(yield* chat.entries, wakes)) {
+      while (!(yield* isDeleted) && History.needsTurn(yield* chat.entries)) {
         yield* Turns.run({ registration, handler, chat, services, checkOpen: Effect.asVoid(checkAvailable) })
       }
     })
@@ -296,7 +296,7 @@ export const make = Effect.fnUntraced(function* (options: {
       yield* inBackground(drain)
     }),
     resume: Effect.gen(function* () {
-      if (History.needsTurn(yield* chat.entries, wakes)) yield* inBackground(drain)
+      if (History.needsTurn(yield* chat.entries)) yield* inBackground(drain)
     }),
     stream: (after) =>
       Stream.unwrap(

package/src/internal/events.ts

@@ -1,27 +1,30 @@
 import * as Effect from "effect/Effect"
 import * as Option from "effect/Option"
+import * as Predicate from "effect/Predicate"
+import * as Record from "effect/Record"
 import * as Schema from "effect/Schema"
-import type * as AppEvent from "../AppEvent.ts"
+import * as SchemaAST from "effect/SchemaAST"
 import type * as Assistant from "../Assistant.ts"
 import * as AssistantEvent from "../AssistantEvent.ts"
-import { toJsonText } from "./schema.ts"
+import { inputKey } from "./input.ts"
 
 /** @internal */
 export interface AppEvents {
-  readonly byTag: ReadonlyMap<string, Registered>
-  readonly wakes: ReadonlySet<string>
+  readonly byTag: ReadonlyMap<string, AssistantEvent.AppEventSchema>
 }
 
-interface Registered {
-  readonly schema: AppEvent.EventSchema
-  readonly render: AppEvent.Render<{ readonly _tag: string }> | undefined
+/** @internal */
+export const tagOf = (schema: AssistantEvent.AppEventSchema): string => {
+  const ast = schema.fields._tag.ast
+
+  if (SchemaAST.isLiteral(ast) && Predicate.isString(ast.literal)) return ast.literal
+
+  throw new Error("An app event is a tagged struct or class.")
 }
 
 /** @internal */
-export const make = (events: ReadonlyArray<AppEvent.Any>): AppEvents => {
-  const byTag = new Map(
-    events.map((event): [string, Registered] => [event.tag, { schema: event.schema, render: event.render }])
-  )
+export const make = (events: ReadonlyArray<AssistantEvent.AppEventSchema>): AppEvents => {
+  const byTag = new Map(events.map((schema): [string, AssistantEvent.AppEventSchema] => [tagOf(schema), schema]))
 
   for (const tag of byTag.keys()) {
     if (AssistantEvent.isLibraryEvent({ _tag: tag })) throw new Error(`${tag} is one of the library's events.`)
@@ -29,17 +32,17 @@ export const make = (events: ReadonlyArray<AppEvent.Any>): AppEvents => {
 
   if (byTag.size !== events.length) throw new Error("An assistant's events have different tags.")
 
-  return { byTag, wakes: new Set(events.flatMap((event) => (event.wakes ? [event.tag] : []))) }
+  return { byTag }
 }
 
 /** @internal */
 export const encode = Effect.fnUntraced(function* (app: AppEvents, event: { readonly _tag: string }) {
-  const registered = app.byTag.get(event._tag)
+  const schema = app.byTag.get(event._tag)
 
   // The types only let registered events through, so one with no schema here is a defect.
-  if (registered === undefined) return yield* Effect.die(`${event._tag} isn't one of this assistant's events.`)
+  if (schema === undefined) return yield* Effect.die(`${event._tag} isn't one of this assistant's events.`)
 
-  const json = yield* Schema.encodeUnknownEffect(Schema.toCodecJson(registered.schema))(event)
+  const json = yield* Schema.encodeUnknownEffect(Schema.toCodecJson(schema))(event)
 
   return yield* Schema.decodeUnknownEffect(AssistantEvent.StoredAppEvent)(json)
 }, Effect.orDie)
@@ -47,6 +50,30 @@ export const encode = Effect.fnUntraced(function* (app: AppEvents, event: { read
 /** @internal */
 export const isRegistered = (app: AppEvents, event: { readonly _tag: string }): boolean => app.byTag.has(event._tag)
 
+// The app's schema decodes the event as the app wrote it.
+const unmarked = (event: { readonly _tag: string }) =>
+  Predicate.hasProperty(event, inputKey) ? Record.remove(event, inputKey) : event
+
+// An event as the log stores it, decoded with its schema.
+/** @internal */
+export const decodeWith = (
+  schema: AssistantEvent.AppEventSchema,
+  event: { readonly _tag: string }
+): Option.Option<{ readonly _tag: string }> => Schema.decodeUnknownOption(Schema.toCodecJson(schema))(unmarked(event))
+
+const decodeEvent = (app: AppEvents, event: { readonly _tag: string }): Option.Option<{ readonly _tag: string }> => {
+  const schema = app.byTag.get(event._tag)
+
+  return schema === undefined ? Option.none() : decodeWith(schema, event)
+}
+
+// What came in through `submit`, from outside a turn, is an input: it wakes a turn.
+/** @internal */
+export const markInput = (event: AssistantEvent.StoredAppEvent): AssistantEvent.StoredAppEvent => ({
+  ...event,
+  [inputKey]: true
+})
+
 // An app event that doesn't decode (say, one from an older version of its schema) is left out.
 /** @internal */
 export const decodeEntry = (app: AppEvents, entry: AssistantEvent.AnyEntry): Option.Option<Assistant.Entry<any>> => {
@@ -54,14 +81,7 @@ export const decodeEntry = (app: AppEvents, entry: AssistantEvent.AnyEntry): Opt
 
   if (AssistantEvent.isLibraryEvent(event)) return Option.some({ ...toEntry(entry), event })
 
-  const registered = app.byTag.get(event._tag)
-
-  if (registered === undefined) return Option.none()
-
-  return Option.map(Schema.decodeUnknownOption(Schema.toCodecJson(registered.schema))(event), (decoded) => ({
-    ...toEntry(entry),
-    event: decoded
-  }))
+  return Option.map(decodeEvent(app, event), (decoded) => ({ ...toEntry(entry), event: decoded }))
 }
 
 /** @internal */
@@ -73,28 +93,8 @@ export const decodeEntries = (
 /** @internal */
 export type DecodedEntries = ReturnType<typeof decodeEntries>
 
-const decodeStored = Schema.decodeUnknownOption(AssistantEvent.StoredAppEvent)
-
 const toEntry = (entry: AssistantEvent.AnyEntry) => ({
   chatId: entry.chatId,
   seq: entry.seq,
   at: entry.at
 })
-
-/** @internal */
-export const read = (app: AppEvents, event: { readonly _tag: string }): string | undefined => {
-  const registered = app.byTag.get(event._tag)
-
-  if (registered?.render === undefined) return undefined
-
-  if (registered.render !== "json") return registered.render(event)
-
-  const stored = Schema.encodeUnknownOption(Schema.toCodecJson(registered.schema))(event).pipe(
-    Option.flatMap(decodeStored)
-  )
-
-  return Option.match(stored, {
-    onNone: () => undefined,
-    onSome: ({ _tag, ...fields }) => `<${_tag}>\n${toJsonText(fields)}\n</${_tag}>`
-  })
-}

package/src/internal/history.ts

@@ -110,12 +110,17 @@ const answerText = (answer: AssistantEvent.BlockAnswer) =>
 const resultText = (result: AssistantEvent.ToolResult) =>
   `<result tool="${result.tool}" call="${result.callId}" outcome="${result.outcome}">\nThe result of a call from earlier in this chat.\n${toJsonText(result.result)}\n</result>`
 
-// In the order the model saw the entries, not the order they were stored.
+const isEntry = (item: AssistantEvent.AnyEntry | Prompt.Message): item is AssistantEvent.AnyEntry =>
+  Predicate.hasProperty(item, "seq")
+
+// In the order the model saw the entries, not the order they were stored. A message a history view put in stands
+// where it is, right after the entry before it, and waits like an input for a call's result or for the model's next
+// read; the app's own events reach the model only as such messages.
 /** @internal */
 export const fromEntries = (
-  entries: ReadonlyArray<AssistantEvent.AnyEntry>,
-  readApp: (event: { readonly _tag: string }) => string | undefined
+  items: ReadonlyArray<AssistantEvent.AnyEntry | Prompt.Message>
 ): ReadonlyArray<Prompt.Message> => {
+  const entries = items.filter(isEntry)
   const history: Array<Prompt.Message> = []
   const held: Array<Prompt.Message> = []
   const open = new Set<string>()
@@ -133,27 +138,35 @@ export const fromEntries = (
       : undefined
   }
 
-  const input = (index: number, item: Prompt.Message) => {
+  // `index` is the last entry at or before the item, and `seq` where the item stands.
+  const input = (index: number, seq: number, item: Prompt.Message) => {
     const seen = nextSeen(index)
 
-    if (open.size > 0 || (seen !== undefined && seen < entries[index]!.seq)) held.push(item)
+    if (open.size > 0 || (seen !== undefined && seen < seq)) held.push(item)
     else history.push(item)
   }
 
-  entries.forEach(({ event }, index) => {
-    if (!AssistantEvent.isLibraryEvent(event)) {
-      const text = readApp(event)
+  let index = -1
 
-      if (text !== undefined) input(index, userText(text))
+  for (const item of items) {
+    if (!isEntry(item)) {
+      input(index, (entries[index]?.seq ?? 0) + 0.5, item)
 
-      return
+      continue
     }
 
+    index += 1
+
+    const { event, seq } = item
+    const at = index
+
+    if (!AssistantEvent.isLibraryEvent(event)) continue
+
     Match.value(event).pipe(
       Match.tagsExhaustive({
         UserMessage: (message) =>
-          input(index, userText(AssistantEvent.textWithAttachments(message.text, message.attachments))),
-        BlockAnswer: (answer) => input(index, userText(answerText(answer))),
+          input(at, seq, userText(AssistantEvent.textWithAttachments(message.text, message.attachments))),
+        BlockAnswer: (answer) => input(at, seq, userText(answerText(answer))),
         ModelOutput: (output) => {
           history.push(...Prompt.fromResponseParts(output.parts).content)
 
@@ -169,7 +182,7 @@ export const fromEntries = (
         ToolResult: (result) => {
           // A view that starts after the call (since a summary, say) keeps its result as text: a tool result needs its
           // call right before it.
-          if (!called.has(result.callId)) return input(index, userText(resultText(result)))
+          if (!called.has(result.callId)) return input(at, seq, userText(resultText(result)))
 
           history.push(toolMessage(result))
           open.delete(result.callId)
@@ -180,21 +193,21 @@ export const fromEntries = (
         TurnStarted: () => undefined,
         TurnCompleted: () => undefined,
         TurnFailed: () => undefined,
-        SpecialistFinished: (finished) => input(index, userText(finishedText(entries, index, finished))),
+        SpecialistFinished: (finished) => input(at, seq, userText(finishedText(entries, at, finished))),
         // Every run starts in a call of the model's own (a spawn or a follow-up), whose result says so.
         SpecialistStarted: () => undefined,
         BlocksClosed: () => undefined,
         ChatDeleted: () => undefined
       })
     )
-  })
+  }
 
   return [...history, ...held]
 }
 
 /** @internal */
-export const isInput = (event: { readonly _tag: string }, wakes: ReadonlySet<string>): boolean =>
-  AssistantEvent.isInput(event) || (!AssistantEvent.isLibraryEvent(event) && wakes.has(event._tag))
+export const isInput = (event: { readonly _tag: string }): boolean =>
+  AssistantEvent.isInput(event) || AssistantEvent.isAppInput(event)
 
 /** @internal */
 export const handledThrough = (entries: ReadonlyArray<AssistantEvent.AnyEntry>): number => {
@@ -206,21 +219,18 @@ export const handledThrough = (entries: ReadonlyArray<AssistantEvent.AnyEntry>):
 // A run the assistant stopped isn't an input here: it wakes nothing.
 /** @internal */
 export const unhandledInputs = (
-  entries: ReadonlyArray<AssistantEvent.AnyEntry>,
-  wakes: ReadonlySet<string>
+  entries: ReadonlyArray<AssistantEvent.AnyEntry>
 ): ReadonlyArray<{ readonly _tag: string }> => {
   const seen = handledThrough(entries)
 
   return entries.flatMap(({ event, seq }) =>
-    seq > seen && isInput(event, wakes) && !(AssistantEvent.isInput(event) && !AssistantEvent.isWaking(event))
-      ? [event]
-      : []
+    seq > seen && isInput(event) && !(AssistantEvent.isInput(event) && !AssistantEvent.isWaking(event)) ? [event] : []
   )
 }
 
 /** @internal */
-export const needsTurn = (entries: ReadonlyArray<AssistantEvent.AnyEntry>, wakes: ReadonlySet<string>): boolean =>
-  unhandledInputs(entries, wakes).length > 0
+export const needsTurn = (entries: ReadonlyArray<AssistantEvent.AnyEntry>): boolean =>
+  unhandledInputs(entries).length > 0
 
 // A failure the user was shown counts as a reply.
 /** @internal */
@@ -287,8 +297,5 @@ export const owesDelivery = (entries: ReadonlyArray<AssistantEvent.AnyEntry>, th
 }
 
 /** @internal */
-export const unreadAfter = (
-  entries: ReadonlyArray<AssistantEvent.AnyEntry>,
-  throughSeq: number,
-  wakes: ReadonlySet<string>
-): boolean => entries.some(({ event, seq }) => seq > throughSeq && isInput(event, wakes))
+export const unreadAfter = (entries: ReadonlyArray<AssistantEvent.AnyEntry>, throughSeq: number): boolean =>
+  entries.some(({ event, seq }) => seq > throughSeq && isInput(event))

package/src/internal/input.ts

@@ -0,0 +1,3 @@
+// Marks a stored app event that came in through the assistant's `submit`: an input, which wakes a turn.
+/** @internal */
+export const inputKey = "~effect-assistant/input"

package/src/internal/skills.ts

@@ -8,6 +8,17 @@ import type { Skill } from "../Skill.ts"
 import * as ToolFailure from "../ToolFailure.ts"
 import * as Toolkits from "./toolkit.ts"
 
+// A skill whose tools the loop doesn't have would send the model after calls it can't make.
+/** @internal */
+export const available = <R>(
+  skills: ReadonlyArray<Skill<R>>,
+  definitions: ReadonlyArray<Tool.Any>
+): ReadonlyArray<Skill<R>> => {
+  const names = new Set(definitions.map((tool) => tool.name))
+
+  return skills.filter((skill) => (skill.tools ?? []).every((tool) => names.has(tool.name)))
+}
+
 /** @internal */
 export const toTools = <R>(skills: ReadonlyArray<Skill<R>>): Toolkits.Tools<R> => {
   if (skills.length === 0) return Toolkits.empty

package/src/internal/specialists.ts

@@ -84,11 +84,12 @@ export const runBrief = Effect.fnUntraced(
       brief: options.brief,
       history: current,
       loop: (loop) => {
-        const skills = loop.skills ?? []
+        const own = Toolkits.fromToolkitOrEmpty(loop.toolkit)
+        const skills = Skills.available(loop.skills ?? [], own.definitions)
 
         return Loop.run({
           instructions: mapText(loop.instructions, (text) => Skill.withCatalog(text, skills)),
-          toolkit: Toolkits.merge(Skills.toTools(skills), Toolkits.fromToolkitOrEmpty(loop.toolkit)),
+          toolkit: Toolkits.merge(Skills.toTools(skills), own),
           history: current,
           maxSteps: loop.maxSteps ?? 8
         })

package/src/internal/turns.ts

@@ -1,6 +1,5 @@
 import type * as LanguageModel from "effect/ai/LanguageModel"
 import type * as Tool from "effect/ai/Tool"
-import type * as Prompt from "effect/ai/Prompt"
 import * as Cause from "effect/Cause"
 import * as Context from "effect/Context"
 import * as Effect from "effect/Effect"
@@ -8,6 +7,7 @@ import * as Exit from "effect/Exit"
 import { identity } from "effect/Function"
 import * as Option from "effect/Option"
 import * as Predicate from "effect/Predicate"
+import * as Ref from "effect/Ref"
 import * as Schema from "effect/Schema"
 import type * as Scope from "effect/Scope"
 import * as Stream from "effect/Stream"
@@ -127,34 +127,6 @@ const failureMessage = (cause: Cause.Cause<unknown>): string =>
 
 const lastSeq = (entries: ReadonlyArray<AssistantEvent.AnyEntry>, otherwise: number) => entries.at(-1)?.seq ?? otherwise
 
-const toHistory = (
-  viewed: ReadonlyArray<Assistant.Entry<any> | Prompt.Message>,
-  app: AppEvents.AppEvents
-): ReadonlyArray<Prompt.Message> => {
-  const out: Array<Prompt.Message> = []
-  let run: Array<AssistantEvent.AnyEntry> = []
-
-  const flush = () => {
-    out.push(...History.fromEntries(run, (event) => AppEvents.read(app, event)))
-    run = []
-  }
-
-  for (const item of viewed) {
-    if (isEntry(item)) run.push(item)
-    else {
-      flush()
-      out.push(item)
-    }
-  }
-
-  flush()
-
-  return out
-}
-
-const isEntry = (item: Assistant.Entry<any> | Prompt.Message): item is Assistant.Entry<any> =>
-  Predicate.hasProperty(item, "seq")
-
 // The handler's stream can end between a step's output and its tools, or while they run. An interrupted turn (a
 // shutdown) leaves its calls open instead: the next turn runs them again.
 const closeOpenCalls = Effect.fnUntraced(function* (chat: Writer, startSeq: number) {
@@ -164,7 +136,7 @@ const closeOpenCalls = Effect.fnUntraced(function* (chat: Writer, startSeq: numb
     entries.flatMap(({ event }) => (Predicate.isTagged(event, "ToolStarted") ? [event.callId] : []))
   )
 
-  const open = History.unansweredCalls(History.fromEntries(entries, () => undefined))
+  const open = History.unansweredCalls(History.fromEntries(entries))
 
   if (open.length === 0) return
 
@@ -196,13 +168,13 @@ const handledThrough = (entries: ReadonlyArray<AssistantEvent.AnyEntry>, startSe
     startSeq
   )
 
-// Fails visibly when the user's latest input got no reply; an input that arrived after what its model read gets the
-// next turn, which replies.
-const finishTurn = Effect.fnUntraced(function* (chat: Writer, read: number, wakes: ReadonlySet<string>) {
+// A turn that ran the loop fails visibly when the user's latest input got no reply; an input that arrived after what
+// its model read gets the next turn, which replies. A handler that ended without the loop decided that itself.
+const finishTurn = Effect.fnUntraced(function* (chat: Writer, read: number, ranLoop: boolean) {
   const entries = yield* chat.entries
 
   const end =
-    History.owesReply(entries, read) && !History.unreadAfter(entries, read, wakes)
+    ranLoop && History.owesReply(entries, read) && !History.unreadAfter(entries, read)
       ? AssistantEvent.TurnFailed.make({ throughSeq: read, message: silentTurnMessage })
       : AssistantEvent.TurnCompleted.make({ throughSeq: read })
 
@@ -222,11 +194,15 @@ const makeTurnApi = (
   registration: Registration,
   chat: Writer,
   startSeq: number,
-  checkOpen: Effect.Effect<void>
+  checkOpen: Effect.Effect<void>,
+  ranLoop: Ref.Ref<boolean>
 ): Assistant.Turn<any> => {
   const { definition, builtins } = registration
   const { app } = definition
 
+  const running = <A, E, R>(stream: Stream.Stream<A, E, R>) =>
+    Stream.unwrap(Ref.set(ranLoop, true).pipe(Effect.as(stream)))
+
   // With how far into the chat it goes: the step records it on the model's output.
   // Read before every model call: a chat the app deleted meanwhile stops here.
   const history = Effect.fnUntraced(function* (view: Assistant.HistoryView<any> = identity) {
@@ -235,7 +211,7 @@ const makeTurnApi = (
     const all = yield* chat.entries
 
     const read: AssistantLoop.ChatHistory = {
-      messages: toHistory(view(AppEvents.decodeEntries(app, all)), app),
+      messages: History.fromEntries(view(AppEvents.decodeEntries(app, all))),
       throughSeq: lastSeq(all, startSeq)
     }
 
@@ -258,7 +234,7 @@ const makeTurnApi = (
         const through = handledThrough(all, startSeq)
 
         // Something arrived after what the loop's model read: the next turn reads it with the full loop, and replies.
-        if (History.unreadAfter(all, through, app.wakes)) return Stream.empty
+        if (History.unreadAfter(all, through)) return Stream.empty
 
         const owed = History.owesReply(all, through)
         const undelivered = !owed && History.owesDelivery(all, through)
@@ -282,7 +258,7 @@ const makeTurnApi = (
 
             return {
               messages: [
-                ...toHistory(options.view(AppEvents.decodeEntries(app, entries)), app),
+                ...History.fromEntries(options.view(AppEvents.decodeEntries(app, entries))),
                 History.userText(nudge)
               ],
               throughSeq: lastSeq(entries, startSeq)
@@ -295,22 +271,22 @@ const makeTurnApi = (
     )
 
   const replyIfOwed = (options: Assistant.ReplyOptions) =>
-    replyPass({
-      instructions: instructions(options.instructions),
-      toolkit: builtins,
-      view: identity,
-      nudge: options.nudge
-    })
+    running(
+      replyPass({
+        instructions: instructions(options.instructions),
+        toolkit: builtins,
+        view: identity,
+        nudge: options.nudge
+      })
+    )
 
   const prepare = <T extends Record<string, Tool.Any>, RS>(options: Assistant.LoopOptions<T, RS, any>) => {
-    const skills = options.skills ?? []
+    const own = Toolkits.fromToolkitOrEmpty(options.toolkit)
+    const skills = Skills.available(options.skills ?? [], [...builtins.definitions, ...own.definitions])
 
     return {
       system: mapText(instructions(options.instructions), (text) => Skill.withCatalog(text, skills)),
-      toolkit: Toolkits.merge(
-        Toolkits.merge(builtins, Skills.toTools(skills)),
-        Toolkits.fromToolkitOrEmpty(options.toolkit)
-      ),
+      toolkit: Toolkits.merge(Toolkits.merge(builtins, Skills.toTools(skills)), own),
       view: options.history ?? identity
     }
   }
@@ -334,7 +310,7 @@ const makeTurnApi = (
               maxSteps: options.maxSteps ?? 16
             })
 
-      return Stream.concat(loop, replyPass({ instructions: system, toolkit, view, nudge: options.replyNudge }))
+      return running(Stream.concat(loop, replyPass({ instructions: system, toolkit, view, nudge: options.replyNudge })))
     }
   }
 }
@@ -353,7 +329,7 @@ export const run = Effect.fnUntraced(
     const { chat } = options
     const before = yield* chat.entries
 
-    yield* Telemetry.agentInput(History.unhandledInputs(before, options.registration.definition.app.wakes))
+    yield* Telemetry.agentInput(History.unhandledInputs(before))
 
     const assistant = options.registration.definition.name
     const traceId = yield* Telemetry.currentTraceId
@@ -368,7 +344,8 @@ export const run = Effect.fnUntraced(
     ])
 
     const startSeq = lastSeq(started, 0)
-    const turn = makeTurnApi(options.registration, chat, startSeq, options.checkOpen)
+    const ranLoop = yield* Ref.make(false)
+    const turn = makeTurnApi(options.registration, chat, startSeq, options.checkOpen, ranLoop)
 
     const record = (event: AssistantLoop.Event) => chat.append([event])
 
@@ -385,7 +362,7 @@ export const run = Effect.fnUntraced(
         onSuccess: Effect.fnUntraced(function* () {
           const all = yield* chat.entries
 
-          yield* finishTurn(chat, handledThrough(all, startSeq), options.registration.definition.app.wakes)
+          yield* finishTurn(chat, handledThrough(all, startSeq), yield* Ref.get(ranLoop))
         }),
         onFailure: (cause) => failTurn(chat, cause)
       })