effect-assistant 0.3.0 → 0.5.0

package/dist/internal/turns.js

@@ -1,16 +1,16 @@
 import { ToolResult, TurnCompleted, TurnFailed, TurnStarted, isLibraryEvent } from "../AssistantEvent.js";
+import { fromEntries } from "../ToolApproval.js";
 import { decodeEntries } from "./events.js";
 import { toJsonText } from "./schema.js";
-import { fromEntries, mayHaveRunOutput, notRunOutput, owesDelivery, owesReply, unansweredCalls, unhandledInputs, unreadAfter, userText } from "./history.js";
+import { fromEntries as fromEntries$1, mayHaveRunOutput, notRunOutput, owesDelivery, owesReply, unansweredCalls, unhandledInputs, unreadAfter, userText } from "./history.js";
 import { agentInput, agentOutput, agentSpan, currentTraceId } from "./telemetry.js";
-import { duplicateNames, fromToolkitOrEmpty, merge, provide, runOnly } from "./toolkit.js";
+import { duplicateNames, fromToolkitOrEmpty, merge, provide, runOnly, showing } from "./toolkit.js";
 import { makeMessaging, sendUserMessageName, waitToolName } from "./tools.js";
-import { TurnTools, run as run$1 } from "./loop.js";
-import { withCatalog } from "../Skill.js";
+import { TurnApprovals, TurnTools, run as run$1 } from "./loop.js";
+import { toolkit } from "./specialists.js";
+import { toolNames } from "../BlockKit.js";
 import { protocol } from "../Instructions.js";
-import { available, toTools } from "./skills.js";
 import { mapText } from "./instructions.js";
-import { toolkit } from "./specialists.js";
 import "effect/Context";
 import * as Effect from "effect/Effect";
 import * as Predicate from "effect/Predicate";
@@ -18,6 +18,7 @@ import * as Schema from "effect/Schema";
 import * as Stream from "effect/Stream";
 import * as Exit from "effect/Exit";
 import * as Option from "effect/Option";
+import * as Response from "effect/ai/Response";
 import * as Ref from "effect/Ref";
 import * as Cause from "effect/Cause";
 import { identity } from "effect/Function";
@@ -56,11 +57,17 @@ const failureMessage = (cause) => Option.match(Schema.decodeUnknownOption(Provid
 	onNone: () => Cause.pretty(cause),
 	onSome: ({ _tag, raw }) => `${_tag ?? "Error"}: ${Predicate.isString(raw) ? raw : toJsonText(raw)}`
 });
+const approvedCalls = (entries) => [...fromEntries(entries).values()].flatMap(({ request, status, outcome }) => status === "approved" && outcome === void 0 ? [Response.makePart("tool-call", {
+	id: request.callId,
+	name: request.tool,
+	params: request.params,
+	providerExecuted: false
+})] : []);
 const lastSeq = (entries, otherwise) => entries.at(-1)?.seq ?? otherwise;
 const closeOpenCalls = Effect.fnUntraced(function* (chat, startSeq) {
 	const entries = (yield* chat.entries).filter(({ seq }) => seq > startSeq);
 	const started = new Set(entries.flatMap(({ event }) => Predicate.isTagged(event, "ToolStarted") ? [event.callId] : []));
-	const open = unansweredCalls(fromEntries(entries));
+	const open = unansweredCalls(fromEntries$1(entries));
 	if (open.length === 0) return;
 	yield* chat.append(open.map((call) => ToolResult.make({
 		callId: call.id,
@@ -95,12 +102,13 @@ const failTurn = Effect.fnUntraced(function* (chat, cause) {
 const makeTurnApi = (registration, chat, startSeq, checkOpen, ranLoop) => {
 	const { definition, builtins } = registration;
 	const { app } = definition;
+	const shownTools = toolNames(definition.blocks);
 	const running = (stream) => Stream.unwrap(Ref.set(ranLoop, true).pipe(Effect.as(stream)));
 	const history = Effect.fnUntraced(function* (view = identity) {
 		yield* checkOpen;
 		const all = yield* chat.entries;
 		return {
-			messages: fromEntries(view(decodeEntries(app, all))),
+			messages: fromEntries$1(view(decodeEntries(app, all))),
 			throughSeq: lastSeq(all, startSeq)
 		};
 	});
@@ -120,12 +128,13 @@ const makeTurnApi = (registration, chat, startSeq, checkOpen, ranLoop) => {
 				yield* checkOpen;
 				const entries = yield* chat.entries;
 				return {
-					messages: [...fromEntries(options.view(decodeEntries(app, entries))), userText(nudge)],
+					messages: [...fromEntries$1(options.view(decodeEntries(app, entries))), userText(nudge)],
 					throughSeq: lastSeq(entries, startSeq)
 				};
 			}),
-			maxSteps: 2
-		});
+			maxSteps: 2,
+			toolChoice: "required"
+		}).pipe(Stream.provideService(TurnApprovals, Option.none()));
 	}));
 	const replyIfOwed = (options) => running(replyPass({
 		instructions: instructions(options.instructions),
@@ -134,11 +143,10 @@ const makeTurnApi = (registration, chat, startSeq, checkOpen, ranLoop) => {
 		nudge: options.nudge
 	}));
 	const prepare = (options) => {
-		const own = fromToolkitOrEmpty(options.toolkit);
-		const skills = available(options.skills ?? [], [...builtins.definitions, ...own.definitions]);
+		const own = showing(fromToolkitOrEmpty(options.toolkit), shownTools);
 		return {
-			system: mapText(instructions(options.instructions), (text) => withCatalog(text, skills)),
-			toolkit: merge(merge(builtins, toTools(skills)), own),
+			system: instructions(options.instructions),
+			toolkit: merge(builtins, own),
 			view: options.history ?? identity
 		};
 	};
@@ -183,7 +191,7 @@ const run = Effect.fnUntraced(function* (options) {
 	const ranLoop = yield* Ref.make(false);
 	const turn = makeTurnApi(options.registration, chat, startSeq, options.checkOpen, ranLoop);
 	const record = (event) => chat.append([event]);
-	yield* options.handler(turn).pipe(Stream.runForEach(record), Effect.onExit((exit) => Exit.hasInterrupts(exit) ? Effect.void : closeOpenCalls(chat, startSeq)), Effect.provideService(TurnTools, Option.some(provide(options.registration.builtins, options.services))), Effect.provideContext(options.services), Effect.matchCauseEffect({
+	yield* options.handler(turn).pipe(Stream.runForEach(record), Effect.onExit((exit) => Exit.hasInterrupts(exit) ? Effect.void : closeOpenCalls(chat, startSeq)), Effect.provideService(TurnTools, Option.some(provide(options.registration.builtins, options.services))), Effect.provideService(TurnApprovals, Option.some({ approved: Effect.map(chat.entries, approvedCalls) })), Effect.provideContext(options.services), Effect.matchCauseEffect({
 		onSuccess: Effect.fnUntraced(function* () {
 			const all = yield* chat.entries;
 			yield* finishTurn(chat, handledThrough(all, startSeq), yield* Ref.get(ranLoop));

package/dist/internal/turns.js.map

@@ -1 +1 @@
-{"version":3,"file":"turns.js","names":["Toolkits.merge","Tools.makeMessaging","Specialists.toolkit","History.unansweredCalls","History.fromEntries","History.mayHaveRunOutput","History.notRunOutput","AssistantEvent.isLibraryEvent","History.owesReply","History.unreadAfter","AppEvents.decodeEntries","Instructions.protocol","History.owesDelivery","Loop.run","Toolkits.runOnly","Tools.sendUserMessageName","Tools.waitToolName","History.userText","Toolkits.fromToolkitOrEmpty","Skills.available","Skill.withCatalog","Skills.toTools","Toolkits.duplicateNames","Telemetry.agentInput","History.unhandledInputs","Telemetry.currentTraceId","Loop.TurnTools","Toolkits.provide","Telemetry.agentOutput","Telemetry.agentSpan"],"sources":["../../src/internal/turns.ts"],"sourcesContent":["import type * as LanguageModel from \"effect/ai/LanguageModel\"\nimport type * as Tool from \"effect/ai/Tool\"\nimport * as Cause from \"effect/Cause\"\nimport * as Context from \"effect/Context\"\nimport * as Effect from \"effect/Effect\"\nimport * as Exit from \"effect/Exit\"\nimport { identity } from \"effect/Function\"\nimport * as Option from \"effect/Option\"\nimport * as Predicate from \"effect/Predicate\"\nimport * as Ref from \"effect/Ref\"\nimport * as Schema from \"effect/Schema\"\nimport type * as Scope from \"effect/Scope\"\nimport * as Stream from \"effect/Stream\"\nimport type * as Assistant from \"../Assistant.ts\"\nimport type { ChatId } from \"../ChatId.ts\"\nimport * as AssistantEvent from \"../AssistantEvent.ts\"\nimport type * as AssistantLoop from \"../AssistantLoop.ts\"\nimport * as Loop from \"./loop.ts\"\nimport type * as BlockKit from \"../BlockKit.ts\"\nimport type { CurrentChat } from \"../CurrentChat.ts\"\nimport * as Instructions from \"../Instructions.ts\"\nimport * as Skill from \"../Skill.ts\"\nimport * as Skills from \"./skills.ts\"\nimport type * as Specialist from \"../Specialist.ts\"\nimport * as AppEvents from \"./events.ts\"\nimport * as History from \"./history.ts\"\nimport { mapText } from \"./instructions.ts\"\nimport { toJsonText } from \"./schema.ts\"\nimport * as Specialists from \"./specialists.ts\"\nimport * as Telemetry from \"./telemetry.ts\"\nimport * as Toolkits from \"./toolkit.ts\"\nimport type { Writer } from \"./writer.ts\"\nimport * as Tools from \"./tools.ts\"\n\n/** @internal */\nexport const silentTurnMessage = \"I finished without sending a reply.\"\n\n/** @internal */\nexport const defaultReplyNudge =\n  \"You haven't replied to the user's latest message yet. Reply now with send_user_message.\"\n\n/** @internal */\nexport const deliveryNudge =\n  \"You told the user you're on it, but stopped without giving them the result. Send it now with send_user_message; if part of it is still running, say what and that you'll report back. If they already have everything, call wait.\"\n\n/** @internal */\nexport interface Definition {\n  readonly name: string\n  readonly blocks: BlockKit.BlockKit | undefined\n  readonly specialists: ReadonlyArray<Specialist.Any>\n  readonly app: AppEvents.AppEvents\n}\n\n// Once its build ran the layer's services are provided, so its streams need only what a turn provides.\n/** @internal */\nexport type TurnHandler = (\n  turn: Assistant.Turn<any>\n) => Stream.Stream<AssistantLoop.Event, unknown, Assistant.TurnServices | LanguageModel.LanguageModel>\n\n// The chat `CurrentChat` gives, with its entries typed as the assistant's decode returns them: the assistant's typed\n// chat is this one, so it needs no check of its own.\n/** @internal */\nexport interface TypedChat {\n  readonly chatId: ChatId\n  readonly entries: Effect.Effect<AppEvents.DecodedEntries>\n  readonly append: CurrentChat[\"Service\"][\"append\"]\n}\n\n/** @internal */\nexport interface Registration {\n  readonly definition: Definition\n  readonly model: Context.Context<LanguageModel.LanguageModel>\n  readonly open: (chat: TypedChat) => Effect.Effect<TurnHandler, never, Scope.Scope | CurrentChat>\n  readonly specialists: ReadonlyArray<{\n    readonly specialist: Specialist.Any\n    readonly built: Specialist.Built\n  }>\n  readonly builtins: Toolkits.Tools<Assistant.TurnServices>\n}\n\n/** @internal */\nexport const register = Effect.fnUntraced(function* (\n  definition: Definition,\n  options: { readonly open: Registration[\"open\"] }\n) {\n  const model = yield* Effect.context<LanguageModel.LanguageModel>()\n\n  const specialists = yield* Effect.forEach(\n    definition.specialists,\n    Effect.fnUntraced(function* (specialist) {\n      const built = yield* Effect.serviceOption(specialist.Handler)\n\n      if (Option.isNone(built)) {\n        return yield* Effect.die(\n          `No handler for the ${specialist.name} specialist: provide ${specialist.name}.toLayer.`\n        )\n      }\n\n      return { specialist, built: built.value }\n    })\n  )\n\n  const builtins = Toolkits.merge(\n    yield* Tools.makeMessaging(definition.blocks),\n    yield* Specialists.toolkit(definition.specialists)\n  )\n\n  const registration: Registration = {\n    definition,\n    model,\n    open: options.open,\n    specialists,\n    builtins\n  }\n\n  return registration\n})\n\nconst ProviderError = Schema.Struct({ _tag: Schema.optional(Schema.String), raw: Schema.Unknown })\n\n// Provider errors keep their response body.\nconst failureMessage = (cause: Cause.Cause<unknown>): string =>\n  Option.match(Schema.decodeUnknownOption(ProviderError)(Cause.squash(cause)), {\n    onNone: () => Cause.pretty(cause),\n    onSome: ({ _tag, raw }) => `${_tag ?? \"Error\"}: ${Predicate.isString(raw) ? raw : toJsonText(raw)}`\n  })\n\nconst lastSeq = (entries: ReadonlyArray<AssistantEvent.AnyEntry>, otherwise: number) => entries.at(-1)?.seq ?? otherwise\n\n// The handler's stream can end between a step's output and its tools, or while they run. An interrupted turn (a\n// shutdown) leaves its calls open instead: the next turn runs them again.\nconst closeOpenCalls = Effect.fnUntraced(function* (chat: Writer, startSeq: number) {\n  const entries = (yield* chat.entries).filter(({ seq }) => seq > startSeq)\n\n  const started = new Set(\n    entries.flatMap(({ event }) => (Predicate.isTagged(event, \"ToolStarted\") ? [event.callId] : []))\n  )\n\n  const open = History.unansweredCalls(History.fromEntries(entries))\n\n  if (open.length === 0) return\n\n  yield* chat.append(\n    open.map((call) =>\n      AssistantEvent.ToolResult.make({\n        callId: call.id,\n        tool: call.name,\n        outcome: \"failure\",\n        ...(started.has(call.id)\n          ? { result: History.mayHaveRunOutput, reason: \"MayHaveRun\" }\n          : { result: History.notRunOutput, reason: \"NotRun\" })\n      })\n    )\n  )\n})\n\n// The inputs before the turn's `TurnStarted` (at `startSeq`) woke it; past that, what its model outputs record\n// reading.\nconst handledThrough = (entries: ReadonlyArray<AssistantEvent.AnyEntry>, startSeq: number) =>\n  entries.reduce(\n    (through, { seq, event }) =>\n      seq > startSeq &&\n      AssistantEvent.isLibraryEvent(event) &&\n      Predicate.isTagged(event, \"ModelOutput\") &&\n      event.seenThroughSeq !== undefined\n        ? Math.max(through, event.seenThroughSeq)\n        : through,\n    startSeq\n  )\n\n// A turn that ran the loop fails visibly when the user's latest input got no reply; an input that arrived after what\n// its model read gets the next turn, which replies. A handler that ended without the loop decided that itself.\nconst finishTurn = Effect.fnUntraced(function* (chat: Writer, read: number, ranLoop: boolean) {\n  const entries = yield* chat.entries\n\n  const end =\n    ranLoop && History.owesReply(entries, read) && !History.unreadAfter(entries, read)\n      ? AssistantEvent.TurnFailed.make({ throughSeq: read, message: silentTurnMessage })\n      : AssistantEvent.TurnCompleted.make({ throughSeq: read })\n\n  yield* chat.append([end])\n})\n\n// Everything stored so far counts as read, so a failing input isn't retried forever.\nconst failTurn = Effect.fnUntraced(function* (chat: Writer, cause: Cause.Cause<unknown>) {\n  yield* Effect.logError(\"assistant turn failed\", cause)\n\n  const last = lastSeq(yield* chat.entries, 0)\n\n  yield* chat.append([AssistantEvent.TurnFailed.make({ throughSeq: last, message: failureMessage(cause) })])\n})\n\nconst makeTurnApi = (\n  registration: Registration,\n  chat: Writer,\n  startSeq: number,\n  checkOpen: Effect.Effect<void>,\n  ranLoop: Ref.Ref<boolean>\n): Assistant.Turn<any> => {\n  const { definition, builtins } = registration\n  const { app } = definition\n\n  const running = <A, E, R>(stream: Stream.Stream<A, E, R>) =>\n    Stream.unwrap(Ref.set(ranLoop, true).pipe(Effect.as(stream)))\n\n  // With how far into the chat it goes: the step records it on the model's output.\n  // Read before every model call: a chat the app deleted meanwhile stops here.\n  const history = Effect.fnUntraced(function* (view: Assistant.HistoryView<any> = identity) {\n    yield* checkOpen\n\n    const all = yield* chat.entries\n\n    const read: AssistantLoop.ChatHistory = {\n      messages: History.fromEntries(view(AppEvents.decodeEntries(app, all))),\n      throughSeq: lastSeq(all, startSeq)\n    }\n\n    return read\n  })\n\n  const instructions = (given: string | Instructions.Resolved) =>\n    mapText(given, (text) => `${Instructions.protocol}\\n\\n${text}`)\n\n  // The loop's own prompt and tools, so the prompt stays cached, with the nudge at the end.\n  const replyPass = <R>(options: {\n    readonly instructions: Instructions.Resolved\n    readonly toolkit: Toolkits.Tools<R>\n    readonly view: Assistant.HistoryView<any>\n    readonly nudge: string | undefined\n  }) =>\n    Stream.unwrap(\n      Effect.gen(function* () {\n        const all = yield* chat.entries\n        const through = handledThrough(all, startSeq)\n\n        // Something arrived after what the loop's model read: the next turn reads it with the full loop, and replies.\n        if (History.unreadAfter(all, through)) return Stream.empty\n\n        const owed = History.owesReply(all, through)\n        const undelivered = !owed && History.owesDelivery(all, through)\n\n        if (!owed && !undelivered) return Stream.empty\n\n        const nudge = undelivered ? deliveryNudge : (options.nudge ?? defaultReplyNudge)\n\n        return Loop.run({\n          instructions: options.instructions,\n          // A reply that's owed can only be sent; a result it may have given may also be for nobody.\n          toolkit: Toolkits.runOnly(\n            options.toolkit,\n            owed ? [Tools.sendUserMessageName] : [Tools.sendUserMessageName, Tools.waitToolName],\n            \"Not now: reply to the user with send_user_message.\"\n          ),\n          history: Effect.gen(function* () {\n            yield* checkOpen\n\n            const entries = yield* chat.entries\n\n            return {\n              messages: [\n                ...History.fromEntries(options.view(AppEvents.decodeEntries(app, entries))),\n                History.userText(nudge)\n              ],\n              throughSeq: lastSeq(entries, startSeq)\n            }\n          }),\n          // A second step, for a reply after a call it was refused.\n          maxSteps: 2\n        })\n      })\n    )\n\n  const replyIfOwed = (options: Assistant.ReplyOptions) =>\n    running(\n      replyPass({\n        instructions: instructions(options.instructions),\n        toolkit: builtins,\n        view: identity,\n        nudge: options.nudge\n      })\n    )\n\n  const prepare = <T extends Record<string, Tool.Any>, RS>(options: Assistant.LoopOptions<T, RS, any>) => {\n    const own = Toolkits.fromToolkitOrEmpty(options.toolkit)\n    const skills = Skills.available(options.skills ?? [], [...builtins.definitions, ...own.definitions])\n\n    return {\n      system: mapText(instructions(options.instructions), (text) => Skill.withCatalog(text, skills)),\n      toolkit: Toolkits.merge(Toolkits.merge(builtins, Skills.toTools(skills)), own),\n      view: options.history ?? identity\n    }\n  }\n\n  return {\n    chatId: chat.chatId,\n    history,\n    instructions,\n    replyIfOwed,\n    loop: (options) => {\n      const { system, toolkit, view } = prepare(options)\n      const twice = Toolkits.duplicateNames(toolkit)\n\n      const loop =\n        twice.length > 0\n          ? Stream.die(`Tool names used twice, like one named after a built-in: ${twice.join(\", \")}`)\n          : Loop.run({\n              instructions: system,\n              toolkit,\n              history: history(view),\n              maxSteps: options.maxSteps ?? 16\n            })\n\n      return running(Stream.concat(loop, replyPass({ instructions: system, toolkit, view, nudge: options.replyNudge })))\n    }\n  }\n}\n\n// Every event the handler's loop emits is recorded before the loop is pulled again.\n/** @internal */\nexport const run = Effect.fnUntraced(\n  function* (options: {\n    readonly registration: Registration\n    readonly handler: TurnHandler\n    readonly chat: Writer\n    readonly services: Context.Context<Assistant.TurnServices | LanguageModel.LanguageModel>\n    // A chat the app deleted is deleted here, and the turn stops.\n    readonly checkOpen: Effect.Effect<void>\n  }) {\n    const { chat } = options\n    const before = yield* chat.entries\n\n    yield* Telemetry.agentInput(History.unhandledInputs(before))\n\n    const assistant = options.registration.definition.name\n    const traceId = yield* Telemetry.currentTraceId\n\n    const started = yield* chat.append([\n      AssistantEvent.TurnStarted.make(\n        Option.match(traceId, {\n          onNone: () => ({ assistant }),\n          onSome: (id) => ({ assistant, traceId: id })\n        })\n      )\n    ])\n\n    const startSeq = lastSeq(started, 0)\n    const ranLoop = yield* Ref.make(false)\n    const turn = makeTurnApi(options.registration, chat, startSeq, options.checkOpen, ranLoop)\n\n    const record = (event: AssistantLoop.Event) => chat.append([event])\n\n    yield* options.handler(turn).pipe(\n      Stream.runForEach(record),\n      Effect.onExit((exit) => (Exit.hasInterrupts(exit) ? Effect.void : closeOpenCalls(chat, startSeq))),\n      // A loop the app writes gets the assistant's own tools too, with this turn's services.\n      Effect.provideService(\n        Loop.TurnTools,\n        Option.some(Toolkits.provide(options.registration.builtins, options.services))\n      ),\n      Effect.provideContext(options.services),\n      Effect.matchCauseEffect({\n        onSuccess: Effect.fnUntraced(function* () {\n          const all = yield* chat.entries\n\n          yield* finishTurn(chat, handledThrough(all, startSeq), yield* Ref.get(ranLoop))\n        }),\n        onFailure: (cause) => failTurn(chat, cause)\n      })\n    )\n\n    // The trace's output is what the user saw this turn, and a failure if any.\n    const shown = (yield* chat.entries).flatMap(({ event, seq }) =>\n      seq > startSeq && (Predicate.isTagged(event, \"AssistantMessage\") || Predicate.isTagged(event, \"TurnFailed\"))\n        ? [event]\n        : []\n    )\n\n    yield* Telemetry.agentOutput(shown)\n  },\n  (effect, options) =>\n    effect.pipe(\n      Telemetry.agentSpan(options.registration.definition.name, {\n        chatId: options.chat.chatId,\n        root: true\n      })\n    )\n)\n"],"mappings":"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"}
+{"version":3,"file":"turns.js","names":["Toolkits.merge","Tools.makeMessaging","Specialists.toolkit","ToolApproval.fromEntries","History.unansweredCalls","History.fromEntries","History.mayHaveRunOutput","History.notRunOutput","AssistantEvent.isLibraryEvent","History.owesReply","History.unreadAfter","BlockKit.toolNames","AppEvents.decodeEntries","Instructions.protocol","History.owesDelivery","Loop.run","Toolkits.runOnly","Tools.sendUserMessageName","Tools.waitToolName","History.userText","Loop.TurnApprovals","Toolkits.showing","Toolkits.fromToolkitOrEmpty","Toolkits.duplicateNames","Telemetry.agentInput","History.unhandledInputs","Telemetry.currentTraceId","Loop.TurnTools","Toolkits.provide","Telemetry.agentOutput","Telemetry.agentSpan"],"sources":["../../src/internal/turns.ts"],"sourcesContent":["import type * as LanguageModel from \"effect/ai/LanguageModel\"\nimport * as Response from \"effect/ai/Response\"\nimport type * as Tool from \"effect/ai/Tool\"\nimport * as Cause from \"effect/Cause\"\nimport * as Context from \"effect/Context\"\nimport * as Effect from \"effect/Effect\"\nimport * as Exit from \"effect/Exit\"\nimport { identity } from \"effect/Function\"\nimport * as Option from \"effect/Option\"\nimport * as Predicate from \"effect/Predicate\"\nimport * as Ref from \"effect/Ref\"\nimport * as Schema from \"effect/Schema\"\nimport type * as Scope from \"effect/Scope\"\nimport * as Stream from \"effect/Stream\"\nimport type * as Assistant from \"../Assistant.ts\"\nimport type { ChatId } from \"../ChatId.ts\"\nimport * as AssistantEvent from \"../AssistantEvent.ts\"\nimport type * as AssistantLoop from \"../AssistantLoop.ts\"\nimport * as Loop from \"./loop.ts\"\nimport * as BlockKit from \"../BlockKit.ts\"\nimport type { CurrentChat } from \"../CurrentChat.ts\"\nimport * as Instructions from \"../Instructions.ts\"\nimport * as ToolApproval from \"../ToolApproval.ts\"\nimport type * as Specialist from \"../Specialist.ts\"\nimport * as AppEvents from \"./events.ts\"\nimport * as History from \"./history.ts\"\nimport { mapText } from \"./instructions.ts\"\nimport { toJsonText } from \"./schema.ts\"\nimport * as Specialists from \"./specialists.ts\"\nimport * as Telemetry from \"./telemetry.ts\"\nimport * as Toolkits from \"./toolkit.ts\"\nimport type { Writer } from \"./writer.ts\"\nimport * as Tools from \"./tools.ts\"\n\n/** @internal */\nexport const silentTurnMessage = \"I finished without sending a reply.\"\n\n/** @internal */\nexport const defaultReplyNudge =\n  \"You haven't replied to the user's latest message yet. Reply now with send_user_message.\"\n\n/** @internal */\nexport const deliveryNudge =\n  \"You told the user you're on it, but stopped without giving them the result. Send it now with send_user_message; if part of it is still running, say what and that you'll report back. If they already have everything, call wait.\"\n\n/** @internal */\nexport interface Definition {\n  readonly name: string\n  readonly blocks: BlockKit.BlockKit | undefined\n  readonly specialists: ReadonlyArray<Specialist.Any>\n  readonly app: AppEvents.AppEvents\n}\n\n// Once its build ran the layer's services are provided, so its streams need only what a turn provides.\n/** @internal */\nexport type TurnHandler = (\n  turn: Assistant.Turn<any>\n) => Stream.Stream<AssistantLoop.Event, unknown, Assistant.TurnServices | LanguageModel.LanguageModel>\n\n// The chat `CurrentChat` gives, with its entries typed as the assistant's decode returns them: the assistant's typed\n// chat is this one, so it needs no check of its own.\n/** @internal */\nexport interface TypedChat {\n  readonly chatId: ChatId\n  readonly entries: Effect.Effect<AppEvents.DecodedEntries>\n  readonly append: CurrentChat[\"Service\"][\"append\"]\n}\n\n/** @internal */\nexport interface Registration {\n  readonly definition: Definition\n  readonly model: Context.Context<LanguageModel.LanguageModel>\n  readonly open: (chat: TypedChat) => Effect.Effect<TurnHandler, never, Scope.Scope | CurrentChat>\n  readonly specialists: ReadonlyArray<{\n    readonly specialist: Specialist.Any\n    readonly built: Specialist.Built\n  }>\n  readonly builtins: Toolkits.Tools<Assistant.TurnServices>\n}\n\n/** @internal */\nexport const register = Effect.fnUntraced(function* (\n  definition: Definition,\n  options: { readonly open: Registration[\"open\"] }\n) {\n  const model = yield* Effect.context<LanguageModel.LanguageModel>()\n\n  const specialists = yield* Effect.forEach(\n    definition.specialists,\n    Effect.fnUntraced(function* (specialist) {\n      const built = yield* Effect.serviceOption(specialist.Handler)\n\n      if (Option.isNone(built)) {\n        return yield* Effect.die(\n          `No handler for the ${specialist.name} specialist: provide ${specialist.name}.toLayer.`\n        )\n      }\n\n      return { specialist, built: built.value }\n    })\n  )\n\n  const builtins = Toolkits.merge(\n    yield* Tools.makeMessaging(definition.blocks),\n    yield* Specialists.toolkit(definition.specialists)\n  )\n\n  const registration: Registration = {\n    definition,\n    model,\n    open: options.open,\n    specialists,\n    builtins\n  }\n\n  return registration\n})\n\nconst ProviderError = Schema.Struct({ _tag: Schema.optional(Schema.String), raw: Schema.Unknown })\n\n// Provider errors keep their response body.\nconst failureMessage = (cause: Cause.Cause<unknown>): string =>\n  Option.match(Schema.decodeUnknownOption(ProviderError)(Cause.squash(cause)), {\n    onNone: () => Cause.pretty(cause),\n    onSome: ({ _tag, raw }) => `${_tag ?? \"Error\"}: ${Predicate.isString(raw) ? raw : toJsonText(raw)}`\n  })\n\n// Approved, and not run yet: also one a crash cut off while it ran, which runs again with the same id.\nconst approvedCalls = (entries: ReadonlyArray<AssistantEvent.AnyEntry>): ReadonlyArray<AssistantEvent.ToolCallPart> =>\n  [...ToolApproval.fromEntries(entries).values()].flatMap(({ request, status, outcome }) =>\n    status === \"approved\" && outcome === undefined\n      ? [\n          Response.makePart(\"tool-call\", {\n            id: request.callId,\n            name: request.tool,\n            params: request.params,\n            providerExecuted: false\n          })\n        ]\n      : []\n  )\n\nconst lastSeq = (entries: ReadonlyArray<AssistantEvent.AnyEntry>, otherwise: number) => entries.at(-1)?.seq ?? otherwise\n\n// The handler's stream can end between a step's output and its tools, or while they run. An interrupted turn (a\n// shutdown) leaves its calls open instead: the next turn runs them again.\nconst closeOpenCalls = Effect.fnUntraced(function* (chat: Writer, startSeq: number) {\n  const entries = (yield* chat.entries).filter(({ seq }) => seq > startSeq)\n\n  const started = new Set(\n    entries.flatMap(({ event }) => (Predicate.isTagged(event, \"ToolStarted\") ? [event.callId] : []))\n  )\n\n  const open = History.unansweredCalls(History.fromEntries(entries))\n\n  if (open.length === 0) return\n\n  yield* chat.append(\n    open.map((call) =>\n      AssistantEvent.ToolResult.make({\n        callId: call.id,\n        tool: call.name,\n        outcome: \"failure\",\n        ...(started.has(call.id)\n          ? { result: History.mayHaveRunOutput, reason: \"MayHaveRun\" }\n          : { result: History.notRunOutput, reason: \"NotRun\" })\n      })\n    )\n  )\n})\n\n// The inputs before the turn's `TurnStarted` (at `startSeq`) woke it; past that, what its model outputs record\n// reading.\nconst handledThrough = (entries: ReadonlyArray<AssistantEvent.AnyEntry>, startSeq: number) =>\n  entries.reduce(\n    (through, { seq, event }) =>\n      seq > startSeq &&\n      AssistantEvent.isLibraryEvent(event) &&\n      Predicate.isTagged(event, \"ModelOutput\") &&\n      event.seenThroughSeq !== undefined\n        ? Math.max(through, event.seenThroughSeq)\n        : through,\n    startSeq\n  )\n\n// A turn that ran the loop fails visibly when the user's latest input got no reply; an input that arrived after what\n// its model read gets the next turn, which replies. A handler that ended without the loop decided that itself.\nconst finishTurn = Effect.fnUntraced(function* (chat: Writer, read: number, ranLoop: boolean) {\n  const entries = yield* chat.entries\n\n  const end =\n    ranLoop && History.owesReply(entries, read) && !History.unreadAfter(entries, read)\n      ? AssistantEvent.TurnFailed.make({ throughSeq: read, message: silentTurnMessage })\n      : AssistantEvent.TurnCompleted.make({ throughSeq: read })\n\n  yield* chat.append([end])\n})\n\n// Everything stored so far counts as read, so a failing input isn't retried forever.\nconst failTurn = Effect.fnUntraced(function* (chat: Writer, cause: Cause.Cause<unknown>) {\n  yield* Effect.logError(\"assistant turn failed\", cause)\n\n  const last = lastSeq(yield* chat.entries, 0)\n\n  yield* chat.append([AssistantEvent.TurnFailed.make({ throughSeq: last, message: failureMessage(cause) })])\n})\n\nconst makeTurnApi = (\n  registration: Registration,\n  chat: Writer,\n  startSeq: number,\n  checkOpen: Effect.Effect<void>,\n  ranLoop: Ref.Ref<boolean>\n): Assistant.Turn<any> => {\n  const { definition, builtins } = registration\n  const { app } = definition\n  const shownTools = BlockKit.toolNames(definition.blocks)\n\n  const running = <A, E, R>(stream: Stream.Stream<A, E, R>) =>\n    Stream.unwrap(Ref.set(ranLoop, true).pipe(Effect.as(stream)))\n\n  // With how far into the chat it goes: the step records it on the model's output.\n  // Read before every model call: a chat the app deleted meanwhile stops here.\n  const history = Effect.fnUntraced(function* (view: Assistant.HistoryView<any> = identity) {\n    yield* checkOpen\n\n    const all = yield* chat.entries\n\n    const read: AssistantLoop.ChatHistory = {\n      messages: History.fromEntries(view(AppEvents.decodeEntries(app, all))),\n      throughSeq: lastSeq(all, startSeq)\n    }\n\n    return read\n  })\n\n  const instructions = (given: string | Instructions.Resolved) =>\n    mapText(given, (text) => `${Instructions.protocol}\\n\\n${text}`)\n\n  // The loop's own prompt and tools, so the prompt stays cached, with the nudge at the end.\n  const replyPass = <R>(options: {\n    readonly instructions: Instructions.Resolved\n    readonly toolkit: Toolkits.Tools<R>\n    readonly view: Assistant.HistoryView<any>\n    readonly nudge: string | undefined\n  }) =>\n    Stream.unwrap(\n      Effect.gen(function* () {\n        const all = yield* chat.entries\n        const through = handledThrough(all, startSeq)\n\n        // Something arrived after what the loop's model read: the next turn reads it with the full loop, and replies.\n        if (History.unreadAfter(all, through)) return Stream.empty\n\n        const owed = History.owesReply(all, through)\n        const undelivered = !owed && History.owesDelivery(all, through)\n\n        if (!owed && !undelivered) return Stream.empty\n\n        const nudge = undelivered ? deliveryNudge : (options.nudge ?? defaultReplyNudge)\n\n        return Loop.run({\n          instructions: options.instructions,\n          // A reply that's owed can only be sent; a result it may have given may also be for nobody.\n          toolkit: Toolkits.runOnly(\n            options.toolkit,\n            owed ? [Tools.sendUserMessageName] : [Tools.sendUserMessageName, Tools.waitToolName],\n            \"Not now: reply to the user with send_user_message.\"\n          ),\n          history: Effect.gen(function* () {\n            yield* checkOpen\n\n            const entries = yield* chat.entries\n\n            return {\n              messages: [\n                ...History.fromEntries(options.view(AppEvents.decodeEntries(app, entries))),\n                History.userText(nudge)\n              ],\n              throughSeq: lastSeq(entries, startSeq)\n            }\n          }),\n          // A second step, for a reply after a call it was refused.\n          maxSteps: 2,\n          // The pass runs because the model wrote text of its own instead of replying, which reaches nobody: it has to\n          // call a tool now. Changing the choice costs a read of the history at full price, on these rare turns only.\n          toolChoice: \"required\"\n          // The loop ran the approved calls; a pass that can only reply runs none.\n        }).pipe(Stream.provideService(Loop.TurnApprovals, Option.none()))\n      })\n    )\n\n  const replyIfOwed = (options: Assistant.ReplyOptions) =>\n    running(\n      replyPass({\n        instructions: instructions(options.instructions),\n        toolkit: builtins,\n        view: identity,\n        nudge: options.nudge\n      })\n    )\n\n  const prepare = <T extends Record<string, Tool.Any>>(options: Assistant.LoopOptions<T, any>) => {\n    const own = Toolkits.showing(Toolkits.fromToolkitOrEmpty(options.toolkit), shownTools)\n\n    return {\n      system: instructions(options.instructions),\n      toolkit: Toolkits.merge(builtins, own),\n      view: options.history ?? identity\n    }\n  }\n\n  return {\n    chatId: chat.chatId,\n    history,\n    instructions,\n    replyIfOwed,\n    loop: (options) => {\n      const { system, toolkit, view } = prepare(options)\n      const twice = Toolkits.duplicateNames(toolkit)\n\n      const loop =\n        twice.length > 0\n          ? Stream.die(`Tool names used twice, like one named after a built-in: ${twice.join(\", \")}`)\n          : Loop.run({\n              instructions: system,\n              toolkit,\n              history: history(view),\n              maxSteps: options.maxSteps ?? 16\n            })\n\n      return running(Stream.concat(loop, replyPass({ instructions: system, toolkit, view, nudge: options.replyNudge })))\n    }\n  }\n}\n\n// Every event the handler's loop emits is recorded before the loop is pulled again.\n/** @internal */\nexport const run = Effect.fnUntraced(\n  function* (options: {\n    readonly registration: Registration\n    readonly handler: TurnHandler\n    readonly chat: Writer\n    readonly services: Context.Context<Assistant.TurnServices | LanguageModel.LanguageModel>\n    // A chat the app deleted is deleted here, and the turn stops.\n    readonly checkOpen: Effect.Effect<void>\n  }) {\n    const { chat } = options\n    const before = yield* chat.entries\n\n    yield* Telemetry.agentInput(History.unhandledInputs(before))\n\n    const assistant = options.registration.definition.name\n    const traceId = yield* Telemetry.currentTraceId\n\n    const started = yield* chat.append([\n      AssistantEvent.TurnStarted.make(\n        Option.match(traceId, {\n          onNone: () => ({ assistant }),\n          onSome: (id) => ({ assistant, traceId: id })\n        })\n      )\n    ])\n\n    const startSeq = lastSeq(started, 0)\n    const ranLoop = yield* Ref.make(false)\n    const turn = makeTurnApi(options.registration, chat, startSeq, options.checkOpen, ranLoop)\n\n    const record = (event: AssistantLoop.Event) => chat.append([event])\n\n    yield* options.handler(turn).pipe(\n      Stream.runForEach(record),\n      Effect.onExit((exit) => (Exit.hasInterrupts(exit) ? Effect.void : closeOpenCalls(chat, startSeq))),\n      // A loop the app writes gets the assistant's own tools too, with this turn's services.\n      Effect.provideService(\n        Loop.TurnTools,\n        Option.some(Toolkits.provide(options.registration.builtins, options.services))\n      ),\n      // A turn's loop waits for the user's approval, and runs the calls they approved.\n      Effect.provideService(Loop.TurnApprovals, Option.some({ approved: Effect.map(chat.entries, approvedCalls) })),\n      Effect.provideContext(options.services),\n      Effect.matchCauseEffect({\n        onSuccess: Effect.fnUntraced(function* () {\n          const all = yield* chat.entries\n\n          yield* finishTurn(chat, handledThrough(all, startSeq), yield* Ref.get(ranLoop))\n        }),\n        onFailure: (cause) => failTurn(chat, cause)\n      })\n    )\n\n    // The trace's output is what the user saw this turn, and a failure if any.\n    const shown = (yield* chat.entries).flatMap(({ event, seq }) =>\n      seq > startSeq && (Predicate.isTagged(event, \"AssistantMessage\") || Predicate.isTagged(event, \"TurnFailed\"))\n        ? [event]\n        : []\n    )\n\n    yield* Telemetry.agentOutput(shown)\n  },\n  (effect, options) =>\n    effect.pipe(\n      Telemetry.agentSpan(options.registration.definition.name, {\n        chatId: options.chat.chatId,\n        root: true\n      })\n    )\n)\n"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-assistant",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "A colleague assistant on Effect: an append-only event log per chat, an interruptible agent loop, specialists, skills, and UI blocks",
   "license": "MIT",
   "repository": {

package/src/Assistant.ts

@@ -34,7 +34,6 @@ import type { CurrentChat } from "./CurrentChat.ts"
 import type * as Instructions from "./Instructions.ts"
 import * as AppEvents from "./internal/events.ts"
 import * as Turns from "./internal/turns.ts"
-import type { Skill } from "./Skill.ts"
 import type * as Specialist from "./Specialist.ts"
 
 const TypeId = "~effect-assistant/Assistant" as const
@@ -54,21 +53,16 @@ export type TurnServices = CurrentChat | Specialist.Runner
  * @category models
  * @since 0.1.0
  */
-export interface LoopOptions<T extends Record<string, Tool.Any> = Record<never, never>, RS = never, Events = never> {
+export interface LoopOptions<T extends Record<string, Tool.Any> = Record<never, never>, Events = never> {
   /** The assistant's role and rules. The loop places `Instructions.protocol` before them. */
   readonly instructions: string | Instructions.Resolved
   /**
    * Tools the model can use in addition to the assistant's own. This is an `effect/ai` toolkit,
    * and its handlers come from the layer. Combine several toolkits with `Toolkit.merge`, for
-   * example `Memory.Tools` or a `ToolDiscovery.make(...)` toolkit together with your own.
+   * example `Memory.Tools`, a `Skill.toolkit(...)`, or a `ToolDiscovery.make(...)` toolkit together
+   * with your own.
    */
   readonly toolkit?: Toolkit.Toolkit<T> | undefined
-  /**
-   * Playbooks the model can follow. The prompt lists them as a catalog, and the model loads one
-   * with `load_skill` when a task matches it. A skill made with `tools` is left out when the turn's
-   * tools lack one of them.
-   */
-  readonly skills?: ReadonlyArray<Skill<RS>> | undefined
   /** The maximum number of model calls per turn. Defaults to 16. */
   readonly maxSteps?: number | undefined
   /** The message the reply pass gives the model when the turn would end without a reply. */
@@ -188,15 +182,15 @@ export interface Turn<Events = never> {
   readonly instructions: (instructions: string | Instructions.Resolved) => Instructions.Resolved
   /**
    * Runs the agent loop over the chat. The loop uses `Instructions.protocol`, the assistant's own
-   * tools, and the instructions, tools, and skills in `options`. Every step is a tool call, and
+   * tools, and the instructions and tools in `options`. Every step is a tool call, and
    * the loop ends with `replyIfOwed`.
    */
-  readonly loop: <T extends Record<string, Tool.Any> = Record<never, never>, RS = never>(
-    options: LoopOptions<T, RS, Events>
+  readonly loop: <T extends Record<string, Tool.Any> = Record<never, never>>(
+    options: LoopOptions<T, Events>
   ) => Stream.Stream<
     AssistantLoop.Event,
     AiError.AiError,
-    LanguageModel.LanguageModel | TurnServices | AssistantLoop.ToolkitServices<T> | RS
+    LanguageModel.LanguageModel | TurnServices | AssistantLoop.ToolkitServices<T>
   >
   /**
    * Runs one more pass when the turn would otherwise end without a reply to the user's latest

package/src/AssistantEvent.ts

@@ -140,13 +140,30 @@ export class SpecialistFinished extends Schema.TaggedClass<SpecialistFinished>()
   error: Schema.optional(Schema.String)
 }) {}
 
+/**
+ * Represents the user's decision on a tool call that waits for their approval: `"approved"`, so
+ * the call runs, or `"rejected"`, with an optional short reason the model reads.
+ *
+ * Its id is fixed per call (see `ToolApproval.approve`), so a decision is stored once. A decision on
+ * a call that isn't waiting any more (decided, or expired) isn't stored.
+ *
+ * @category schemas
+ * @since 0.4.0
+ */
+export class ApprovalDecision extends Schema.TaggedClass<ApprovalDecision>()("ApprovalDecision", {
+  id: InputId,
+  callId: Schema.String,
+  decision: Schema.Literals(["approved", "rejected"]),
+  reason: Schema.optional(Schema.String.check(Schema.isMaxLength(500)))
+}) {}
+
 /**
  * Schema for every input `Assistant.submit` accepts.
  *
  * @category schemas
  * @since 0.1.0
  */
-export const Input = Schema.Union([UserMessage, BlockAnswer, SpecialistFinished])
+export const Input = Schema.Union([UserMessage, BlockAnswer, SpecialistFinished, ApprovalDecision])
 
 /**
  * Represents an input to an assistant.
@@ -157,7 +174,8 @@ export const Input = Schema.Union([UserMessage, BlockAnswer, SpecialistFinished]
 export type Input = typeof Input.Type
 
 /**
- * Schema for the inputs from the chat's user, which are messages and block answers.
+ * Schema for the inputs from the chat's user, which are messages, block answers, and decisions on
+ * tool calls that wait for their approval.
  *
  * A turn owes each one a reply. It is also what a chat client usually may submit, since the app's
  * events come from the server.
@@ -165,7 +183,7 @@ export type Input = typeof Input.Type
  * @category schemas
  * @since 0.1.0
  */
-export const UserInput = Schema.Union([UserMessage, BlockAnswer])
+export const UserInput = Schema.Union([UserMessage, BlockAnswer, ApprovalDecision])
 
 /**
  * Represents an input from the chat's user.
@@ -179,12 +197,16 @@ export type UserInput = typeof UserInput.Type
  * Represents the UI shown with a message, as a block kind from the assistant's `BlockKit` and its
  * props.
  *
+ * A block that shows a tool's result (`Block.fromToolResult`) has the tool's name as its kind and
+ * the result's `resultId`.
+ *
  * @category schemas
  * @since 0.1.0
  */
 export class MessageBlock extends Schema.Class<MessageBlock>("effect-assistant/MessageBlock")({
   kind: Schema.String,
-  props: Schema.Unknown
+  props: Schema.Unknown,
+  resultId: Schema.optional(Schema.String)
 }) {}
 
 /**
@@ -307,6 +329,10 @@ export type ToolOutcome = typeof ToolOutcome.Type
  * failure includes its reason when it has one, which is a `ToolFailure`'s `reason` or the
  * failure's tag.
  *
+ * When the model reads less than the whole success (a `ToolResult.modelView`, or the `resultId`
+ * added for a tool the assistant's blocks show), `full` holds the whole success, encoded by the
+ * tool's success schema.
+ *
  * @category schemas
  * @since 0.1.0
  */
@@ -315,7 +341,10 @@ export class ToolResult extends Schema.TaggedClass<ToolResult>()("ToolResult", {
   tool: Schema.String,
   outcome: ToolOutcome,
   result: Schema.Json,
-  reason: Schema.optional(Schema.String)
+  reason: Schema.optional(Schema.String),
+  full: Schema.optional(Schema.Json),
+  /** The id the model passes in a `tool_result` block to show this result. */
+  resultId: Schema.optional(Schema.String)
 }) {}
 
 /**
@@ -400,6 +429,36 @@ export class BlocksClosed extends Schema.TaggedClass<BlocksClosed>()("BlocksClos
   messageIds: Schema.Array(Schema.String)
 }) {}
 
+/**
+ * Represents a tool call that waits for the user's approval instead of running: its tool needs
+ * approval (Effect's `needsApproval`).
+ *
+ * **Details**
+ *
+ * It holds the call's id, the tool, and its params, in JSON, as the model wrote them. The model
+ * reads it as the call's result, saying it waits for the user; the user's
+ * {@link ApprovalDecision} decides it, and an approved call runs then, with the same id.
+ *
+ * @category schemas
+ * @since 0.4.0
+ */
+export class ApprovalRequested extends Schema.TaggedClass<ApprovalRequested>()("ApprovalRequested", {
+  callId: Schema.String,
+  tool: Schema.String,
+  params: Schema.Json
+}) {}
+
+/**
+ * Represents tool calls that waited for the user's approval and won't run: the user moved on, like
+ * the ones `ToolApproval.closeStale` expires. The model reads that they weren't approved.
+ *
+ * @category schemas
+ * @since 0.4.0
+ */
+export class ApprovalsExpired extends Schema.TaggedClass<ApprovalsExpired>()("ApprovalsExpired", {
+  callIds: Schema.Array(Schema.String)
+}) {}
+
 /**
  * Schema for every event the library defines.
  *
@@ -419,6 +478,9 @@ export const AssistantEvent = Schema.Union([
   SpecialistStarted,
   SpecialistFinished,
   BlocksClosed,
+  ApprovalRequested,
+  ApprovalDecision,
+  ApprovalsExpired,
   ChatDeleted
 ])
 
@@ -554,7 +616,7 @@ export type Entry = typeof Entry.Type
 
 /**
  * Returns whether an event is one of the library's inputs, which are a user message, a block
- * answer, or a finished specialist run.
+ * answer, a finished specialist run, or a decision on a tool call waiting for approval.
  *
  * The application's events that came in through the assistant's `submit` are inputs too (see
  * {@link isAppInput}).
@@ -565,7 +627,8 @@ export type Entry = typeof Entry.Type
 export const isInput = (event: { readonly _tag: string }): event is Input =>
   Predicate.isTagged(event, "UserMessage") ||
   Predicate.isTagged(event, "BlockAnswer") ||
-  Predicate.isTagged(event, "SpecialistFinished")
+  Predicate.isTagged(event, "SpecialistFinished") ||
+  Predicate.isTagged(event, "ApprovalDecision")
 
 /**
  * Returns whether an input starts a turn, which every input does except a run the assistant
@@ -584,7 +647,9 @@ export const isWaking = (input: Input): boolean =>
  * @since 0.1.0
  */
 export const isUserInput = (input: Input): input is UserInput =>
-  Predicate.isTagged(input, "UserMessage") || Predicate.isTagged(input, "BlockAnswer")
+  Predicate.isTagged(input, "UserMessage") ||
+  Predicate.isTagged(input, "BlockAnswer") ||
+  Predicate.isTagged(input, "ApprovalDecision")
 
 /**
  * Returns whether an event ends a turn, and so says how far the assistant has read.

package/src/AssistantLoop.ts

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

package/src/Block.ts

@@ -5,9 +5,14 @@
  * pick from, a yes or no, or a small input. The assistant fills in its `props`, and
  * using the block sends back a value typed by its `answer` schema.
  *
+ * A block made with {@link fromToolResult} shows a tool's result instead: the assistant picks the
+ * result, and the client draws it from what the tool returned.
+ *
  * @since 0.1.0
  */
-import type * as Schema from "effect/Schema"
+import type * as Tool from "effect/ai/Tool"
+import * as Predicate from "effect/Predicate"
+import * as Schema from "effect/Schema"
 
 /**
  * Schema that a block's props or answer can use.
@@ -82,3 +87,79 @@ export const make = <const Kind extends string, Props extends Codec, Answer exte
   props: options.props,
   answer: options.answer
 })
+
+/**
+ * Schema for the props of a block that shows a tool's result: none, since the result is the block.
+ *
+ * @category schemas
+ * @since 0.5.0
+ */
+export const NoProps = Schema.Struct({})
+
+/**
+ * Represents a block that shows a tool's results, made with {@link fromToolResult}. Its kind is the
+ * tool's name.
+ *
+ * @category models
+ * @since 0.5.0
+ */
+export interface ToolResultBlock<T extends Tool.Any = Tool.Any> extends Block<
+  Tool.Name<T>,
+  typeof NoProps,
+  Schema.Never
+> {
+  readonly tool: T
+  /** The tool's success schema, which the client decodes the result with. */
+  readonly result: Codec
+}
+
+/**
+ * Creates a block that shows a tool's results.
+ *
+ * **Details**
+ *
+ * Put it in the assistant's `BlockKit`. The tool's results then carry a `resultId` in what the model
+ * reads, and the model shows one with a `tool_result` block that names it: it never sees the
+ * block's kind or how the client draws it. Sending the block fails back to the model when no
+ * successful result of a shown tool has that id.
+ *
+ * On the client, `BlockKit.toClient` gives the block's renderer the result, decoded by the tool's
+ * success schema. The tool's definition is shared with the client for that, so it can't need
+ * server-only services: add those on the server with `Tool.addDependency`.
+ *
+ * **Example** (Showing search results as cards)
+ *
+ * ```ts
+ * import { Block, BlockKit } from "effect-assistant"
+ * import { SearchAssets } from "./tools.ts"
+ *
+ * export const Blocks = BlockKit.make([PickOne, Block.fromToolResult(SearchAssets)])
+ *
+ * // Client
+ * const renderBlock = BlockKit.toClient<typeof Blocks, ReactNode>(Blocks, {
+ *   pick_one: ({ props, respond }) => <Options options={props.options} onPick={respond} />,
+ *   search_assets: ({ result }) => <AssetCards assets={result.items} />
+ * })
+ * ```
+ *
+ * @category constructors
+ * @since 0.5.0
+ */
+export const fromToolResult = <T extends Tool.Any>(
+  tool: T & { readonly successSchema: Codec }
+): ToolResultBlock<T> => ({
+  kind: tool.name,
+  description: `Shows a ${tool.name} result.`,
+  props: NoProps,
+  answer: undefined,
+  tool,
+  result: tool.successSchema
+})
+
+/**
+ * Returns whether a block shows a tool's results.
+ *
+ * @category guards
+ * @since 0.5.0
+ */
+export const isToolResult = (block: Any): block is ToolResultBlock => Predicate.hasProperty(block, "tool")

package/src/BlockKit.ts

@@ -8,12 +8,13 @@
  *
  * @since 0.1.0
  */
+import type * as Tool from "effect/ai/Tool"
 import * as Effect from "effect/Effect"
 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 type * as Block from "./Block.ts"
+import * as Block from "./Block.ts"
 import type * as Timeline from "./Timeline.ts"
 import { CurrentChat } from "./CurrentChat.ts"
 import * as InputId from "./InputId.ts"
@@ -40,6 +41,15 @@ export const make = <const Blocks extends ReadonlyArray<Block.Any>>(blocks: Bloc
   byKind: new Map(blocks.map((block) => [block.kind, block]))
 })
 
+/**
+ * Returns the names of the tools whose results the kit's blocks show (`Block.fromToolResult`).
+ *
+ * @category utils
+ * @since 0.5.0
+ */
+export const toolNames = (kit: BlockKit | undefined): ReadonlySet<string> =>
+  new Set((kit?.blocks ?? []).flatMap((block) => (Block.isToolResult(block) ? [block.tool.name] : [])))
+
 type KindOf<B> = B extends { readonly kind: infer K extends string } ? K : never
 
 type BlockOf<Kit extends BlockKit, K> = Extract<Kit["blocks"][number], { readonly kind: K }>
@@ -48,6 +58,13 @@ type PropsOf<B> = B extends { readonly props: Schema.Top } ? B["props"]["Type"]
 
 type AnswerOf<B> = B extends { readonly answer: infer A } ? (A extends Schema.Top ? A["Type"] : never) : never
 
+type ResultArgs<B> = B extends { readonly tool: infer T }
+  ? {
+      /** The tool's result the block shows, decoded by its success schema. */
+      readonly result: Tool.Success<T>
+    }
+  : unknown
+
 /**
  * Represents the state of a message's block.
  *
@@ -164,12 +181,21 @@ export const closeStale = Effect.fn(function* (options: { readonly messages: num
 })
 
 /**
- * Represents what a renderer receives for one block.
+ * Represents what a renderer receives for one block. A block that shows a tool's result also gets
+ * the `result`.
  *
  * @category models
  * @since 0.1.0
  */
-export interface RenderArgs<B> {
+export type RenderArgs<B> = BlockArgs<B> & ResultArgs<B>
+
+/**
+ * Represents what every block's renderer receives.
+ *
+ * @category models
+ * @since 0.5.0
+ */
+export interface BlockArgs<B> {
   /**
    * The id of the message the block is on. A block whose button calls your API can key the work
    * on it, with the chat's id, so the work runs once per block.
@@ -256,7 +282,7 @@ export function toClient<Kit extends BlockKit, Out>(
 // arguments.
 export function toClient<Out>(
   kit: BlockKit,
-  renderers: Readonly<Record<string, (args: RenderArgs<Block.Any>) => Out>>
+  renderers: Readonly<Record<string, (args: BlockArgs<Block.Any> & { readonly result?: unknown }) => Out>>
 ): (message: Timeline.AssistantMessage, options: RenderOptions) => Out | undefined {
   return (message, options) => {
     if (message.block === undefined) return undefined
@@ -271,6 +297,12 @@ export function toClient<Out>(
 
     if (Option.isNone(props)) return undefined
 
+    const result = Block.isToolResult(block)
+      ? Schema.decodeUnknownOption(Schema.toCodecJson(block.result))(message.block.result)
+      : Option.some(undefined)
+
+    if (Option.isNone(result)) return undefined
+
     const given = message.block.answer
     const answerCodec = block.answer === undefined ? undefined : Schema.toCodecJson(block.answer)
 
@@ -281,6 +313,7 @@ export function toClient<Out>(
       messageId: message.id,
       text: message.text,
       props: props.value,
+      result: result.value,
       open: message.block.status === "open",
       answer: Option.getOrUndefined(answer),
       respond: (value) =>