effect-assistant 0.1.0 → 0.2.0

package/src/ChatView.ts

@@ -2,7 +2,7 @@
  * This module provides the view of a chat as its user sees it. A chat client receives this view
  * and nothing else.
  *
- * A {@link View} holds the chat's messages with their blocks and decisions, the chat's
+ * A {@link View} holds the chat's messages with their blocks, 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, the app's own events, or why a
  * turn failed. The server streams {@link Update}s by piping the assistant's `subscribe` through
@@ -13,40 +13,14 @@
  */
 import { dual } from "effect/Function"
 import * as Match from "effect/Match"
-import * as Option from "effect/Option"
 import * as Schema from "effect/Schema"
 import * as Stream from "effect/Stream"
 import * as AssistantActivity from "./AssistantActivity.ts"
 import * as AssistantEvent from "./AssistantEvent.ts"
 import * as BlockKit from "./BlockKit.ts"
-import * as Decisions from "./Decision.ts"
-import { DecisionId } from "./DecisionId.ts"
 import { InputId } from "./InputId.ts"
 import { toJson } from "./internal/schema.ts"
 
-/**
- * Schema for a decision as the user sees it on a decision block. It holds the call the decision is
- * for (its tool and params, which the app can display as it likes) and, once the user has
- * decided, the outcome.
- *
- * @category schemas
- * @since 0.1.0
- */
-export const PendingDecision = Schema.Struct({
-  id: DecisionId,
-  tool: Schema.String,
-  params: Schema.Json,
-  outcome: Schema.optional(AssistantEvent.DecisionOutcome)
-})
-
-/**
- * Represents a decision as the user sees it.
- *
- * @category models
- * @since 0.1.0
- */
-export type PendingDecision = typeof PendingDecision.Type
-
 /**
  * Schema for the status of a block. A block is `"open"` while it accepts an answer, `"answered"`
  * once the user has used it, and `"closed"` when it closed without an answer because the user
@@ -67,8 +41,8 @@ export type BlockStatus = typeof BlockStatus.Type
 
 /**
  * Schema for a block on an assistant's message. It holds the block's kind, its props (JSON, as
- * the block's props schema encodes them), its status, the user's answer (JSON, as the block's
- * answer schema encodes it), and, for a decision block, its decisions.
+ * the block's props schema encodes them), its status, and the user's answer (JSON, as the block's
+ * answer schema encodes it).
  *
  * @category schemas
  * @since 0.1.0
@@ -77,8 +51,7 @@ export const Block = Schema.Struct({
   kind: Schema.String,
   props: Schema.Json,
   status: BlockStatus,
-  answer: Schema.optional(Schema.Json),
-  decisions: Schema.optional(Schema.Array(PendingDecision))
+  answer: Schema.optional(Schema.Json)
 })
 
 /**
@@ -173,7 +146,7 @@ export type SpecialistWorking = typeof SpecialistWorking.Type
  *
  * `working` is true while the assistant runs a turn, or when a turn is about to start for
  * something that arrived. `specialists` lists the specialists that are working. When the chat is
- * idle, nothing is working, even if a workflow is waiting on a timer or a decision.
+ * idle, nothing is working, even if a workflow is waiting on a timer or on the user.
  *
  * @category schemas
  * @since 0.1.0
@@ -220,8 +193,8 @@ export type View = typeof View.Type
 /**
  * Schema for a change to a chat's view.
  *
- * An update holds each message that is new or changed (for example, a block answered or closed,
- * or a decision made), in full. It also holds the current activity, whether the last turn failed,
+ * An update holds each message that is new or changed (for example, a block answered or
+ * closed), 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 update is up
  * to.
  *
@@ -349,10 +322,6 @@ interface Folding {
   readonly view: View
 }
 
-const decodeProps = Schema.decodeUnknownOption(Decisions.Props)
-
-const decodeAnswer = Schema.decodeUnknownOption(Decisions.Answer)
-
 const activityOf = (activity: AssistantActivity.State): Activity => ({
   working: activity.turnSince !== undefined || activity.queued,
   specialists: [...activity.specialists.values()].map((run) => ({
@@ -370,49 +339,24 @@ const sameActivity = (a: Activity, b: Activity) =>
     return other !== undefined && run.specialist === other.specialist && run.since === other.since
   })
 
-const decisionIds = (block: AssistantEvent.MessageBlock): ReadonlyArray<string> =>
-  block.kind === Decisions.kind
-    ? Option.match(decodeProps(block.props), {
-        onNone: () => [],
-        onSome: (props) => props.decisionIds
-      })
-    : []
-
 const folding = (wakes: ReadonlySet<string>): Folding => {
   let seq = 0
   let failed = false
   let deleted = false
   let activity = AssistantActivity.empty
   let blocks: ReadonlyMap<string, BlockKit.State> = new Map()
-  let decisions: ReadonlyMap<string, Decisions.State> = new Map()
   // The messages in order, and the assistant's as stored: their blocks change as the chat goes on.
   const messages = new Map<string, Message>()
   const sent = new Map<string, AssistantEvent.AssistantMessage>()
-  // Which messages ask for a decision, so a decision's outcome updates the block that asked for it.
-  const asking = new Map<string, Array<string>>()
 
   const blockOf = (message: AssistantEvent.AssistantMessage): Block | undefined => {
     if (message.block === undefined) return undefined
 
     const state = blocks.get(message.id)
     const status = state === undefined || state.open ? "open" : state.answer === undefined ? "closed" : "answered"
-    const ids = decisionIds(message.block)
-
-    const shown = ids.flatMap((id) => {
-      const decision = decisions.get(id)
-
-      if (decision === undefined) return []
-
-      const { tool, params } = decision.request.origin
-      const shown = { id: decision.request.id, tool, params }
-
-      return [decision.outcome === undefined ? shown : { ...shown, outcome: decision.outcome }]
-    })
-
     const block: Block = { kind: message.block.kind, props: toJson(message.block.props), status }
-    const answered = state?.answer === undefined ? block : { ...block, answer: toJson(state.answer.value) }
 
-    return message.block.kind === Decisions.kind ? { ...answered, decisions: shown } : answered
+    return state?.answer === undefined ? block : { ...block, answer: toJson(state.answer.value) }
   }
 
   const viewOf = (message: AssistantEvent.AssistantMessage, at: number): AssistantMessage => {
@@ -447,27 +391,14 @@ const folding = (wakes: ReadonlySet<string>): Folding => {
           messages.set(message.id, viewOf(message, at))
           failed = false
 
-          if (message.block !== undefined) {
-            for (const id of decisionIds(message.block)) asking.set(id, [...(asking.get(id) ?? []), message.id])
-          }
-
           return [message.id, ...(message.closes ?? [])]
         },
         BlockAnswer: (answer) => {
           failed = false
 
-          const decided =
-            answer.kind === Decisions.kind
-              ? Option.match(decodeAnswer(answer.value), {
-                  onNone: () => [],
-                  onSome: ({ decisions }) => Object.keys(decisions).flatMap((id) => asking.get(id) ?? [])
-                })
-              : []
-
-          return [answer.messageId, ...decided]
+          return [answer.messageId]
         },
         BlocksClosed: (closed) => closed.messageIds,
-        DecisionResolved: (resolved) => asking.get(resolved.id) ?? [],
         TurnFailed: () => {
           failed = true
 
@@ -480,7 +411,6 @@ const folding = (wakes: ReadonlySet<string>): Folding => {
         TurnCompleted: () => [],
         SpecialistStarted: () => [],
         SpecialistFinished: () => [],
-        DecisionRequested: () => [],
         ChatDeleted: () => {
           deleted = true
 
@@ -503,7 +433,6 @@ const folding = (wakes: ReadonlySet<string>): Folding => {
     }
 
     blocks = BlockKit.apply(blocks, event)
-    decisions = Decisions.apply(decisions, event)
 
     const changed = [...new Set(touched(event, entry.at))].flatMap((id) => {
       const message = sent.get(id)
@@ -588,7 +517,7 @@ const wakesOf = (definition: Definition): ReadonlySet<string> =>
  *
  * The entries must stream from the start of the chat's log, as `assistant.subscribe(chatId)` does
  * without `after`. The fold reads every entry, because a message's view depends on earlier
- * entries: a block is answered or closed later, and a decision is made later. `after` only skips
+ * entries: a block is answered or closed later. `after` only skips
  * emitting the updates up to that `seq`, so a client that has the view up to a `seq` receives only
  * what changed since. Pass `after` here, not to `subscribe`: a subscription that starts after a
  * `seq` gives the fold an incomplete log, and the updates it produces are wrong.

package/src/Compaction.ts

@@ -17,9 +17,7 @@ import type * as Assistant from "./Assistant.ts"
 import * as AssistantActivity from "./AssistantActivity.ts"
 import * as AssistantEvent from "./AssistantEvent.ts"
 import * as BlockKit from "./BlockKit.ts"
-import * as Decision from "./Decision.ts"
 import { userText } from "./internal/history.ts"
-import { toJsonText } from "./internal/schema.ts"
 
 /**
  * Represents the fields a summary event must have: its text and the last `seq` it covers.
@@ -55,8 +53,8 @@ export const inputTokens = (entries: ReadonlyArray<AssistantEvent.AnyEntry>): nu
 }
 
 /**
- * Returns the items that were open at `throughSeq` and are still open: decisions waiting for the
- * user, blocks the user hasn't answered, and specialists that are working. The result is text for
+ * 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
  * the model, or `None` when nothing is open.
  *
  * @category utils
@@ -71,20 +69,6 @@ export const openItems = (
 
   const opened = (seq: number) => seq <= throughSeq
 
-  const decisions = [...Decision.fromEntries(entries).values()].flatMap((state) =>
-    state.outcome === undefined &&
-    opened(
-      seqOf(
-        (event) =>
-          AssistantEvent.isLibraryEvent(event) &&
-          Predicate.isTagged(event, "DecisionRequested") &&
-          event.id === state.request.id
-      )
-    )
-      ? [`- decision ${state.request.id}, for ${state.request.origin.tool}: ${toJsonText(state.request.origin.params)}`]
-      : []
-  )
-
   const blocks = [...BlockKit.fromEntries(entries)].flatMap(([messageId, state]) => {
     const shown = entries.find(
       ({ event }) =>
@@ -117,7 +101,6 @@ export const openItems = (
   )
 
   const sections = [
-    decisions.length > 0 ? `Decisions waiting for the user:\n${decisions.join("\n")}` : "",
     blocks.length > 0 ? `Blocks the user hasn't answered:\n${blocks.join("\n")}` : "",
     specialists.length > 0 ? `Specialists still working:\n${specialists.join("\n")}` : ""
   ].filter((section) => section.length > 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

@@ -79,16 +79,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
  */

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"
@@ -113,8 +110,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 +174,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 +187,24 @@ 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 (Predicate.isTagged(verdict, "Refuse")) {
-          yield* Effect.logWarning(`assistant chat refused ${input._tag}: ${verdict.reason}`)
-
-          return Option.none()
-        }
+        if (id !== undefined && (yield* Ref.get(entries)).some(({ event }) => idOf(event) === id)) return
 
         yield* write([input])
-
-        return Option.some(verdict)
       })
     )
-
-    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))
@@ -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)
   )
 

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,61 +107,9 @@ 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>`
-
 // In the order the model saw the entries, not the order they were stored.
 /** @internal */
 export const fromEntries = (
@@ -172,9 +119,6 @@ export const fromEntries = (
   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 = () => {
@@ -209,11 +153,7 @@ export const fromEntries = (
       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))
-          ),
+        BlockAnswer: (answer) => input(index, userText(answerText(answer))),
         ModelOutput: (output) => {
           history.push(...Prompt.fromResponseParts(output.parts).content)
 
@@ -227,26 +167,14 @@ 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.
+          // call right before it.
           if (!called.has(result.callId)) return input(index, 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,