effect-assistant 0.0.0-stage → 0.2.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: 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":";;;;;;;;;;;;;;;;iBA8BiB;WACN;WACA;WACA;;;;;;;;;qBAUE,cAAW,SAAa,cAAc;;;;;;;;;qBAmBtC,YAAS,SACX,cAAc,WAAwB,uBAE9C,OAAO;;;;;;;;qBAoDG,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,126 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import { attachmentLine, isLibraryEvent } from "./AssistantEvent.js";
+import { userText } from "./internal/history.js";
+import { fromEntries } from "./AssistantActivity.js";
+import { fromEntries as fromEntries$1 } from "./BlockKit.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: 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 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(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 = [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","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 { userText } from \"./internal/history.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: blocks the user hasn't\n * 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 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    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/InputId.d.ts

@@ -0,0 +1,38 @@
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+declare namespace InputId_d_exports {
+  export { InputId, fromKey, make };
+}
+/**
+ * Schema for input ids. Any string is a valid input id, and the schema brands it.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare const InputId: Schema.brand<Schema.String, "~effect-assistant/InputId">;
+/**
+ * Represents an input id.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type InputId = typeof InputId.Type;
+/**
+ * Creates a new random input id using Effect's `Random`. Seed `Random` in tests to get the same ids
+ * on every run.
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export declare const make: () => Effect.Effect<InputId>;
+/**
+ * Creates the input id for a key, such as `${runId}:order_placed`. The same key always gives the
+ * same id, so an input that is sent again is stored only once.
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export declare const fromKey: (key: string) => InputId;
+//#endregion
+export { InputId_d_exports };
+//# sourceMappingURL=InputId.d.ts.map

package/dist/InputId.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InputId.d.ts","names":[],"sources":["../src/InputId.ts"],"mappings":";;;;;;;;;;;qBAgBa,SAAO,OAAA,MAAA,OAAA;;;;;;;YAQR,iBAAiB,QAAQ;;;;;;;;qBASxB,YAAW,OAAO,OAAO;;;;;;;;qBASzB,UAAO,gBAAkB"}

package/dist/InputId.js

@@ -0,0 +1,43 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import { make as make$1 } from "./internal/uuid.js";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+//#region src/InputId.ts
+/**
+* This module provides the id of an input to an assistant. An input is a user message, a block
+* answer, or one of the app's events, and the id is stored in its `id` field.
+*
+* @since 0.1.0
+*/
+var InputId_exports = /* @__PURE__ */ __exportAll({
+	InputId: () => InputId,
+	fromKey: () => fromKey,
+	make: () => make
+});
+/**
+* Schema for input ids. Any string is a valid input id, and the schema brands it.
+*
+* @category schemas
+* @since 0.1.0
+*/
+const InputId = Schema.String.pipe(Schema.brand("~effect-assistant/InputId"));
+/**
+* Creates a new random input id using Effect's `Random`. Seed `Random` in tests to get the same ids
+* on every run.
+*
+* @category constructors
+* @since 0.1.0
+*/
+const make = () => Effect.map(make$1, (uuid) => InputId.make(uuid));
+/**
+* Creates the input id for a key, such as `${runId}:order_placed`. The same key always gives the
+* same id, so an input that is sent again is stored only once.
+*
+* @category constructors
+* @since 0.1.0
+*/
+const fromKey = (key) => InputId.make(key);
+//#endregion
+export { InputId, InputId_exports, fromKey, make };
+
+//# sourceMappingURL=InputId.js.map

package/dist/InputId.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"InputId.js","names":["Uuid.make"],"sources":["../src/InputId.ts"],"sourcesContent":["/**\n * This module provides the id of an input to an assistant. An input is a user message, a block\n * answer, or one of the app's events, and the id is stored in its `id` field.\n *\n * @since 0.1.0\n */\nimport * as Effect from \"effect/Effect\"\nimport * as Schema from \"effect/Schema\"\nimport * as Uuid from \"./internal/uuid.ts\"\n\n/**\n * Schema for input ids. Any string is a valid input id, and the schema brands it.\n *\n * @category schemas\n * @since 0.1.0\n */\nexport const InputId = Schema.String.pipe(Schema.brand(\"~effect-assistant/InputId\"))\n\n/**\n * Represents an input id.\n *\n * @category models\n * @since 0.1.0\n */\nexport type InputId = typeof InputId.Type\n\n/**\n * Creates a new random input id using Effect's `Random`. Seed `Random` in tests to get the same ids\n * on every run.\n *\n * @category constructors\n * @since 0.1.0\n */\nexport const make = (): Effect.Effect<InputId> => Effect.map(Uuid.make, (uuid) => InputId.make(uuid))\n\n/**\n * Creates the input id for a key, such as `${runId}:order_placed`. The same key always gives the\n * same id, so an input that is sent again is stored only once.\n *\n * @category constructors\n * @since 0.1.0\n */\nexport const fromKey = (key: string): InputId => InputId.make(key)\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAgBA,MAAa,UAAU,OAAO,OAAO,KAAK,OAAO,MAAM,2BAA2B,CAAC;;;;;;;;AAiBnF,MAAa,aAAqC,OAAO,IAAIA,SAAY,SAAS,QAAQ,KAAK,IAAI,CAAC;;;;;;;;AASpG,MAAa,WAAW,QAAyB,QAAQ,KAAK,GAAG"}

package/dist/Instructions.d.ts

@@ -0,0 +1,56 @@
+import * as Effect from "effect/Effect";
+declare namespace Instructions_d_exports {
+  export { Instructions, Resolved, SpanAttributes, protocol, resolve };
+}
+/**
+ * The text the model has to know for a turn's loop to work.
+ *
+ * **Details**
+ *
+ * It tells the model that every step is a tool call, that `wait` (or a last message with
+ * `wait: true`) ends the turn, that the user sees only what it sends with `send_user_message`, and
+ * that messages can arrive mid-turn. The rest, such as what a `<specialist>` block or an app's
+ * event is, is in the tools' descriptions and in the history itself.
+ *
+ * `turn.instructions(text)` puts it before the text, and a custom loop on `AssistantLoop.run` can
+ * use it too.
+ *
+ * @category utils
+ * @since 0.1.0
+ */
+export declare const protocol = "Every step is a tool call. When you have nothing more to do right now, end your turn: set wait to true on your last send_user_message, or call wait if you have nothing to say.\nThe user sees only the text of what you send with send_user_message: anything else you write is never shown, so put the whole answer in the message, not next to it.\nMessages and updates can arrive while you work: handle the newest one, and don't repeat what you already told the user.";
+/**
+ * Represents the span attributes added to every model call made with a prompt.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type SpanAttributes = Readonly<Record<string, string | number | boolean>>;
+/**
+ * Represents instructions resolved to text, with the span attributes to record them under.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export interface Resolved {
+  readonly text: string;
+  readonly attributes?: SpanAttributes | undefined;
+}
+/**
+ * Represents instructions as text, or as an Effect that produces the text (optionally with span
+ * attributes).
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type Instructions<R = never> = string | Effect.Effect<string | Resolved, never, R>;
+/**
+ * Resolves instructions to their text and span attributes.
+ *
+ * @category utils
+ * @since 0.1.0
+ */
+export declare const resolve: <R = never>(instructions: Instructions<R>) => Effect.Effect<Resolved, never, R>;
+//#endregion
+export { Instructions_d_exports };
+//# sourceMappingURL=Instructions.d.ts.map

package/dist/Instructions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Instructions.d.ts","names":[],"sources":["../src/Instructions.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;qBA4Ba;;;;;;;YAUD,iBAAiB,SAAS;;;;;;;iBAQrB;WACN;WACA,aAAa;;;;;;;;;YAUZ,aAAa,sBAAsB,OAAO,gBAAgB,iBAAiB;;;;;;;qBAQ1E,UAAuD,WAAC,cAAA,aAAA,OAAA,OAAA,OAAA,iBAAA"}

package/dist/Instructions.js

@@ -0,0 +1,50 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import * as Predicate from "effect/Predicate";
+import * as Effect from "effect/Effect";
+//#region src/Instructions.ts
+/**
+* Defines the instructions that tell an assistant, specialist, or skill what to do.
+*
+* Instructions are text, or an Effect that produces text, optionally with span attributes
+* (a {@link Resolved}). {@link resolve} turns them into a `Resolved`, and {@link protocol} is the
+* text a turn's loop needs the model to know.
+*
+* @since 0.1.0
+*/
+var Instructions_exports = /* @__PURE__ */ __exportAll({
+	protocol: () => protocol,
+	resolve: () => resolve
+});
+/**
+* The text the model has to know for a turn's loop to work.
+*
+* **Details**
+*
+* It tells the model that every step is a tool call, that `wait` (or a last message with
+* `wait: true`) ends the turn, that the user sees only what it sends with `send_user_message`, and
+* that messages can arrive mid-turn. The rest, such as what a `<specialist>` block or an app's
+* event is, is in the tools' descriptions and in the history itself.
+*
+* `turn.instructions(text)` puts it before the text, and a custom loop on `AssistantLoop.run` can
+* use it too.
+*
+* @category utils
+* @since 0.1.0
+*/
+const protocol = `Every step is a tool call. When you have nothing more to do right now, end your turn: set wait to true on your last send_user_message, or call wait if you have nothing to say.
+The user sees only the text of what you send with send_user_message: anything else you write is never shown, so put the whole answer in the message, not next to it.
+Messages and updates can arrive while you work: handle the newest one, and don't repeat what you already told the user.`;
+/**
+* Resolves instructions to their text and span attributes.
+*
+* @category utils
+* @since 0.1.0
+*/
+const resolve = Effect.fn("Instructions.resolve")(function* (instructions) {
+	return Predicate.isString(instructions) ? { text: instructions } : toResolved(yield* instructions);
+});
+const toResolved = (resolved) => Predicate.isString(resolved) ? { text: resolved } : resolved;
+//#endregion
+export { Instructions_exports, protocol, resolve };
+
+//# sourceMappingURL=Instructions.js.map