effect-assistant 0.1.0 → 0.3.0

package/src/ToolDiscovery.ts

@@ -94,8 +94,8 @@ const requiring =
  * the tools' handlers. A catalog tool's services are `execute_tool`'s, so the turn provides them
  * as it does for any tool.
  *
- * `execute_tool` doesn't run a tool that needs the user's decision; keep such tools in the loop's
- * toolkit directly.
+ * A catalog tool with Effect's `needsApproval` set fails the layer when it is built, as it would
+ * fail a loop: the library doesn't run calls that wait for approval.
  *
  * **Example** (Finding rarely used tools when needed)
  *
@@ -146,6 +146,9 @@ export const layer = <T extends Record<string, Tool.Any>>(catalog: Toolkit.Toolk
     Effect.gen(function* () {
       const resolved = yield* catalog
       const definitions = Object.values(resolved.tools)
+      const needingApproval = Toolkits.needingApproval(definitions)
+
+      if (needingApproval.length > 0) return yield* Effect.die(Toolkits.needsApprovalMessage(needingApproval))
 
       return {
         search_tools: ({ query }) =>
@@ -167,17 +170,6 @@ export const layer = <T extends Record<string, Tool.Any>>(catalog: Toolkit.Toolk
             providerExecuted: false
           })
 
-          // A call that needs the user's decision parks only as a call the model made itself,
-          // where it can ask for it.
-          if (yield* Toolkits.needsDecision(resolved, call, [])) {
-            return yield* Effect.fail(
-              Toolkits.failed(
-                `${name} needs the user's decision, so it can't run through execute_tool.`,
-                "NeedsDecision"
-              ).result
-            )
-          }
-
           const { outcome, result } = yield* Toolkits.runNative(resolved, call)
 
           return outcome === "failure" ? yield* Effect.fail(result) : result

package/src/ToolFailure.ts

@@ -15,7 +15,7 @@ import * as Schema from "effect/Schema"
  *
  * It holds a message that says what went wrong and, optionally, a `reason` the model can tell
  * apart, such as `"NotFound"` or `"OverBudget"`. The library's own reasons are PascalCase, like
- * `"NeedsDecision"`.
+ * `"ToolNotFoundError"`.
  *
  * @category errors
  * @since 0.1.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
  */
@@ -79,16 +69,6 @@ export * as Compaction from "./Compaction.ts"
  */
 export * as CurrentChat from "./CurrentChat.ts"
 
-/**
- * @since 0.1.0
- */
-export * as Decision from "./Decision.ts"
-
-/**
- * @since 0.1.0
- */
-export * as DecisionId from "./DecisionId.ts"
-
 /**
  * @since 0.1.0
  */
@@ -119,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

@@ -5,7 +5,6 @@ import * as Effect from "effect/Effect"
 import * as Exit from "effect/Exit"
 import * as Fiber from "effect/Fiber"
 import * as FiberSet from "effect/FiberSet"
-import * as Option from "effect/Option"
 import * as Predicate from "effect/Predicate"
 import * as PubSub from "effect/PubSub"
 import * as Ref from "effect/Ref"
@@ -17,10 +16,8 @@ import * as AssistantEvent from "../AssistantEvent.ts"
 import type { ChatId } from "../ChatId.ts"
 import { ChatLog } from "../ChatLog.ts"
 import { CurrentChat } from "../CurrentChat.ts"
-import type { InputId } from "../InputId.ts"
 import * as Chats from "../Chats.ts"
 import * as SpecialistService from "../Specialist.ts"
-import * as Decisions from "./decisions.ts"
 import * as AppEvents from "./events.ts"
 import * as History from "./history.ts"
 import * as Specialists from "./specialists.ts"
@@ -104,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)
@@ -113,8 +109,6 @@ export const make = Effect.fnUntraced(function* (options: {
 
   const channel = yield* makeChannelPubSub
   const writes = yield* Semaphore.make(1)
-  // Inputs are stored one at a time with the decisions they make: an answer checks the decisions the last one made.
-  const storing = yield* Semaphore.make(1)
   const turnsLock = yield* Semaphore.make(1)
   const holding = yield* makeHolding(options.keepAlive)
   const deleted = yield* Deferred.make<undefined>()
@@ -179,13 +173,6 @@ export const make = Effect.fnUntraced(function* (options: {
     append: (...events) => Effect.asVoid(Effect.flatMap(Effect.forEach(events, toStored), chat.append))
   }
 
-  // An approved call runs at the turn's next step.
-  const resolve = Effect.fnUntraced(function* (decided: ReadonlyArray<Decisions.Decided>, answer: InputId) {
-    yield* chat.append(
-      decided.map(({ request, outcome }) => AssistantEvent.DecisionResolved.make({ id: request.id, outcome, answer }))
-    )
-  })
-
   // A chat the app deleted is deleted here too, which stops what works in it: a turn that checks stops there.
   const checkAvailable: Effect.Effect<boolean> = chats.get(chatId).pipe(
     Effect.as(true),
@@ -199,51 +186,25 @@ export const make = Effect.fnUntraced(function* (options: {
     )
   )
 
-  // Under `storing`: an answer's decisions are resolved before the next input is stored.
   const store = Effect.fnUntraced(function* (input: AssistantEvent.Input | AssistantEvent.StoredAppEvent) {
     if (yield* isDeleted) return yield* refused(input, "is deleted")
 
     if (!(yield* checkAvailable)) return yield* refused(input, "is unavailable")
 
     // Checked under the write lock: a retry that arrives while the first submit is storing is stored once.
-    const verdict = yield* Semaphore.withPermit(writes)(
+    yield* Semaphore.withPermit(writes)(
       Effect.gen(function* () {
-        if (yield* isDeleted) {
-          yield* refused(input, "is deleted")
+        if (yield* isDeleted) return yield* refused(input, "is deleted")
 
-          return Option.none()
-        }
-
-        const stored = yield* Ref.get(entries)
         const id = idOf(input)
 
-        if (id !== undefined && stored.some(({ event }) => idOf(event) === id)) return Option.none()
-
-        const verdict = Decisions.verdict(stored, input)
+        if (id !== undefined && (yield* Ref.get(entries)).some(({ event }) => idOf(event) === id)) return
 
-        if (Predicate.isTagged(verdict, "Refuse")) {
-          yield* Effect.logWarning(`assistant chat refused ${input._tag}: ${verdict.reason}`)
-
-          return Option.none()
-        }
-
-        yield* write([input])
-
-        return Option.some(verdict)
+        // 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)])
       })
     )
-
-    if (Option.isSome(verdict) && Predicate.isTagged(verdict.value, "Decide")) {
-      yield* resolve(verdict.value.decided, verdict.value.answer)
-    }
-  }, Semaphore.withPermit(storing))
-
-  // A restart between storing an answer and resolving it: resolve it now, before anything reads the chat.
-  yield* Effect.forEach(
-    Decisions.unresolved(yield* Ref.get(entries)),
-    (decided) => resolve([decided], decided.answer),
-    { discard: true }
-  )
+  })
 
   // The handlers' builds run in the chat's working scope: what they set up lives until the chat closes or is deleted.
   const handler = yield* inWorking(Effect.provideService(registration.open(handle), CurrentChat, handle))
@@ -271,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) })
       }
     })
@@ -293,16 +254,6 @@ export const make = Effect.fnUntraced(function* (options: {
 
   const services = Context.make(CurrentChat, handle).pipe(
     Context.add(SpecialistService.Runner, runner),
-    Context.add(
-      Decisions.TurnDecisions,
-      Option.some({
-        approved: Effect.gen(function* () {
-          const all = yield* chat.entries
-
-          return Decisions.approvedCalls(all)
-        })
-      })
-    ),
     Context.merge(registration.model)
   )
 
@@ -345,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

@@ -5,7 +5,6 @@ import * as Option from "effect/Option"
 import * as Predicate from "effect/Predicate"
 import * as Schema from "effect/Schema"
 import * as AssistantEvent from "../AssistantEvent.ts"
-import * as Decision from "../Decision.ts"
 import { toJson, toJsonText } from "./schema.ts"
 import * as Uuid from "./uuid.ts"
 
@@ -108,73 +107,23 @@ const finishedText = (
 const answerText = (answer: AssistantEvent.BlockAnswer) =>
   `<answer message="${answer.messageId}" kind="${answer.kind}">\nThe user answered with the block on your message ${answer.messageId}.\n${toJsonText(answer.value)}\n</answer>`
 
-/** @internal */
-export const parkedResult = (
-  request: AssistantEvent.DecisionRequested,
-  origin: AssistantEvent.CallOrigin
-): Prompt.ToolMessage =>
-  Prompt.toolMessage({
-    content: [
-      Prompt.toolResultPart({
-        id: origin.callId,
-        name: origin.tool,
-        isFailure: false,
-        result: {
-          status: "waiting_for_decision",
-          decisionId: request.id,
-          next: "Not run: it runs only if the user approves it. Send them a message with a decision block for this decisionId that says what they approve (the call's key facts). Their answer runs it, or declines it."
-        },
-        providerExecuted: false
-      })
-    ]
-  })
-
-const whatDecided = (request: AssistantEvent.DecisionRequested, outcome: AssistantEvent.DecisionOutcome) =>
-  outcome === "approved"
-    ? `approved: ${request.origin.tool} runs now, and its result follows.`
-    : `declined: ${request.origin.tool} didn't run, and won't.`
-
-const decodeDecisionAnswer = Schema.decodeUnknownOption(Decision.Answer)
-
-const decisionAnswerText = (
-  answer: AssistantEvent.BlockAnswer,
-  requests: ReadonlyMap<string, AssistantEvent.DecisionRequested>
-) =>
-  Option.match(decodeDecisionAnswer(answer.value), {
-    onNone: () => answerText(answer),
-    onSome: ({ decisions }) => {
-      const lines = Object.entries(decisions).map(([id, outcome]) => {
-        const request = requests.get(id)
-
-        return `- ${id}: ${request === undefined ? outcome : whatDecided(request, outcome)}`
-      })
-
-      return `<answer message="${answer.messageId}" kind="${answer.kind}">\nThe user decided with the block on your message ${answer.messageId}:\n${lines.join("\n")}\n</answer>`
-    }
-  })
-
 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>`
 
-const approvedResultText = (
-  request: AssistantEvent.DecisionRequested,
-  tool: string,
-  result: AssistantEvent.ToolResult
-) =>
-  `<decision id="${request.id}" tool="${tool}" outcome="approved">\nThe user approved it, and ${tool} ran: ${result.outcome}.\n${toJsonText(result.result)}\n</decision>`
+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.
+// 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>()
-  const requests = new Map<string, AssistantEvent.DecisionRequested>()
-  // Parked calls by call id: their result came with the parking, so a later one reads as the decision's.
-  const parked = new Map<string, AssistantEvent.DecisionRequested>()
   const called = new Set<string>()
 
   const flushIfClosed = () => {
@@ -189,31 +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(answer.kind === Decision.kind ? decisionAnswerText(answer, requests) : 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)
 
@@ -227,46 +180,34 @@ export const fromEntries = (
           flushIfClosed()
         },
         ToolResult: (result) => {
-          const request = parked.get(result.callId)
-
-          if (request !== undefined) return input(index, userText(approvedResultText(request, result.tool, 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. An approved call's result can come long after the call was parked.
-          if (!called.has(result.callId)) return input(index, userText(resultText(result)))
+          // call right before it.
+          if (!called.has(result.callId)) return input(at, seq, userText(resultText(result)))
 
           history.push(toolMessage(result))
           open.delete(result.callId)
           flushIfClosed()
         },
-        DecisionRequested: (request) => {
-          requests.set(request.id, request)
-          parked.set(request.origin.callId, request)
-          history.push(parkedResult(request, request.origin))
-          open.delete(request.origin.callId)
-          flushIfClosed()
-        },
-        DecisionResolved: () => undefined,
         AssistantMessage: () => undefined,
         ToolStarted: () => undefined,
         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 => {
@@ -278,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 */
@@ -359,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"