effect-assistant 0.0.0-stage → 0.1.0

package/dist/Chats.js

@@ -0,0 +1,98 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import { ChatId } from "./ChatId.js";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+//#region src/Chats.ts
+/**
+* This module provides the `Chats` service, through which the app tells the library which chats
+* exist.
+*
+* The app keeps its own record of each chat (its owner, its title, whether it was deleted) and
+* decides when a chat is created: up front, or on its first message. The library asks `Chats`
+* before it stores an input and before each model call. When the app reports a chat as deleted,
+* the library deletes it as well (see `Assistant.delete`).
+*
+* @since 0.1.0
+*/
+var Chats_exports = /* @__PURE__ */ __exportAll({
+	Chats: () => Chats,
+	GetChatError: () => GetChatError,
+	Reason: () => Reason
+});
+/**
+* Schema for the reason a chat can't be used. `"NotFound"` means the app doesn't know the chat,
+* and `"Deleted"` means the app deleted it.
+*
+* @category schemas
+* @since 0.1.0
+*/
+const Reason = Schema.Literals(["NotFound", "Deleted"]);
+/**
+* Represents the error that `get` fails with when a chat can't be used. It carries the chat's id
+* and the {@link Reason}. An input for such a chat isn't stored.
+*
+* **Example** (Failing for an unknown chat)
+*
+* ```ts
+* if (row === undefined) return yield* new GetChatError({ chatId, reason: "NotFound" })
+* ```
+*
+* @category errors
+* @since 0.1.0
+*/
+var GetChatError = class extends Schema.Error("effect-assistant/Chats/GetChatError")({
+	_tag: Schema.tag("GetChatError"),
+	chatId: ChatId,
+	reason: Reason
+}) {};
+/**
+* Service that tells the library which of the app's chats exist.
+*
+* **Details**
+*
+* By default every chat exists from its first input, and a chat is deleted only when its log
+* says so (`ChatDeleted`). Provide your own implementation to have the app decide. Provide it
+* where you provide the `ChatLog`, so the engine and your server see the same one.
+*
+* **Example** (Reading chats from the app's own table)
+*
+* ```ts
+* import { type ChatId, Chats } from "effect-assistant"
+* import * as Effect from "effect/Effect"
+* import * as Layer from "effect/Layer"
+* import * as SqlClient from "effect/sql/SqlClient"
+*
+* const ChatsLive = Layer.effect(
+*   Chats.Chats,
+*   Effect.gen(function* () {
+*     const sql = yield* SqlClient.SqlClient
+*
+*     return {
+*       get: Effect.fn(function* (chatId: ChatId.ChatId) {
+*         const [row] = yield* sql<{ readonly deleted_at: number | null }>`
+*           SELECT deleted_at FROM chats WHERE chat_id = ${chatId}
+*         `.pipe(Effect.orDie)
+*
+*         if (row === undefined) {
+*           return yield* new Chats.GetChatError({ chatId, reason: "NotFound" })
+*         }
+*         if (row.deleted_at !== null) {
+*           return yield* new Chats.GetChatError({ chatId, reason: "Deleted" })
+*         }
+*
+*         return { chatId }
+*       })
+*     }
+*   })
+* )
+* ```
+*
+* @category services
+* @since 0.1.0
+*/
+const Chats = Context.Reference("effect-assistant/Chats", { defaultValue: () => ({ get: (chatId) => Effect.succeed({ chatId }) }) });
+//#endregion
+export { Chats, Chats_exports, GetChatError, Reason };
+
+//# sourceMappingURL=Chats.js.map

package/dist/Chats.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Chats.js","names":[],"sources":["../src/Chats.ts"],"sourcesContent":["/**\n * This module provides the `Chats` service, through which the app tells the library which chats\n * exist.\n *\n * The app keeps its own record of each chat (its owner, its title, whether it was deleted) and\n * decides when a chat is created: up front, or on its first message. The library asks `Chats`\n * before it stores an input and before each model call. When the app reports a chat as deleted,\n * the library deletes it as well (see `Assistant.delete`).\n *\n * @since 0.1.0\n */\nimport * as Context from \"effect/Context\"\nimport * as Effect from \"effect/Effect\"\nimport * as Schema from \"effect/Schema\"\nimport { ChatId } from \"./ChatId.ts\"\n\n/**\n * Schema for the reason a chat can't be used. `\"NotFound\"` means the app doesn't know the chat,\n * and `\"Deleted\"` means the app deleted it.\n *\n * @category schemas\n * @since 0.1.0\n */\nexport const Reason = Schema.Literals([\"NotFound\", \"Deleted\"])\n\n/**\n * The reason a chat can't be used.\n *\n * @category models\n * @since 0.1.0\n */\nexport type Reason = typeof Reason.Type\n\n/**\n * Represents the error that `get` fails with when a chat can't be used. It carries the chat's id\n * and the {@link Reason}. An input for such a chat isn't stored.\n *\n * **Example** (Failing for an unknown chat)\n *\n * ```ts\n * if (row === undefined) return yield* new GetChatError({ chatId, reason: \"NotFound\" })\n * ```\n *\n * @category errors\n * @since 0.1.0\n */\nexport class GetChatError extends Schema.Error<GetChatError>(\"effect-assistant/Chats/GetChatError\")({\n  _tag: Schema.tag(\"GetChatError\"),\n  chatId: ChatId,\n  reason: Reason\n}) {}\n\n/**\n * Represents what the library needs to know about a chat, which is its id. The app's own record\n * can carry more.\n *\n * @category models\n * @since 0.1.0\n */\nexport interface ChatRecord {\n  readonly chatId: ChatId\n}\n\n/**\n * Represents the app's chats, as the `Chats` service exposes them.\n *\n * @category models\n * @since 0.1.0\n */\nexport interface Service {\n  /** Returns the chat, or fails with a `GetChatError` that says why it can't be used. */\n  readonly get: (chatId: ChatId) => Effect.Effect<ChatRecord, GetChatError>\n}\n\n/**\n * Service that tells the library which of the app's chats exist.\n *\n * **Details**\n *\n * By default every chat exists from its first input, and a chat is deleted only when its log\n * says so (`ChatDeleted`). Provide your own implementation to have the app decide. Provide it\n * where you provide the `ChatLog`, so the engine and your server see the same one.\n *\n * **Example** (Reading chats from the app's own table)\n *\n * ```ts\n * import { type ChatId, Chats } from \"effect-assistant\"\n * import * as Effect from \"effect/Effect\"\n * import * as Layer from \"effect/Layer\"\n * import * as SqlClient from \"effect/sql/SqlClient\"\n *\n * const ChatsLive = Layer.effect(\n *   Chats.Chats,\n *   Effect.gen(function* () {\n *     const sql = yield* SqlClient.SqlClient\n *\n *     return {\n *       get: Effect.fn(function* (chatId: ChatId.ChatId) {\n *         const [row] = yield* sql<{ readonly deleted_at: number | null }>`\n *           SELECT deleted_at FROM chats WHERE chat_id = ${chatId}\n *         `.pipe(Effect.orDie)\n *\n *         if (row === undefined) {\n *           return yield* new Chats.GetChatError({ chatId, reason: \"NotFound\" })\n *         }\n *         if (row.deleted_at !== null) {\n *           return yield* new Chats.GetChatError({ chatId, reason: \"Deleted\" })\n *         }\n *\n *         return { chatId }\n *       })\n *     }\n *   })\n * )\n * ```\n *\n * @category services\n * @since 0.1.0\n */\nexport const Chats: Context.Reference<Service> = Context.Reference<Service>(\"effect-assistant/Chats\", {\n  defaultValue: () => ({ get: (chatId) => Effect.succeed({ chatId }) })\n})\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuBA,MAAa,SAAS,OAAO,SAAS,CAAC,YAAY,SAAS,CAAC;;;;;;;;;;;;;;AAuB7D,IAAa,eAAb,cAAkC,OAAO,MAAoB,qCAAqC,CAAC,CAAC;CAClG,MAAM,OAAO,IAAI,cAAc;CAC/B,QAAQ;CACR,QAAQ;AACV,CAAC,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqEJ,MAAa,QAAoC,QAAQ,UAAmB,0BAA0B,EACpG,qBAAqB,EAAE,MAAM,WAAW,OAAO,QAAQ,EAAE,OAAO,CAAC,EAAE,GACrE,CAAC"}

package/dist/Compaction.d.ts

@@ -0,0 +1,105 @@
+import { AnyEntry, AssistantEvent_d_exports } from "./AssistantEvent.js";
+import { Assistant_d_exports, Entry } from "./Assistant.js";
+import * as Option from "effect/Option";
+import * as Prompt from "effect/ai/Prompt";
+declare namespace Compaction_d_exports {
+  export { Summary, attachedFiles, inputTokens, openItems, since };
+}
+/**
+ * Represents the fields a summary event must have: its text and the last `seq` it covers.
+ *
+ * Entries after `throughSeq` are kept as they are, so an input that arrived while the summary was
+ * being written isn't lost.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export interface Summary {
+  readonly _tag: string;
+  readonly text: string;
+  readonly throughSeq: number;
+}
+/**
+ * Returns the number of input tokens used by the chat's last model call, which shows how large
+ * the prompt has grown. Returns 0 before the first call.
+ *
+ * @category utils
+ * @since 0.1.0
+ */
+export declare const inputTokens: (entries: ReadonlyArray<AnyEntry>) => number;
+/**
+ * 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
+ * the model, or `None` when nothing is open.
+ *
+ * @category utils
+ * @since 0.1.0
+ */
+export declare const openItems: (entries: ReadonlyArray<AnyEntry>, throughSeq: number) => Option.Option<string>;
+/**
+ * Returns the files the user attached up to `throughSeq`, as lines of text for the model, or
+ * `None` when there are none. A summary may leave out a file's id, which tools need.
+ *
+ * @category utils
+ * @since 0.1.0
+ */
+export declare const attachedFiles: (entries: ReadonlyArray<AnyEntry>, throughSeq: number) => Option.Option<string>;
+/**
+ * Creates a history view that starts at the last summary.
+ *
+ * **Details**
+ *
+ * `isSummary` identifies the app's summary events. The model reads the last summary, the files
+ * attached earlier ({@link attachedFiles}), and the items that are still open
+ * ({@link openItems}), followed by the entries after the summary. When the chat has no summary,
+ * the view returns every entry.
+ *
+ * **Example** (Compacting a long chat after each turn)
+ *
+ * ```ts
+ * import { AppEvent, Assistant, type AssistantEvent, Compaction } from "effect-assistant"
+ * import * as LanguageModel from "effect/ai/LanguageModel"
+ * import * as Effect from "effect/Effect"
+ * import * as Schema from "effect/Schema"
+ * import * as Stream from "effect/Stream"
+ *
+ * class Summary extends Schema.TaggedClass<Summary>()("Summary", {
+ *   text: Schema.String,
+ *   throughSeq: Schema.Int
+ * }) {}
+ *
+ * declare const transcript: (entries: ReadonlyArray<AssistantEvent.AnyEntry>) => string
+ *
+ * export const MyAssistant = Assistant.make("my-assistant", { events: [AppEvent.make(Summary)] })
+ *
+ * const MyAssistantLive = MyAssistant.toLayer((turn) => {
+ *   const compact = Effect.gen(function* () {
+ *     const chat = yield* MyAssistant.Chat
+ *     const entries = yield* chat.entries
+ *
+ *     if (Compaction.inputTokens(entries) < 100_000) return
+ *
+ *     const { text } = yield* LanguageModel.generateText({
+ *       prompt: `Summarize this chat:\n\n${transcript(entries)}`
+ *     })
+ *
+ *     yield* chat.append(Summary.make({ text, throughSeq: entries.at(-1)?.seq ?? 0 }))
+ *   })
+ *
+ *   // After the reply, so the user doesn't wait for the summary.
+ *   return Stream.concat(
+ *     turn.loop({ instructions: "Be brief.", history: Compaction.since(Schema.is(Summary)) }),
+ *     Stream.drain(Stream.fromEffect(compact))
+ *   )
+ * })
+ * ```
+ *
+ * @category utils
+ * @since 0.1.0
+ */
+export declare const since: (isSummary: (event: unknown) => event is Summary) => <Events extends {
+  readonly _tag: string;
+}>(entries: ReadonlyArray<Entry<Events>>) => ReadonlyArray<Entry<Events> | Prompt.Message>;
+//#endregion
+export { Compaction_d_exports };
+//# sourceMappingURL=Compaction.d.ts.map

package/dist/Compaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Compaction.d.ts","names":[],"sources":["../src/Compaction.ts"],"mappings":";;;;;;;;;;;;;;;;iBAgCiB;WACN;WACA;WACA;;;;;;;;;qBAUE,cAAW,SAAa,cAAc;;;;;;;;;qBAmBtC,YAAS,SACX,cAAc,WAAwB,uBAE9C,OAAO;;;;;;;;qBAmEG,gBAAa,SACf,cAAc,WAAwB,uBAE9C,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA+DG,QAAK,YACH,mBAAmB,SAAS,aACxC;WAA0B;GAAc,SAC9B,cAAc,MAAgB,aACtC,cAAc,MAAgB,UAAU,OAAO"}

package/dist/Compaction.js

@@ -0,0 +1,133 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import { attachmentLine, isLibraryEvent } from "./AssistantEvent.js";
+import { fromEntries } from "./Decision.js";
+import { fromEntries as fromEntries$1 } from "./BlockKit.js";
+import { toJsonText } from "./internal/schema.js";
+import { userText } from "./internal/history.js";
+import { fromEntries as fromEntries$2 } from "./AssistantActivity.js";
+import * as Predicate from "effect/Predicate";
+import * as Option from "effect/Option";
+//#region src/Compaction.ts
+var Compaction_exports = /* @__PURE__ */ __exportAll({
+	attachedFiles: () => attachedFiles,
+	inputTokens: () => inputTokens,
+	openItems: () => openItems,
+	since: () => since
+});
+/**
+* Returns the number of input tokens used by the chat's last model call, which shows how large
+* the prompt has grown. Returns 0 before the first call.
+*
+* @category utils
+* @since 0.1.0
+*/
+const inputTokens = (entries) => {
+	const last = entries.findLast(({ event }) => isLibraryEvent(event) && Predicate.isTagged(event, "ModelOutput") && event.usage !== void 0)?.event;
+	return last !== void 0 && isLibraryEvent(last) && Predicate.isTagged(last, "ModelOutput") ? last.usage?.inputTokens.total ?? 0 : 0;
+};
+/**
+* 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
+* the model, or `None` when nothing is open.
+*
+* @category utils
+* @since 0.1.0
+*/
+const openItems = (entries, throughSeq) => {
+	const seqOf = (found) => entries.find(({ event }) => found(event))?.seq ?? Number.POSITIVE_INFINITY;
+	const opened = (seq) => seq <= throughSeq;
+	const decisions = [...fromEntries(entries).values()].flatMap((state) => state.outcome === void 0 && opened(seqOf((event) => 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 = [...fromEntries$1(entries)].flatMap(([messageId, state]) => {
+		const shown = entries.find(({ event }) => isLibraryEvent(event) && Predicate.isTagged(event, "AssistantMessage") && event.id === messageId);
+		const message = shown?.event;
+		return state.open && shown !== void 0 && opened(shown.seq) && message !== void 0 && isLibraryEvent(message) && Predicate.isTagged(message, "AssistantMessage") ? [`- message ${messageId}, a ${message.block?.kind} block: ${message.text}`] : [];
+	});
+	const specialists = [...fromEntries$2(entries).specialists.values()].flatMap((run) => opened(seqOf((event) => isLibraryEvent(event) && Predicate.isTagged(event, "SpecialistStarted") && event.runId === run.runId)) ? [`- your ${run.specialist} specialist (${run.runId}), working on: ${run.goal}`] : []);
+	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);
+	return sections.length === 0 ? Option.none() : Option.some(sections.join("\n\n"));
+};
+/**
+* Returns the files the user attached up to `throughSeq`, as lines of text for the model, or
+* `None` when there are none. A summary may leave out a file's id, which tools need.
+*
+* @category utils
+* @since 0.1.0
+*/
+const attachedFiles = (entries, throughSeq) => {
+	const lines = entries.flatMap(({ seq, event }) => seq <= throughSeq && isLibraryEvent(event) && Predicate.isTagged(event, "UserMessage") ? (event.attachments ?? []).map(attachmentLine) : []);
+	return lines.length === 0 ? Option.none() : Option.some(lines.join("\n"));
+};
+/**
+* Creates a history view that starts at the last summary.
+*
+* **Details**
+*
+* `isSummary` identifies the app's summary events. The model reads the last summary, the files
+* attached earlier ({@link attachedFiles}), and the items that are still open
+* ({@link openItems}), followed by the entries after the summary. When the chat has no summary,
+* the view returns every entry.
+*
+* **Example** (Compacting a long chat after each turn)
+*
+* ```ts
+* import { AppEvent, Assistant, type AssistantEvent, Compaction } from "effect-assistant"
+* import * as LanguageModel from "effect/ai/LanguageModel"
+* import * as Effect from "effect/Effect"
+* import * as Schema from "effect/Schema"
+* import * as Stream from "effect/Stream"
+*
+* class Summary extends Schema.TaggedClass<Summary>()("Summary", {
+*   text: Schema.String,
+*   throughSeq: Schema.Int
+* }) {}
+*
+* declare const transcript: (entries: ReadonlyArray<AssistantEvent.AnyEntry>) => string
+*
+* export const MyAssistant = Assistant.make("my-assistant", { events: [AppEvent.make(Summary)] })
+*
+* const MyAssistantLive = MyAssistant.toLayer((turn) => {
+*   const compact = Effect.gen(function* () {
+*     const chat = yield* MyAssistant.Chat
+*     const entries = yield* chat.entries
+*
+*     if (Compaction.inputTokens(entries) < 100_000) return
+*
+*     const { text } = yield* LanguageModel.generateText({
+*       prompt: `Summarize this chat:\n\n${transcript(entries)}`
+*     })
+*
+*     yield* chat.append(Summary.make({ text, throughSeq: entries.at(-1)?.seq ?? 0 }))
+*   })
+*
+*   // After the reply, so the user doesn't wait for the summary.
+*   return Stream.concat(
+*     turn.loop({ instructions: "Be brief.", history: Compaction.since(Schema.is(Summary)) }),
+*     Stream.drain(Stream.fromEffect(compact))
+*   )
+* })
+* ```
+*
+* @category utils
+* @since 0.1.0
+*/
+const since = (isSummary) => (entries) => {
+	const last = entries.findLast(({ event }) => isSummary(event))?.event;
+	if (last === void 0 || !isSummary(last)) return entries;
+	const open = Option.match(openItems(entries, last.throughSeq), {
+		onNone: () => "",
+		onSome: (items) => `\n\n<still_open>\n${items}\n</still_open>`
+	});
+	const files = Option.match(attachedFiles(entries, last.throughSeq), {
+		onNone: () => "",
+		onSome: (lines) => `\n\n<files_attached_earlier>\n${lines}\n</files_attached_earlier>`
+	});
+	return [userText(`<earlier_in_this_chat>\n${last.text}\n</earlier_in_this_chat>${files}${open}`), ...entries.filter(({ seq, event }) => seq > last.throughSeq && !isSummary(event))];
+};
+//#endregion
+export { Compaction_exports, attachedFiles, inputTokens, openItems, since };
+
+//# sourceMappingURL=Compaction.js.map

package/dist/Compaction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Compaction.js","names":["AssistantEvent.isLibraryEvent","Decision.fromEntries","BlockKit.fromEntries","AssistantActivity.fromEntries","AssistantEvent.attachmentLine"],"sources":["../src/Compaction.ts"],"sourcesContent":["/**\n * This module provides what a long chat needs so that the model can read a summary in place of\n * everything before it.\n *\n * The app decides when to compact, which model writes the summary, and what the summary says.\n * Its handler reads the chat's entries, has a model write a summary, and stores the summary as one\n * of the assistant's own events (see {@link Summary}). Its loop then reads the chat through\n * {@link since}. {@link inputTokens} helps decide when the prompt has grown large enough to\n * compact. The log keeps every entry, so the user still sees the whole chat.\n *\n * @since 0.1.0\n */\nimport type * as Prompt from \"effect/ai/Prompt\"\nimport * as Option from \"effect/Option\"\nimport * as Predicate from \"effect/Predicate\"\nimport type * as Assistant from \"./Assistant.ts\"\nimport * as AssistantActivity from \"./AssistantActivity.ts\"\nimport * as AssistantEvent from \"./AssistantEvent.ts\"\nimport * as BlockKit from \"./BlockKit.ts\"\nimport * as Decision from \"./Decision.ts\"\nimport { userText } from \"./internal/history.ts\"\nimport { toJsonText } from \"./internal/schema.ts\"\n\n/**\n * Represents the fields a summary event must have: its text and the last `seq` it covers.\n *\n * Entries after `throughSeq` are kept as they are, so an input that arrived while the summary was\n * being written isn't lost.\n *\n * @category models\n * @since 0.1.0\n */\nexport interface Summary {\n  readonly _tag: string\n  readonly text: string\n  readonly throughSeq: number\n}\n\n/**\n * Returns the number of input tokens used by the chat's last model call, which shows how large\n * the prompt has grown. Returns 0 before the first call.\n *\n * @category utils\n * @since 0.1.0\n */\nexport const inputTokens = (entries: ReadonlyArray<AssistantEvent.AnyEntry>): number => {\n  const last = entries.findLast(\n    ({ event }) =>\n      AssistantEvent.isLibraryEvent(event) && Predicate.isTagged(event, \"ModelOutput\") && event.usage !== undefined\n  )?.event\n\n  return last !== undefined && AssistantEvent.isLibraryEvent(last) && Predicate.isTagged(last, \"ModelOutput\")\n    ? (last.usage?.inputTokens.total ?? 0)\n    : 0\n}\n\n/**\n * Returns the items that were open at `throughSeq` and are still open: decisions waiting for the\n * user, blocks the user hasn't answered, and specialists that are working. The result is text for\n * the model, or `None` when nothing is open.\n *\n * @category utils\n * @since 0.1.0\n */\nexport const openItems = (\n  entries: ReadonlyArray<AssistantEvent.AnyEntry>,\n  throughSeq: number\n): Option.Option<string> => {\n  const seqOf = (found: (event: AssistantEvent.AnyEntry[\"event\"]) => boolean) =>\n    entries.find(({ event }) => found(event))?.seq ?? Number.POSITIVE_INFINITY\n\n  const opened = (seq: number) => seq <= throughSeq\n\n  const decisions = [...Decision.fromEntries(entries).values()].flatMap((state) =>\n    state.outcome === undefined &&\n    opened(\n      seqOf(\n        (event) =>\n          AssistantEvent.isLibraryEvent(event) &&\n          Predicate.isTagged(event, \"DecisionRequested\") &&\n          event.id === state.request.id\n      )\n    )\n      ? [`- decision ${state.request.id}, for ${state.request.origin.tool}: ${toJsonText(state.request.origin.params)}`]\n      : []\n  )\n\n  const blocks = [...BlockKit.fromEntries(entries)].flatMap(([messageId, state]) => {\n    const shown = entries.find(\n      ({ event }) =>\n        AssistantEvent.isLibraryEvent(event) && Predicate.isTagged(event, \"AssistantMessage\") && event.id === messageId\n    )\n\n    const message = shown?.event\n\n    return state.open &&\n      shown !== undefined &&\n      opened(shown.seq) &&\n      message !== undefined &&\n      AssistantEvent.isLibraryEvent(message) &&\n      Predicate.isTagged(message, \"AssistantMessage\")\n      ? [`- message ${messageId}, a ${message.block?.kind} block: ${message.text}`]\n      : []\n  })\n\n  const specialists = [...AssistantActivity.fromEntries(entries).specialists.values()].flatMap((run) =>\n    opened(\n      seqOf(\n        (event) =>\n          AssistantEvent.isLibraryEvent(event) &&\n          Predicate.isTagged(event, \"SpecialistStarted\") &&\n          event.runId === run.runId\n      )\n    )\n      ? [`- your ${run.specialist} specialist (${run.runId}), working on: ${run.goal}`]\n      : []\n  )\n\n  const sections = [\n    decisions.length > 0 ? `Decisions waiting for the user:\\n${decisions.join(\"\\n\")}` : \"\",\n    blocks.length > 0 ? `Blocks the user hasn't answered:\\n${blocks.join(\"\\n\")}` : \"\",\n    specialists.length > 0 ? `Specialists still working:\\n${specialists.join(\"\\n\")}` : \"\"\n  ].filter((section) => section.length > 0)\n\n  return sections.length === 0 ? Option.none() : Option.some(sections.join(\"\\n\\n\"))\n}\n\n/**\n * Returns the files the user attached up to `throughSeq`, as lines of text for the model, or\n * `None` when there are none. A summary may leave out a file's id, which tools need.\n *\n * @category utils\n * @since 0.1.0\n */\nexport const attachedFiles = (\n  entries: ReadonlyArray<AssistantEvent.AnyEntry>,\n  throughSeq: number\n): Option.Option<string> => {\n  const lines = entries.flatMap(({ seq, event }) =>\n    seq <= throughSeq && AssistantEvent.isLibraryEvent(event) && Predicate.isTagged(event, \"UserMessage\")\n      ? (event.attachments ?? []).map(AssistantEvent.attachmentLine)\n      : []\n  )\n\n  return lines.length === 0 ? Option.none() : Option.some(lines.join(\"\\n\"))\n}\n\n/**\n * Creates a history view that starts at the last summary.\n *\n * **Details**\n *\n * `isSummary` identifies the app's summary events. The model reads the last summary, the files\n * attached earlier ({@link attachedFiles}), and the items that are still open\n * ({@link openItems}), followed by the entries after the summary. When the chat has no summary,\n * the view returns every entry.\n *\n * **Example** (Compacting a long chat after each turn)\n *\n * ```ts\n * import { AppEvent, Assistant, type AssistantEvent, Compaction } from \"effect-assistant\"\n * import * as LanguageModel from \"effect/ai/LanguageModel\"\n * import * as Effect from \"effect/Effect\"\n * import * as Schema from \"effect/Schema\"\n * import * as Stream from \"effect/Stream\"\n *\n * class Summary extends Schema.TaggedClass<Summary>()(\"Summary\", {\n *   text: Schema.String,\n *   throughSeq: Schema.Int\n * }) {}\n *\n * declare const transcript: (entries: ReadonlyArray<AssistantEvent.AnyEntry>) => string\n *\n * export const MyAssistant = Assistant.make(\"my-assistant\", { events: [AppEvent.make(Summary)] })\n *\n * const MyAssistantLive = MyAssistant.toLayer((turn) => {\n *   const compact = Effect.gen(function* () {\n *     const chat = yield* MyAssistant.Chat\n *     const entries = yield* chat.entries\n *\n *     if (Compaction.inputTokens(entries) < 100_000) return\n *\n *     const { text } = yield* LanguageModel.generateText({\n *       prompt: `Summarize this chat:\\n\\n${transcript(entries)}`\n *     })\n *\n *     yield* chat.append(Summary.make({ text, throughSeq: entries.at(-1)?.seq ?? 0 }))\n *   })\n *\n *   // After the reply, so the user doesn't wait for the summary.\n *   return Stream.concat(\n *     turn.loop({ instructions: \"Be brief.\", history: Compaction.since(Schema.is(Summary)) }),\n *     Stream.drain(Stream.fromEffect(compact))\n *   )\n * })\n * ```\n *\n * @category utils\n * @since 0.1.0\n */\nexport const since =\n  (isSummary: (event: unknown) => event is Summary) =>\n  <Events extends { readonly _tag: string }>(\n    entries: ReadonlyArray<Assistant.Entry<Events>>\n  ): ReadonlyArray<Assistant.Entry<Events> | Prompt.Message> => {\n    const last = entries.findLast(({ event }) => isSummary(event))?.event\n\n    if (last === undefined || !isSummary(last)) return entries\n\n    const open = Option.match(openItems(entries, last.throughSeq), {\n      onNone: () => \"\",\n      onSome: (items) => `\\n\\n<still_open>\\n${items}\\n</still_open>`\n    })\n\n    const files = Option.match(attachedFiles(entries, last.throughSeq), {\n      onNone: () => \"\",\n      onSome: (lines) => `\\n\\n<files_attached_earlier>\\n${lines}\\n</files_attached_earlier>`\n    })\n\n    return [\n      userText(`<earlier_in_this_chat>\\n${last.text}\\n</earlier_in_this_chat>${files}${open}`),\n      ...entries.filter(({ seq, event }) => seq > last.throughSeq && !isSummary(event))\n    ]\n  }\n"],"mappings":"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"}

package/dist/CurrentChat.d.ts

@@ -0,0 +1,40 @@
+import { ChatId } from "./ChatId.js";
+import { AnyEntry, AssistantEvent_d_exports } from "./AssistantEvent.js";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+declare namespace CurrentChat_d_exports {
+  export { CurrentChat };
+}
+declare const CurrentChat_base: Context.ServiceClass<CurrentChat, "effect-assistant/CurrentChat", {
+  readonly chatId: ChatId;
+  /**
+   * The chat's entries so far, in order. They include the library's events and the assistant's
+   * own events, decoded; check for these with `Schema.is(MyEvent)` or `instanceof`. An app event
+   * that no longer decodes is left out.
+   */
+  readonly entries: Effect.Effect<ReadonlyArray<AnyEntry>>;
+  /**
+   * Appends events after the chat's last entry and sends them to the chat's subscribers. The
+   * events can be the library's or the assistant's own (registered with its `events` option),
+   * such as a summary. An event that wakes a turn is handled by the next turn.
+   */
+  readonly append: (...events: ReadonlyArray<{
+    readonly _tag: string;
+  }>) => Effect.Effect<void>;
+}>;
+/**
+ * Service that represents the chat the current code runs in.
+ *
+ * **Details**
+ *
+ * In a turn, it is the chat the turn runs in. In a specialist's run, and in its handler's build,
+ * it is the chat the run belongs to: the chat of the turn that spawned the run. A run's tools
+ * read and append to that chat.
+ *
+ * @category services
+ * @since 0.1.0
+ */
+export declare class CurrentChat extends CurrentChat_base {}
+//#endregion
+export { CurrentChat_d_exports };
+//# sourceMappingURL=CurrentChat.d.ts.map

package/dist/CurrentChat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CurrentChat.d.ts","names":[],"sources":["../src/CurrentChat.ts"],"mappings":";;;;;;;;WAgCqB,QAAA;;;;;;WAMC,SAAA,OAAO,OAAO,cAAc;;;;;;WAM7B,YAAI,QAAQ;aAAyB;SAAoB,OAAO;;;;;;;;;;;;;;qBAfxE,oBAAoB"}

package/dist/CurrentChat.js

@@ -0,0 +1,33 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import * as Context from "effect/Context";
+//#region src/CurrentChat.ts
+/**
+* This module provides the `CurrentChat` service, which gives code that runs inside a chat
+* access to that chat: its id, its entries, and a way to append to it.
+*
+* A turn's handler, its tools, and its specialists' runs get the chat with `yield* CurrentChat`.
+* Inside a specialist's run, it is the chat the run belongs to, which is the chat of the turn
+* that spawned the run. The service doesn't carry an assistant's event types, so code that
+* doesn't know the assistant, such as a shared tool, can use it. Code that knows the assistant
+* can use `MyAssistant.Chat`, which is the same chat typed with the assistant's events.
+*
+* @since 0.1.0
+*/
+var CurrentChat_exports = /* @__PURE__ */ __exportAll({ CurrentChat: () => CurrentChat });
+/**
+* Service that represents the chat the current code runs in.
+*
+* **Details**
+*
+* In a turn, it is the chat the turn runs in. In a specialist's run, and in its handler's build,
+* it is the chat the run belongs to: the chat of the turn that spawned the run. A run's tools
+* read and append to that chat.
+*
+* @category services
+* @since 0.1.0
+*/
+var CurrentChat = class extends Context.Service()("effect-assistant/CurrentChat") {};
+//#endregion
+export { CurrentChat, CurrentChat_exports };
+
+//# sourceMappingURL=CurrentChat.js.map

package/dist/CurrentChat.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CurrentChat.js","names":[],"sources":["../src/CurrentChat.ts"],"sourcesContent":["/**\n * This module provides the `CurrentChat` service, which gives code that runs inside a chat\n * access to that chat: its id, its entries, and a way to append to it.\n *\n * A turn's handler, its tools, and its specialists' runs get the chat with `yield* CurrentChat`.\n * Inside a specialist's run, it is the chat the run belongs to, which is the chat of the turn\n * that spawned the run. The service doesn't carry an assistant's event types, so code that\n * doesn't know the assistant, such as a shared tool, can use it. Code that knows the assistant\n * can use `MyAssistant.Chat`, which is the same chat typed with the assistant's events.\n *\n * @since 0.1.0\n */\nimport * as Context from \"effect/Context\"\nimport type * as Effect from \"effect/Effect\"\nimport type * as AssistantEvent from \"./AssistantEvent.ts\"\nimport type { ChatId } from \"./ChatId.ts\"\n\n/**\n * Service that represents the chat the current code runs in.\n *\n * **Details**\n *\n * In a turn, it is the chat the turn runs in. In a specialist's run, and in its handler's build,\n * it is the chat the run belongs to: the chat of the turn that spawned the run. A run's tools\n * read and append to that chat.\n *\n * @category services\n * @since 0.1.0\n */\nexport class CurrentChat extends Context.Service<\n  CurrentChat,\n  {\n    readonly chatId: ChatId\n    /**\n     * The chat's entries so far, in order. They include the library's events and the assistant's\n     * own events, decoded; check for these with `Schema.is(MyEvent)` or `instanceof`. An app event\n     * that no longer decodes is left out.\n     */\n    readonly entries: Effect.Effect<ReadonlyArray<AssistantEvent.AnyEntry>>\n    /**\n     * Appends events after the chat's last entry and sends them to the chat's subscribers. The\n     * events can be the library's or the assistant's own (registered with its `events` option),\n     * such as a summary. An event that wakes a turn is handled by the next turn.\n     */\n    readonly append: (...events: ReadonlyArray<{ readonly _tag: string }>) => Effect.Effect<void>\n  }\n>()(\"effect-assistant/CurrentChat\") {}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,IAAa,cAAb,cAAiC,QAAQ,QAiBvC,CAAC,CAAC,8BAA8B,CAAC,CAAC,CAAC"}

package/dist/Decision.d.ts

@@ -0,0 +1,145 @@
+import { AnyEntry, AssistantEvent_d_exports, DecisionOutcome, DecisionRequested, ToolResult } from "./AssistantEvent.js";
+import { Block, Block_d_exports } from "./Block.js";
+import { InputId } from "./InputId.js";
+import * as Schema from "effect/Schema";
+declare namespace Decision_d_exports {
+  export { Answer, Props, State, answerAll, apply, block, fromEntries, kind };
+}
+/**
+ * The kind of the decision block.
+ *
+ * @category utils
+ * @since 0.1.0
+ */
+export declare const kind = "decision";
+/**
+ * Schema for the decision block's props, which list the decisions it asks for and, optionally,
+ * its buttons' labels.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare const Props: Schema.Struct<{
+  readonly decisionIds: Schema.$Array<Schema.String>;
+  readonly approveLabel: Schema.optional<Schema.String>;
+  readonly declineLabel: Schema.optional<Schema.String>;
+}>;
+/**
+ * Represents the decision block's props.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type Props = typeof Props.Type;
+/**
+ * Schema for the decision block's answer, which holds an outcome for every decision the block
+ * asks for, by id.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare const Answer: Schema.Struct<{
+  readonly decisions: Schema.$Record<Schema.String, Schema.Literals<readonly ["approved", "declined"]>>;
+}>;
+/**
+ * Represents the decision block's answer.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type Answer = typeof Answer.Type;
+/**
+ * Block with approve and decline buttons for the decisions waiting for the user.
+ *
+ * **Details**
+ *
+ * Put it in the assistant's `BlockKit`. An assistant with a tool that needs a decision must have
+ * it. The client renders it like any other block, with the calls from {@link fromEntries} (their
+ * tool and params).
+ *
+ * **Example** (Asking the user before placing an order)
+ *
+ * ```ts
+ * import { Assistant, BlockKit, Decision } from "effect-assistant"
+ * import * as Tool from "effect/ai/Tool"
+ * import * as Toolkit from "effect/ai/Toolkit"
+ * import * as Effect from "effect/Effect"
+ * import * as Layer from "effect/Layer"
+ * import * as Schema from "effect/Schema"
+ *
+ * export const Shop = Assistant.make("shop", { blocks: BlockKit.make([Decision.block]) })
+ *
+ * const OrderTools = Toolkit.make(
+ *   Tool.make("place_order", {
+ *     description: "Places an order.",
+ *     parameters: Schema.Struct({ sku: Schema.String, quantity: Schema.Int }),
+ *     success: Schema.Struct({ reference: Schema.String }),
+ *     needsApproval: true
+ *   })
+ * )
+ *
+ * const OrderToolsLive = OrderTools.toLayer({
+ *   place_order: () => Effect.succeed({ reference: "R-1042" })
+ * })
+ *
+ * // The call waits until the user answers the decision block.
+ * const ShopLive = Shop.toLayer((turn) =>
+ *   turn.loop({ instructions: "You place orders for the team.", toolkit: OrderTools })
+ * ).pipe(Layer.provide(OrderToolsLive))
+ * ```
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export declare const block: Block<"decision", Schema.Struct<{
+  readonly decisionIds: Schema.$Array<Schema.String>;
+  readonly approveLabel: Schema.optional<Schema.String>;
+  readonly declineLabel: Schema.optional<Schema.String>;
+}>, Schema.Struct<{
+  readonly decisions: Schema.$Record<Schema.String, Schema.Literals<readonly ["approved", "declined"]>>;
+}>>;
+/**
+ * Creates an answer that gives every decision the block asks for the same outcome.
+ *
+ * This is what an "Approve" or "Decline" button sends.
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export declare const answerAll: (props: Props, outcome: DecisionOutcome) => Answer;
+/**
+ * Represents the state of a decision.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export interface State {
+  readonly request: DecisionRequested;
+  /** How the user decided, or `undefined` while the decision waits. */
+  readonly outcome: DecisionOutcome | undefined;
+  /** The id of the answer that decided it. */
+  readonly answer: InputId | undefined;
+  /** Whether its `DecisionResolved` is stored. A workflow's decision has been passed on by then. */
+  readonly resolved: boolean;
+  /** The approved call's result, once the call has run. */
+  readonly result: ToolResult | undefined;
+}
+/**
+ * Returns the decision states after one more event.
+ *
+ * @category utils
+ * @since 0.1.0
+ */
+export declare const apply: (states: ReadonlyMap<string, State>, event: {
+  readonly _tag: string;
+}) => ReadonlyMap<string, State>;
+/**
+ * Returns every decision in the log and where it stands, by id.
+ *
+ * @category utils
+ * @since 0.1.0
+ */
+export declare const fromEntries: (entries: ReadonlyArray<AnyEntry>) => ReadonlyMap<string, State>;
+//#endregion
+export { Decision_d_exports };
+//# sourceMappingURL=Decision.d.ts.map

package/dist/Decision.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Decision.d.ts","names":[],"sources":["../src/Decision.ts"],"mappings":";;;;;;;;;;;;;qBAyBa;;;;;;;;qBASA,OAAK,OAAA;;;;;;;;;;;YAqBN,eAAe,MAAM;;;;;;;;qBASpB,QAAM,OAAA;;;;;;;;;YAUP,gBAAgB,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA6CtB,OAAK,kBAAA,OAAA;;;;;;;;;;;;;;;qBAeL,YAAS,OAAW,OAAK,SAAW,oBAAiC;;;;;;;iBAUjE;WACN,SAAS;;WAET,SAAS;;WAET,QAAQ;;WAER;;WAEA,QAAQ;;;;;;;;qBAWN,QAAK,QACR,oBAAoB,QAAM;WAChB;MACjB,oBAAoB;;;;;;;qBAmEV,cAAW,SAAa,cAAc,cAA2B,oBAAoB"}