effect-assistant 0.1.0 → 0.3.0

package/dist/Timeline.js

@@ -0,0 +1,572 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import { InputId } from "./InputId.js";
+import { Attachment, isLibraryEvent } from "./AssistantEvent.js";
+import { decodeWith, tagOf } from "./internal/events.js";
+import { toJson } from "./internal/schema.js";
+import { apply as apply$1, empty as empty$1 } from "./AssistantActivity.js";
+import { apply as apply$2 } from "./BlockKit.js";
+import * as Schema from "effect/Schema";
+import * as Stream from "effect/Stream";
+import * as Option from "effect/Option";
+import * as Match from "effect/Match";
+import { dual } from "effect/Function";
+import * as SchemaTransformation from "effect/SchemaTransformation";
+//#region src/Timeline.ts
+/**
+* This module provides a chat's timeline: the chat as its user sees it. A chat client receives the
+* timeline and nothing else.
+*
+* A {@link Timeline} holds the chat's items: the messages with their blocks, and the app's own
+* events it shows (each typed with its event, see {@link EventItem}). It also holds the chat's
+* {@link Activity}, and whether the last turn failed or the chat was deleted. It never contains the
+* model's output, tool calls or results, what the model read, or why a turn failed. The server
+* streams {@link Change}s by piping the assistant's `subscribe` through {@link changes}, and the
+* client folds them with {@link fold} (or {@link apply}, from {@link empty}). On the server,
+* {@link fromEntries} builds a whole timeline from a chat's log, and {@link snapshot} the whole
+* timeline as one change.
+*
+* **Only the app events in `show` reach the timeline**, and none by default: an event that is only
+* for the assistant, like a summary of the chat, stays out. The RPC's schema, `Change([...])`,
+* names the same events and types the client's timeline with them.
+*
+* @since 0.3.0
+*/
+var Timeline_exports = /* @__PURE__ */ __exportAll({
+	Activity: () => Activity,
+	AssistantMessage: () => AssistantMessage,
+	Block: () => Block,
+	BlockStatus: () => BlockStatus,
+	Change: () => Change,
+	SpecialistWorking: () => SpecialistWorking,
+	UserMessage: () => UserMessage,
+	apply: () => apply,
+	changes: () => changes,
+	empty: () => empty,
+	fold: () => fold,
+	fromEntries: () => fromEntries,
+	isIdle: () => isIdle,
+	snapshot: () => snapshot
+});
+/**
+* Schema for the status of a block. A block is `"open"` while it accepts an answer, `"answered"`
+* once the user has used it, and `"closed"` when it closed without an answer because the user
+* answered in words or moved on.
+*
+* @category schemas
+* @since 0.1.0
+*/
+const BlockStatus = Schema.Literals([
+	"open",
+	"answered",
+	"closed"
+]);
+/**
+* Schema for a block on an assistant's message. It holds the block's kind, its props (JSON, as
+* the block's props schema encodes them), its status, and the user's answer (JSON, as the block's
+* answer schema encodes it).
+*
+* @category schemas
+* @since 0.1.0
+*/
+const Block = Schema.Struct({
+	kind: Schema.String,
+	props: Schema.Json,
+	status: BlockStatus,
+	answer: Schema.optional(Schema.Json)
+});
+/**
+* Schema for a message the user sent. `at` is when it was stored, in epoch
+* milliseconds.
+*
+* @category schemas
+* @since 0.1.0
+*/
+const UserMessage = Schema.TaggedStruct("UserMessage", {
+	id: InputId,
+	text: Schema.String,
+	attachments: Schema.optional(Schema.Array(Attachment)),
+	at: Schema.Finite
+});
+/**
+* Schema for a message the assistant sent the user, including its block if it has one.
+*
+* @category schemas
+* @since 0.1.0
+*/
+const AssistantMessage = Schema.TaggedStruct("AssistantMessage", {
+	id: Schema.String,
+	text: Schema.String,
+	at: Schema.Finite,
+	block: Schema.optional(Block)
+});
+/**
+* Schema for a specialist that is working for the assistant. It holds the specialist's name and
+* when it started, in epoch milliseconds.
+*
+* @category schemas
+* @since 0.1.0
+*/
+const SpecialistWorking = Schema.Struct({
+	specialist: Schema.String,
+	since: Schema.Finite
+});
+/**
+* Schema for what is working in the chat.
+*
+* `working` is true while the assistant runs a turn, or when a turn is about to start for
+* something that arrived. `specialists` lists the specialists that are working. When the chat is
+* idle, nothing is working, even if a workflow is waiting on a timer or on the user.
+*
+* @category schemas
+* @since 0.1.0
+*/
+const Activity = Schema.Struct({
+	working: Schema.Boolean,
+	specialists: Schema.Array(SpecialistWorking)
+});
+const eventItem = (schema) => Schema.Struct({
+	_tag: Schema.Literal(tagOf(schema)),
+	id: Schema.String,
+	at: Schema.Finite,
+	event: schema
+});
+function makeChange(events = []) {
+	const AnyItem = Schema.toCodecJson(Schema.Union([
+		UserMessage,
+		AssistantMessage,
+		...events.map(eventItem)
+	]));
+	const decodeItem = Schema.decodeUnknownOption(AnyItem);
+	const encodeItem = Schema.encodeUnknownSync(AnyItem);
+	return Schema.Struct({
+		seq: Schema.Int,
+		items: Schema.Array(Schema.Json).pipe(Schema.decodeTo(Schema.Array(Schema.toType(AnyItem)), SchemaTransformation.transform({
+			decode: (json) => json.flatMap((item) => Option.toArray(decodeItem(item))),
+			encode: (items) => items.map((item) => encodeItem(item))
+		}))),
+		activity: Activity,
+		failed: Schema.Boolean,
+		deleted: Schema.Boolean
+	});
+}
+/**
+* Creates the schema for the changes to a chat's timeline, with items for the given app events,
+* in JSON.
+*
+* **Details**
+*
+* It is the success schema of the RPC that streams a chat's timeline: name the events the chat's
+* users see, the same ones the handler passes to {@link changes} as `show`. Each item decodes its
+* event with that event's schema, so the client gets `Change<Events>` typed with them and folds it
+* with {@link fold}, no definition needed. `Change()` carries no app events.
+*
+* A handler whose changes show an event the schema doesn't name doesn't compile.
+*
+* **Example** (An RPC that streams a chat's timeline, with the budget notice)
+*
+* ```ts
+* import { ChatId, Timeline } from "effect-assistant"
+* import * as Rpc from "effect/rpc/Rpc"
+* import * as Schema from "effect/Schema"
+*
+* class DailyBudgetReached extends Schema.TaggedClass<DailyBudgetReached>()("DailyBudgetReached", {}) {}
+*
+* const Subscribe = Rpc.make("Subscribe", {
+*   payload: { chatId: ChatId.ChatId },
+*   success: Timeline.Change([DailyBudgetReached]),
+*   stream: true
+* })
+* ```
+*
+* @category schemas
+* @since 0.3.0
+*/
+const Change = makeChange;
+/**
+* The timeline of a chat before anything has happened in it, with no items and nothing working.
+* Use it as the starting point when folding changes with {@link apply}.
+*
+* @category constructors
+* @since 0.1.0
+*/
+const empty = {
+	seq: 0,
+	items: [],
+	activity: {
+		working: false,
+		specialists: []
+	},
+	failed: false,
+	deleted: false
+};
+/**
+* Returns the timeline after a change.
+*
+* **Details**
+*
+* Each item in the change replaces the item with the same id, in place, and new items are added
+* after the rest. The change's activity, `failed`, and `deleted` replace the timeline's. Applying a
+* change twice changes nothing, so a client that resubscribes from the start can fold again and get
+* the same timeline.
+*
+* The timeline is typed with the change's events, as its RPC's schema decoded them (see
+* {@link Change}). To fold a stream of changes, use {@link fold}: in
+* `Stream.scan(() => Timeline.empty, Timeline.apply)`, TypeScript fixes the state's type from
+* `empty` before it sees the changes' events, so that form needs the timeline's type written out.
+*
+* **Example** (Folding changes into your own state)
+*
+* ```ts
+* import { Timeline } from "effect-assistant"
+*
+* interface State<Events> {
+*   readonly timeline: Timeline.Timeline<Events>
+*   readonly unread: number
+* }
+*
+* const next = <Events>(state: State<Events>, change: Timeline.Change<Events>): State<Events> => ({
+*   timeline: Timeline.apply(state.timeline, change),
+*   unread: state.unread + change.items.length
+* })
+* ```
+*
+* @category combinators
+* @since 0.1.0
+*/
+const apply = (timeline, change) => {
+	const changed = new Map(change.items.map((item) => [item.id, item]));
+	const known = new Set(timeline.items.map((item) => item.id));
+	return {
+		seq: Math.max(timeline.seq, change.seq),
+		items: [...timeline.items.map((item) => changed.get(item.id) ?? item), ...change.items.filter((item) => !known.has(item.id))],
+		activity: change.activity,
+		failed: change.failed,
+		deleted: change.deleted
+	};
+};
+/**
+* Returns the timelines a stream of changes folds to, from {@link empty}, typed with the changes'
+* events.
+*
+* **Example** (A chat's timeline on the client)
+*
+* ```ts
+* import { Timeline } from "effect-assistant"
+* import * as Schema from "effect/Schema"
+* import * as Stream from "effect/Stream"
+*
+* class DailyBudgetReached extends Schema.TaggedClass<DailyBudgetReached>()("DailyBudgetReached", {}) {}
+*
+* // The stream of an RPC whose success schema is `Timeline.Change([DailyBudgetReached])`.
+* declare const changes: Stream.Stream<Timeline.Change<DailyBudgetReached>>
+*
+* const timelines = changes.pipe(Timeline.fold) // Stream<Timeline.Timeline<DailyBudgetReached>>
+* ```
+*
+* @category combinators
+* @since 0.3.0
+*/
+const fold = (changes) => changes.pipe(Stream.scan(() => empty, apply));
+/**
+* Returns whether nothing is working in the chat: no turn is running or about to start, and no
+* specialist is working.
+*
+* @category guards
+* @since 0.1.0
+*/
+const isIdle = (timeline) => !timeline.activity.working && timeline.activity.specialists.length === 0;
+function snapshotWith(entries, _definition, options) {
+	const timeline = folding(options?.show ?? []);
+	for (const entry of entries) timeline.step(entry);
+	return timeline.snapshot;
+}
+/**
+* Returns a chat's whole timeline as one change, built from the entries of its log.
+*
+* **When to use**
+*
+* Use it on the server for an RPC that returns a whole chat at once: its success schema is
+* {@link Change} with the same events as `show`, and the client applies it to {@link empty}.
+*
+* **Details**
+*
+* Only the app's events in `show` become items; without it, the timeline has none.
+*
+* @category constructors
+* @since 0.3.0
+*/
+const snapshot = snapshotWith;
+function fromEntriesWith(entries, _definition, options) {
+	const timeline = folding(options?.show ?? []);
+	for (const entry of entries) timeline.step(entry);
+	return timeline.snapshot;
+}
+/**
+* Returns a chat's timeline, built from the entries of its log.
+*
+* **When to use**
+*
+* Use it in server-side code that reads a whole chat. A client gets the timeline as a stream from
+* {@link changes} instead, and an RPC that returns a whole chat sends a {@link snapshot}.
+*
+* **Details**
+*
+* Only the app's events in `show` become items, typed with their schemas; without it, the timeline
+* has none.
+*
+* **Example** (Building a chat's timeline from its log)
+*
+* ```ts
+* import { type ChatId, ChatLog, Timeline } from "effect-assistant"
+* import * as Effect from "effect/Effect"
+*
+* const timelineOf = (chatId: ChatId.ChatId) =>
+*   ChatLog.ChatLog.use((log) => log.read(chatId)).pipe(
+*     Effect.map((entries) => Timeline.fromEntries(entries))
+*   )
+* ```
+*
+* @see {@link changes} for a stream of changes instead of a whole timeline
+*
+* @category constructors
+* @since 0.1.0
+*/
+const fromEntries = fromEntriesWith;
+const activityOf = (activity) => ({
+	working: activity.turnSince !== void 0 || activity.queued,
+	specialists: [...activity.specialists.values()].map((run) => ({
+		specialist: run.specialist,
+		since: run.since
+	}))
+});
+const sameActivity = (a, b) => a.working === b.working && a.specialists.length === b.specialists.length && a.specialists.every((run, i) => {
+	const other = b.specialists[i];
+	return other !== void 0 && run.specialist === other.specialist && run.since === other.since;
+});
+const folding = (show) => {
+	const shown = new Map(show.map((schema) => [tagOf(schema), schema]));
+	let seq = 0;
+	let failed = false;
+	let deleted = false;
+	let activity = empty$1;
+	let blocks = /* @__PURE__ */ new Map();
+	const items = /* @__PURE__ */ new Map();
+	const sent = /* @__PURE__ */ new Map();
+	const blockOf = (message) => {
+		if (message.block === void 0) return void 0;
+		const state = blocks.get(message.id);
+		const status = state === void 0 || state.open ? "open" : state.answer === void 0 ? "closed" : "answered";
+		const block = {
+			kind: message.block.kind,
+			props: toJson(message.block.props),
+			status
+		};
+		return state?.answer === void 0 ? block : {
+			...block,
+			answer: toJson(state.answer.value)
+		};
+	};
+	const itemOf = (message, at) => {
+		const block = blockOf(message);
+		return block === void 0 ? AssistantMessage.make({
+			id: message.id,
+			text: message.text,
+			at
+		}) : AssistantMessage.make({
+			id: message.id,
+			text: message.text,
+			at,
+			block
+		});
+	};
+	const touched = (event, at) => Match.value(event).pipe(Match.tagsExhaustive({
+		UserMessage: (message) => {
+			items.set(message.id, message.attachments === void 0 ? UserMessage.make({
+				id: message.id,
+				text: message.text,
+				at
+			}) : UserMessage.make({
+				id: message.id,
+				text: message.text,
+				attachments: message.attachments,
+				at
+			}));
+			failed = false;
+			return [message.id];
+		},
+		AssistantMessage: (message) => {
+			sent.set(message.id, message);
+			items.set(message.id, itemOf(message, at));
+			failed = false;
+			return [message.id, ...message.closes ?? []];
+		},
+		BlockAnswer: (answer) => {
+			failed = false;
+			return [answer.messageId];
+		},
+		BlocksClosed: (closed) => closed.messageIds,
+		TurnFailed: () => {
+			failed = true;
+			return [];
+		},
+		ModelOutput: () => [],
+		ToolStarted: () => [],
+		ToolResult: () => [],
+		TurnStarted: () => [],
+		TurnCompleted: () => [],
+		SpecialistStarted: () => [],
+		SpecialistFinished: () => [],
+		ChatDeleted: () => {
+			deleted = true;
+			return [];
+		}
+	}));
+	const eventItemOf = (entry) => {
+		const schema = shown.get(entry.event._tag);
+		if (schema === void 0) return Option.none();
+		const event = Schema.is(schema)(entry.event) ? Option.some(entry.event) : decodeWith(schema, entry.event);
+		return Option.map(event, (decoded) => ({
+			_tag: decoded._tag,
+			id: `app-event:${entry.seq}`,
+			at: entry.at,
+			event: decoded
+		}));
+	};
+	const step = (entry) => {
+		const before = {
+			activity: activityOf(activity),
+			failed,
+			deleted
+		};
+		const { event } = entry;
+		seq = entry.seq;
+		activity = apply$1(activity, entry);
+		if (!isLibraryEvent(event)) {
+			const now = activityOf(activity);
+			return Option.match(eventItemOf(entry), {
+				onNone: () => sameActivity(before.activity, now) ? void 0 : {
+					seq,
+					items: [],
+					activity: now,
+					failed,
+					deleted
+				},
+				onSome: (item) => {
+					items.set(item.id, item);
+					return {
+						seq,
+						items: [item],
+						activity: now,
+						failed,
+						deleted
+					};
+				}
+			});
+		}
+		blocks = apply$2(blocks, event);
+		const changed = [...new Set(touched(event, entry.at))].flatMap((id) => {
+			const message = sent.get(id);
+			const current = items.get(id);
+			if (message === void 0 || current === void 0) return current === void 0 ? [] : [current];
+			const next = itemOf(message, current.at);
+			items.set(id, next);
+			return [next];
+		});
+		const now = activityOf(activity);
+		return changed.length === 0 && failed === before.failed && deleted === before.deleted && sameActivity(before.activity, now) ? void 0 : {
+			seq,
+			items: changed,
+			activity: now,
+			failed,
+			deleted
+		};
+	};
+	return {
+		step,
+		get snapshot() {
+			return {
+				seq,
+				items: [...items.values()],
+				activity: activityOf(activity),
+				failed,
+				deleted
+			};
+		}
+	};
+};
+const merge = (changes) => {
+	const last = changes.at(-1);
+	if (last === void 0) return void 0;
+	const items = /* @__PURE__ */ new Map();
+	for (const change of changes) for (const item of change.items) items.set(item.id, item);
+	return {
+		seq: last.seq,
+		items: [...items.values()],
+		activity: last.activity,
+		failed: last.failed,
+		deleted: last.deleted
+	};
+};
+function changesWith(entries, _definition, options) {
+	const after = options?.after ?? 0;
+	return entries.pipe(Stream.mapAccumArray(() => folding(options?.show ?? []), (timeline, chunk) => {
+		const changed = chunk.flatMap((entry) => {
+			const change = timeline.step(entry);
+			return change === void 0 || entry.seq <= after ? [] : [change];
+		});
+		const merged = merge(changed);
+		return [timeline, merged === void 0 ? [] : [merged]];
+	}));
+}
+/**
+* Returns the stream of changes to a chat's timeline that its entries produce, for a chat client.
+*
+* **Details**
+*
+* The entries must stream from the start of the chat's log, as `assistant.subscribe(chatId)` does
+* without `after`. The fold reads every entry, because a message depends on earlier entries: its
+* block is answered or closed later. `after` only skips emitting the changes up to that `seq`, so a
+* client that has the timeline up to a `seq` receives only what changed since. Pass `after` here,
+* not to `subscribe`: a subscription that starts after a `seq` gives the fold an incomplete log,
+* and the changes it produces are wrong.
+*
+* Each chunk of entries becomes one change; the stored entries, for example, arrive as one chunk.
+*
+* **Only the app's events in `show` reach the client.** Each one becomes an item between the
+* messages (see {@link EventItem}); the app's other events, like a summary of the chat for the
+* model, are left out. Without `show`, none are shown. The changes are typed with the events shown,
+* so the RPC's success schema names the same ones (`Timeline.Change([...])`), and a handler that
+* shows one the schema doesn't name doesn't compile. A timeline shows a turn as working once it
+* starts, or from the user's input.
+*
+* **Example** (Streaming a chat's timeline to a client, with the one app event its user sees)
+*
+* ```ts
+* import { Assistant, type ChatId, Timeline } from "effect-assistant"
+* 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 }) {}
+* class DailyBudgetReached extends Schema.TaggedClass<DailyBudgetReached>()("DailyBudgetReached", {}) {}
+*
+* const MyAssistant = Assistant.make("my-assistant", { events: [Summary, DailyBudgetReached] })
+*
+* // The summary is for the model: only the budget notice reaches the user.
+* const watch = (chatId: ChatId.ChatId, after: number) =>
+*   Stream.unwrap(
+*     MyAssistant.useSync((assistant) =>
+*       assistant.subscribe(chatId).pipe(Timeline.changes(MyAssistant, { show: [DailyBudgetReached], after }))
+*     )
+*   )
+* ```
+*
+* @see {@link fold} for folding the changes into a timeline on the client
+*
+* @category utils
+* @since 0.3.0
+*/
+const changes = dual((args) => Stream.isStream(args[0]), changesWith);
+//#endregion
+export { Activity, AssistantMessage, Block, BlockStatus, Change, SpecialistWorking, Timeline_exports, UserMessage, apply, changes, empty, fold, fromEntries, isIdle, snapshot };
+
+//# sourceMappingURL=Timeline.js.map

package/dist/Timeline.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Timeline.js","names":["AssistantEvent.Attachment","AppEvents.tagOf","AssistantActivity.empty","AppEvents.decodeWith","AssistantActivity.apply","AssistantEvent.isLibraryEvent","BlockKit.apply"],"sources":["../src/Timeline.ts"],"sourcesContent":["/**\n * This module provides a chat's timeline: the chat as its user sees it. A chat client receives the\n * timeline and nothing else.\n *\n * A {@link Timeline} holds the chat's items: the messages with their blocks, and the app's own\n * events it shows (each typed with its event, see {@link EventItem}). It also holds the chat's\n * {@link Activity}, and whether the last turn failed or the chat was deleted. It never contains the\n * model's output, tool calls or results, what the model read, or why a turn failed. The server\n * streams {@link Change}s by piping the assistant's `subscribe` through {@link changes}, and the\n * client folds them with {@link fold} (or {@link apply}, from {@link empty}). On the server,\n * {@link fromEntries} builds a whole timeline from a chat's log, and {@link snapshot} the whole\n * timeline as one change.\n *\n * **Only the app events in `show` reach the timeline**, and none by default: an event that is only\n * for the assistant, like a summary of the chat, stays out. The RPC's schema, `Change([...])`,\n * names the same events and types the client's timeline with them.\n *\n * @since 0.3.0\n */\nimport { dual } from \"effect/Function\"\nimport * as Match from \"effect/Match\"\nimport * as Option from \"effect/Option\"\nimport * as Schema from \"effect/Schema\"\nimport * as SchemaTransformation from \"effect/SchemaTransformation\"\nimport * as Stream from \"effect/Stream\"\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 { InputId } from \"./InputId.ts\"\nimport * as AppEvents from \"./internal/events.ts\"\nimport { toJson } from \"./internal/schema.ts\"\n\n/**\n * Schema for the status of a block. A block is `\"open\"` while it accepts an answer, `\"answered\"`\n * once the user has used it, and `\"closed\"` when it closed without an answer because the user\n * answered in words or moved on.\n *\n * @category schemas\n * @since 0.1.0\n */\nexport const BlockStatus = Schema.Literals([\"open\", \"answered\", \"closed\"])\n\n/**\n * The status of a block.\n *\n * @category models\n * @since 0.1.0\n */\nexport type BlockStatus = typeof BlockStatus.Type\n\n/**\n * Schema for a block on an assistant's message. It holds the block's kind, its props (JSON, as\n * the block's props schema encodes them), its status, and the user's answer (JSON, as the block's\n * answer schema encodes it).\n *\n * @category schemas\n * @since 0.1.0\n */\nexport const Block = Schema.Struct({\n  kind: Schema.String,\n  props: Schema.Json,\n  status: BlockStatus,\n  answer: Schema.optional(Schema.Json)\n})\n\n/**\n * Represents a block on an assistant's message.\n *\n * @category models\n * @since 0.1.0\n */\nexport type Block = typeof Block.Type\n\n/**\n * Schema for a message the user sent. `at` is when it was stored, in epoch\n * milliseconds.\n *\n * @category schemas\n * @since 0.1.0\n */\nexport const UserMessage = Schema.TaggedStruct(\"UserMessage\", {\n  id: InputId,\n  text: Schema.String,\n  attachments: Schema.optional(Schema.Array(AssistantEvent.Attachment)),\n  at: Schema.Finite\n})\n\n/**\n * Represents a message the user sent.\n *\n * @category models\n * @since 0.1.0\n */\nexport type UserMessage = typeof UserMessage.Type\n\n/**\n * Schema for a message the assistant sent the user, including its block if it has one.\n *\n * @category schemas\n * @since 0.1.0\n */\nexport const AssistantMessage = Schema.TaggedStruct(\"AssistantMessage\", {\n  id: Schema.String,\n  text: Schema.String,\n  at: Schema.Finite,\n  block: Schema.optional(Block)\n})\n\n/**\n * Represents a message the assistant sent the user.\n *\n * @category models\n * @since 0.1.0\n */\nexport type AssistantMessage = typeof AssistantMessage.Type\n\n/**\n * Represents one of the app's own events in the timeline: an item between the messages, in the\n * order the chat stored it.\n *\n * **Details**\n *\n * The item's `_tag` is the event's, so a match over a timeline's items takes a handler per event\n * beside `UserMessage` and `AssistantMessage`. The event, decoded with its schema, is in `event`,\n * and the item's own fields sit beside it rather than spread into it: an event may have an `id` or\n * an `at` of its own, and a class instance keeps its prototype. `id` is fixed per entry of the\n * chat's log, and `at` is when the event was stored, in epoch milliseconds.\n *\n * @category models\n * @since 0.3.0\n */\nexport type EventItem<E> = E extends { readonly _tag: infer Tag extends string }\n  ? { readonly _tag: Tag; readonly id: string; readonly at: number; readonly event: E }\n  : never\n\n/**\n * Represents an item in the chat's timeline: a message the user or the assistant sent, or one of\n * the app's own events it shows (see {@link EventItem}).\n *\n * **Example** (Showing each item of a chat)\n *\n * ```ts\n * import { Timeline } from \"effect-assistant\"\n * import * as Match from \"effect/Match\"\n * import * as Schema from \"effect/Schema\"\n *\n * class DailyBudgetReached extends Schema.TaggedClass<DailyBudgetReached>()(\"DailyBudgetReached\", {}) {}\n *\n * const line = (item: Timeline.Item<DailyBudgetReached>) =>\n *   Match.valueTags(item, {\n *     UserMessage: (sent) => `You: ${sent.text}`,\n *     AssistantMessage: (sent) => `Assistant: ${sent.text}`,\n *     DailyBudgetReached: () => \"You've reached today's budget.\"\n *   })\n * ```\n *\n * @category models\n * @since 0.3.0\n */\nexport type Item<Events = never> = UserMessage | AssistantMessage | EventItem<Events>\n\n/**\n * Schema for a specialist that is working for the assistant. It holds the specialist's name and\n * when it started, in epoch milliseconds.\n *\n * @category schemas\n * @since 0.1.0\n */\nexport const SpecialistWorking = Schema.Struct({\n  specialist: Schema.String,\n  since: Schema.Finite\n})\n\n/**\n * Represents a specialist that is working for the assistant.\n *\n * @category models\n * @since 0.1.0\n */\nexport type SpecialistWorking = typeof SpecialistWorking.Type\n\n/**\n * Schema for what is working in the chat.\n *\n * `working` is true while the assistant runs a turn, or when a turn is about to start for\n * something that arrived. `specialists` lists the specialists that are working. When the chat is\n * idle, nothing is working, even if a workflow is waiting on a timer or on the user.\n *\n * @category schemas\n * @since 0.1.0\n */\nexport const Activity = Schema.Struct({\n  working: Schema.Boolean,\n  specialists: Schema.Array(SpecialistWorking)\n})\n\n/**\n * Represents what is working in the chat.\n *\n * @category models\n * @since 0.1.0\n */\nexport type Activity = typeof Activity.Type\n\n/**\n * Represents a chat's timeline: the chat as its user sees it, typed with the app's events it shows.\n * It holds the chat's items in order, what is working in it, whether the last turn failed, and\n * whether the chat was deleted. `seq` is the position in the chat's log that the timeline is up to.\n *\n * @category models\n * @since 0.3.0\n */\nexport interface Timeline<Events = never> {\n  readonly seq: number\n  readonly items: ReadonlyArray<Item<Events>>\n  readonly activity: Activity\n  /** Whether the last turn failed with no message after it. */\n  readonly failed: boolean\n  /** Whether the chat was deleted. A deleted chat accepts nothing more, and its stream ends. */\n  readonly deleted: boolean\n}\n\n/**\n * Represents a change to a chat's timeline, typed with the app's events it shows.\n *\n * **Details**\n *\n * A change holds each item that is new or changed (for example, a message whose block was\n * answered or closed), in full. It also holds the current activity, whether the last turn failed,\n * and whether the chat was deleted. `seq` is the position in the chat's log that the change is up\n * to.\n *\n * @category models\n * @since 0.3.0\n */\nexport interface Change<Events = never> {\n  readonly seq: number\n  readonly items: ReadonlyArray<Item<Events>>\n  readonly activity: Activity\n  readonly failed: boolean\n  readonly deleted: boolean\n}\n\nconst eventItem = (schema: AssistantEvent.AppEventSchema) =>\n  Schema.Struct({ _tag: Schema.Literal(AppEvents.tagOf(schema)), id: Schema.String, at: Schema.Finite, event: schema })\n\nfunction makeChange<const Events extends ReadonlyArray<AssistantEvent.AppEventSchema> = readonly []>(\n  events?: Events\n): Schema.Codec<Change<Events[number][\"Type\"]>, Schema.Json>\n// The overload states the decoded type: an item per given schema, each typed with its own event.\nfunction makeChange(events: ReadonlyArray<AssistantEvent.AppEventSchema> = []): Schema.Top {\n  const AnyItem = Schema.toCodecJson(Schema.Union([UserMessage, AssistantMessage, ...events.map(eventItem)]))\n  const decodeItem = Schema.decodeUnknownOption(AnyItem)\n  const encodeItem = Schema.encodeUnknownSync(AnyItem)\n\n  return Schema.Struct({\n    seq: Schema.Int,\n    // An item for an event this schema doesn't name, or that doesn't decode (from a newer server, say), is left out\n    // rather than failing the whole change.\n    items: Schema.Array(Schema.Json).pipe(\n      Schema.decodeTo(\n        Schema.Array(Schema.toType(AnyItem)),\n        SchemaTransformation.transform<ReadonlyArray<typeof AnyItem.Type>, ReadonlyArray<Schema.Json>>({\n          decode: (json) => json.flatMap((item) => Option.toArray(decodeItem(item))),\n          encode: (items) => items.map((item) => encodeItem(item))\n        })\n      )\n    ),\n    activity: Activity,\n    failed: Schema.Boolean,\n    deleted: Schema.Boolean\n  })\n}\n\n/**\n * Creates the schema for the changes to a chat's timeline, with items for the given app events,\n * in JSON.\n *\n * **Details**\n *\n * It is the success schema of the RPC that streams a chat's timeline: name the events the chat's\n * users see, the same ones the handler passes to {@link changes} as `show`. Each item decodes its\n * event with that event's schema, so the client gets `Change<Events>` typed with them and folds it\n * with {@link fold}, no definition needed. `Change()` carries no app events.\n *\n * A handler whose changes show an event the schema doesn't name doesn't compile.\n *\n * **Example** (An RPC that streams a chat's timeline, with the budget notice)\n *\n * ```ts\n * import { ChatId, Timeline } from \"effect-assistant\"\n * import * as Rpc from \"effect/rpc/Rpc\"\n * import * as Schema from \"effect/Schema\"\n *\n * class DailyBudgetReached extends Schema.TaggedClass<DailyBudgetReached>()(\"DailyBudgetReached\", {}) {}\n *\n * const Subscribe = Rpc.make(\"Subscribe\", {\n *   payload: { chatId: ChatId.ChatId },\n *   success: Timeline.Change([DailyBudgetReached]),\n *   stream: true\n * })\n * ```\n *\n * @category schemas\n * @since 0.3.0\n */\nexport const Change: <const Events extends ReadonlyArray<AssistantEvent.AppEventSchema> = readonly []>(\n  events?: Events\n) => Schema.Codec<Change<Events[number][\"Type\"]>, Schema.Json> = makeChange\n\n/**\n * The timeline of a chat before anything has happened in it, with no items and nothing working.\n * Use it as the starting point when folding changes with {@link apply}.\n *\n * @category constructors\n * @since 0.1.0\n */\nexport const empty: Timeline = {\n  seq: 0,\n  items: [],\n  activity: { working: false, specialists: [] },\n  failed: false,\n  deleted: false\n}\n\n/**\n * Returns the timeline after a change.\n *\n * **Details**\n *\n * Each item in the change replaces the item with the same id, in place, and new items are added\n * after the rest. The change's activity, `failed`, and `deleted` replace the timeline's. Applying a\n * change twice changes nothing, so a client that resubscribes from the start can fold again and get\n * the same timeline.\n *\n * The timeline is typed with the change's events, as its RPC's schema decoded them (see\n * {@link Change}). To fold a stream of changes, use {@link fold}: in\n * `Stream.scan(() => Timeline.empty, Timeline.apply)`, TypeScript fixes the state's type from\n * `empty` before it sees the changes' events, so that form needs the timeline's type written out.\n *\n * **Example** (Folding changes into your own state)\n *\n * ```ts\n * import { Timeline } from \"effect-assistant\"\n *\n * interface State<Events> {\n *   readonly timeline: Timeline.Timeline<Events>\n *   readonly unread: number\n * }\n *\n * const next = <Events>(state: State<Events>, change: Timeline.Change<Events>): State<Events> => ({\n *   timeline: Timeline.apply(state.timeline, change),\n *   unread: state.unread + change.items.length\n * })\n * ```\n *\n * @category combinators\n * @since 0.1.0\n */\nexport const apply = <Events>(timeline: Timeline<Events>, change: Change<Events>): Timeline<Events> => {\n  const changed = new Map(change.items.map((item) => [item.id, item]))\n  const known = new Set(timeline.items.map((item) => item.id))\n\n  return {\n    seq: Math.max(timeline.seq, change.seq),\n    items: [\n      ...timeline.items.map((item) => changed.get(item.id) ?? item),\n      ...change.items.filter((item) => !known.has(item.id))\n    ],\n    activity: change.activity,\n    failed: change.failed,\n    deleted: change.deleted\n  }\n}\n\n/**\n * Returns the timelines a stream of changes folds to, from {@link empty}, typed with the changes'\n * events.\n *\n * **Example** (A chat's timeline on the client)\n *\n * ```ts\n * import { Timeline } from \"effect-assistant\"\n * import * as Schema from \"effect/Schema\"\n * import * as Stream from \"effect/Stream\"\n *\n * class DailyBudgetReached extends Schema.TaggedClass<DailyBudgetReached>()(\"DailyBudgetReached\", {}) {}\n *\n * // The stream of an RPC whose success schema is `Timeline.Change([DailyBudgetReached])`.\n * declare const changes: Stream.Stream<Timeline.Change<DailyBudgetReached>>\n *\n * const timelines = changes.pipe(Timeline.fold) // Stream<Timeline.Timeline<DailyBudgetReached>>\n * ```\n *\n * @category combinators\n * @since 0.3.0\n */\nexport const fold = <Events, E, R>(\n  changes: Stream.Stream<Change<Events>, E, R>\n): Stream.Stream<Timeline<Events>, E, R> => changes.pipe(Stream.scan((): Timeline<Events> => empty, apply))\n\n/**\n * Returns whether nothing is working in the chat: no turn is running or about to start, and no\n * specialist is working.\n *\n * @category guards\n * @since 0.1.0\n */\nexport const isIdle = <Events>(timeline: Timeline<Events>): boolean =>\n  !timeline.activity.working && timeline.activity.specialists.length === 0\n\ninterface AnyEventItem {\n  readonly _tag: string\n  readonly id: string\n  readonly at: number\n  readonly event: { readonly _tag: string }\n}\n\n// What the fold below builds: the overloads that use it type its items with the events shown.\ninterface AnyChange {\n  readonly seq: number\n  readonly items: ReadonlyArray<UserMessage | AssistantMessage | AnyEventItem>\n  readonly activity: Activity\n  readonly failed: boolean\n  readonly deleted: boolean\n}\n\n/**\n * Represents the options for building a chat's timeline from its log.\n *\n * @category models\n * @since 0.3.0\n */\nexport interface ShowOptions<Show extends ReadonlyArray<AssistantEvent.AppEventSchema>> {\n  /**\n   * The schemas of the app's events the chat's users see. Each becomes an item in the timeline;\n   * the app's other events are left out. Defaults to none.\n   */\n  readonly show?: Show | undefined\n}\n\n/**\n * Represents the schemas an assistant's timeline may show: some of its own events.\n *\n * @category utility types\n * @since 0.3.0\n */\nexport type Shown<Events> = ReadonlyArray<AssistantEvent.AppEventSchema & { readonly Type: Events }>\n\nfunction snapshotWith(entries: ReadonlyArray<AssistantEvent.AnyEntry>): Change\nfunction snapshotWith<Events, const Show extends Shown<Events> = readonly []>(\n  entries: ReadonlyArray<AssistantEvent.AnyEntry>,\n  definition: Definition<Events>,\n  options?: ShowOptions<Show>\n): Change<Show[number][\"Type\"]>\nfunction snapshotWith(\n  entries: ReadonlyArray<AssistantEvent.AnyEntry>,\n  _definition?: Schemas,\n  options?: ShowOptions<ReadonlyArray<AssistantEvent.AppEventSchema>>\n): AnyChange {\n  const timeline = folding(options?.show ?? [])\n\n  for (const entry of entries) timeline.step(entry)\n\n  return timeline.snapshot\n}\n\n/**\n * Returns a chat's whole timeline as one change, built from the entries of its log.\n *\n * **When to use**\n *\n * Use it on the server for an RPC that returns a whole chat at once: its success schema is\n * {@link Change} with the same events as `show`, and the client applies it to {@link empty}.\n *\n * **Details**\n *\n * Only the app's events in `show` become items; without it, the timeline has none.\n *\n * @category constructors\n * @since 0.3.0\n */\nexport const snapshot: {\n  (entries: ReadonlyArray<AssistantEvent.AnyEntry>): Change\n  <Events, const Show extends Shown<Events> = readonly []>(\n    entries: ReadonlyArray<AssistantEvent.AnyEntry>,\n    definition: Definition<Events>,\n    options?: ShowOptions<Show>\n  ): Change<Show[number][\"Type\"]>\n} = snapshotWith\n\nfunction fromEntriesWith(entries: ReadonlyArray<AssistantEvent.AnyEntry>): Timeline\nfunction fromEntriesWith<Events, const Show extends Shown<Events> = readonly []>(\n  entries: ReadonlyArray<AssistantEvent.AnyEntry>,\n  definition: Definition<Events>,\n  options?: ShowOptions<Show>\n): Timeline<Show[number][\"Type\"]>\nfunction fromEntriesWith(\n  entries: ReadonlyArray<AssistantEvent.AnyEntry>,\n  _definition?: Schemas,\n  options?: ShowOptions<ReadonlyArray<AssistantEvent.AppEventSchema>>\n): AnyChange {\n  const timeline = folding(options?.show ?? [])\n\n  for (const entry of entries) timeline.step(entry)\n\n  return timeline.snapshot\n}\n\n/**\n * Returns a chat's timeline, built from the entries of its log.\n *\n * **When to use**\n *\n * Use it in server-side code that reads a whole chat. A client gets the timeline as a stream from\n * {@link changes} instead, and an RPC that returns a whole chat sends a {@link snapshot}.\n *\n * **Details**\n *\n * Only the app's events in `show` become items, typed with their schemas; without it, the timeline\n * has none.\n *\n * **Example** (Building a chat's timeline from its log)\n *\n * ```ts\n * import { type ChatId, ChatLog, Timeline } from \"effect-assistant\"\n * import * as Effect from \"effect/Effect\"\n *\n * const timelineOf = (chatId: ChatId.ChatId) =>\n *   ChatLog.ChatLog.use((log) => log.read(chatId)).pipe(\n *     Effect.map((entries) => Timeline.fromEntries(entries))\n *   )\n * ```\n *\n * @see {@link changes} for a stream of changes instead of a whole timeline\n *\n * @category constructors\n * @since 0.1.0\n */\nexport const fromEntries: {\n  (entries: ReadonlyArray<AssistantEvent.AnyEntry>): Timeline\n  <Events, const Show extends Shown<Events> = readonly []>(\n    entries: ReadonlyArray<AssistantEvent.AnyEntry>,\n    definition: Definition<Events>,\n    options?: ShowOptions<Show>\n  ): Timeline<Show[number][\"Type\"]>\n} = fromEntriesWith\n\ninterface Schemas {\n  readonly events: ReadonlyArray<AssistantEvent.AppEventSchema>\n}\n\ninterface Folding {\n  readonly step: (entry: AssistantEvent.AnyEntry) => AnyChange | undefined\n  readonly snapshot: AnyChange\n}\n\nconst activityOf = (activity: AssistantActivity.State): Activity => ({\n  working: activity.turnSince !== undefined || activity.queued,\n  specialists: [...activity.specialists.values()].map((run) => ({\n    specialist: run.specialist,\n    since: run.since\n  }))\n})\n\nconst sameActivity = (a: Activity, b: Activity) =>\n  a.working === b.working &&\n  a.specialists.length === b.specialists.length &&\n  a.specialists.every((run, i) => {\n    const other = b.specialists[i]\n\n    return other !== undefined && run.specialist === other.specialist && run.since === other.since\n  })\n\nconst folding = (show: ReadonlyArray<AssistantEvent.AppEventSchema>): Folding => {\n  const shown = new Map(show.map((schema) => [AppEvents.tagOf(schema), schema]))\n  let seq = 0\n  let failed = false\n  let deleted = false\n  let activity = AssistantActivity.empty\n  let blocks: ReadonlyMap<string, BlockKit.State> = new Map()\n  // The items in order, and the assistant's messages as stored: their blocks change as the chat goes on.\n  const items = new Map<string, UserMessage | AssistantMessage | AnyEventItem>()\n  const sent = new Map<string, AssistantEvent.AssistantMessage>()\n\n  const blockOf = (message: AssistantEvent.AssistantMessage): Block | undefined => {\n    if (message.block === undefined) return undefined\n\n    const state = blocks.get(message.id)\n    const status = state === undefined || state.open ? \"open\" : state.answer === undefined ? \"closed\" : \"answered\"\n    const block: Block = { kind: message.block.kind, props: toJson(message.block.props), status }\n\n    return state?.answer === undefined ? block : { ...block, answer: toJson(state.answer.value) }\n  }\n\n  const itemOf = (message: AssistantEvent.AssistantMessage, at: number): AssistantMessage => {\n    const block = blockOf(message)\n\n    return block === undefined\n      ? AssistantMessage.make({ id: message.id, text: message.text, at })\n      : AssistantMessage.make({ id: message.id, text: message.text, at, block })\n  }\n\n  const touched = (event: AssistantEvent.AssistantEvent, at: number): ReadonlyArray<string> =>\n    Match.value(event).pipe(\n      Match.tagsExhaustive({\n        UserMessage: (message) => {\n          items.set(\n            message.id,\n            message.attachments === undefined\n              ? UserMessage.make({ id: message.id, text: message.text, at })\n              : UserMessage.make({\n                  id: message.id,\n                  text: message.text,\n                  attachments: message.attachments,\n                  at\n                })\n          )\n          failed = false\n\n          return [message.id]\n        },\n        AssistantMessage: (message) => {\n          sent.set(message.id, message)\n          items.set(message.id, itemOf(message, at))\n          failed = false\n\n          return [message.id, ...(message.closes ?? [])]\n        },\n        BlockAnswer: (answer) => {\n          failed = false\n\n          return [answer.messageId]\n        },\n        BlocksClosed: (closed) => closed.messageIds,\n        TurnFailed: () => {\n          failed = true\n\n          return []\n        },\n        ModelOutput: () => [],\n        ToolStarted: () => [],\n        ToolResult: () => [],\n        TurnStarted: () => [],\n        TurnCompleted: () => [],\n        SpecialistStarted: () => [],\n        SpecialistFinished: () => [],\n        ChatDeleted: () => {\n          deleted = true\n\n          return []\n        }\n      })\n    )\n\n  // Decoded as `subscribe` streams it, or as the log stores it; one that doesn't decode is left out.\n  const eventItemOf = (entry: AssistantEvent.AnyEntry): Option.Option<AnyEventItem> => {\n    const schema = shown.get(entry.event._tag)\n\n    if (schema === undefined) return Option.none()\n\n    const event = Schema.is(schema)(entry.event) ? Option.some(entry.event) : AppEvents.decodeWith(schema, entry.event)\n\n    return Option.map(event, (decoded) => ({\n      _tag: decoded._tag,\n      id: `app-event:${entry.seq}`,\n      at: entry.at,\n      event: decoded\n    }))\n  }\n\n  const step = (entry: AssistantEvent.AnyEntry): AnyChange | undefined => {\n    const before = { activity: activityOf(activity), failed, deleted }\n    const { event } = entry\n\n    seq = entry.seq\n    activity = AssistantActivity.apply(activity, entry)\n\n    if (!AssistantEvent.isLibraryEvent(event)) {\n      const now = activityOf(activity)\n\n      return Option.match(eventItemOf(entry), {\n        onNone: () =>\n          sameActivity(before.activity, now) ? undefined : { seq, items: [], activity: now, failed, deleted },\n        onSome: (item) => {\n          items.set(item.id, item)\n\n          return { seq, items: [item], activity: now, failed, deleted }\n        }\n      })\n    }\n\n    blocks = BlockKit.apply(blocks, event)\n\n    const changed = [...new Set(touched(event, entry.at))].flatMap((id) => {\n      const message = sent.get(id)\n      const current = items.get(id)\n\n      if (message === undefined || current === undefined) return current === undefined ? [] : [current]\n\n      const next = itemOf(message, current.at)\n      items.set(id, next)\n\n      return [next]\n    })\n\n    const now = activityOf(activity)\n\n    return changed.length === 0 &&\n      failed === before.failed &&\n      deleted === before.deleted &&\n      sameActivity(before.activity, now)\n      ? undefined\n      : { seq, items: changed, activity: now, failed, deleted }\n  }\n\n  return {\n    step,\n    get snapshot() {\n      return { seq, items: [...items.values()], activity: activityOf(activity), failed, deleted }\n    }\n  }\n}\n\nconst merge = (changes: ReadonlyArray<AnyChange>): AnyChange | undefined => {\n  const last = changes.at(-1)\n\n  if (last === undefined) return undefined\n\n  const items = new Map<string, UserMessage | AssistantMessage | AnyEventItem>()\n\n  for (const change of changes) for (const item of change.items) items.set(item.id, item)\n\n  return {\n    seq: last.seq,\n    items: [...items.values()],\n    activity: last.activity,\n    failed: last.failed,\n    deleted: last.deleted\n  }\n}\n\n/**\n * Represents an assistant's definition as the timeline reads it. An assistant made with\n * `Assistant.make` fits it.\n *\n * @category models\n * @since 0.1.0\n */\nexport interface Definition<Events = never> {\n  /** The schemas of the assistant's events. */\n  readonly events: ReadonlyArray<AssistantEvent.AppEventSchema>\n  /** The schema of the chat's entries, typed with the assistant's events: it types `show`. */\n  readonly Entry: Schema.Codec<Assistant.Entry<Events>, Schema.Json>\n}\n\n/**\n * Represents the options accepted by {@link changes}.\n *\n * @category models\n * @since 0.3.0\n */\nexport interface ChangesOptions<\n  Show extends ReadonlyArray<AssistantEvent.AppEventSchema> = readonly []\n> extends ShowOptions<Show> {\n  /**\n   * The `seq` up to which the client already has the timeline. The result contains only the\n   * changes after it. Defaults to `0`, every change.\n   */\n  readonly after?: number | undefined\n}\n\nfunction changesWith<E, R, Events, const Show extends Shown<Events> = readonly []>(\n  entries: Stream.Stream<AssistantEvent.AnyEntry, E, R>,\n  definition: Definition<Events>,\n  options?: ChangesOptions<Show>\n): Stream.Stream<Change<Show[number][\"Type\"]>, E, R>\nfunction changesWith<E, R>(\n  entries: Stream.Stream<AssistantEvent.AnyEntry, E, R>,\n  _definition: Schemas,\n  options?: ChangesOptions<ReadonlyArray<AssistantEvent.AppEventSchema>>\n): Stream.Stream<AnyChange, E, R> {\n  const after = options?.after ?? 0\n\n  return entries.pipe(\n    Stream.mapAccumArray(\n      () => folding(options?.show ?? []),\n      (timeline, chunk) => {\n        const changed = chunk.flatMap((entry) => {\n          const change = timeline.step(entry)\n\n          return change === undefined || entry.seq <= after ? [] : [change]\n        })\n\n        const merged = merge(changed)\n\n        return [timeline, merged === undefined ? [] : [merged]]\n      }\n    )\n  )\n}\n\n/**\n * Returns the stream of changes to a chat's timeline that its entries produce, for a chat client.\n *\n * **Details**\n *\n * The entries must stream from the start of the chat's log, as `assistant.subscribe(chatId)` does\n * without `after`. The fold reads every entry, because a message depends on earlier entries: its\n * block is answered or closed later. `after` only skips emitting the changes up to that `seq`, so a\n * client that has the timeline up to a `seq` receives only what changed since. Pass `after` here,\n * not to `subscribe`: a subscription that starts after a `seq` gives the fold an incomplete log,\n * and the changes it produces are wrong.\n *\n * Each chunk of entries becomes one change; the stored entries, for example, arrive as one chunk.\n *\n * **Only the app's events in `show` reach the client.** Each one becomes an item between the\n * messages (see {@link EventItem}); the app's other events, like a summary of the chat for the\n * model, are left out. Without `show`, none are shown. The changes are typed with the events shown,\n * so the RPC's success schema names the same ones (`Timeline.Change([...])`), and a handler that\n * shows one the schema doesn't name doesn't compile. A timeline shows a turn as working once it\n * starts, or from the user's input.\n *\n * **Example** (Streaming a chat's timeline to a client, with the one app event its user sees)\n *\n * ```ts\n * import { Assistant, type ChatId, Timeline } from \"effect-assistant\"\n * import * as Schema from \"effect/Schema\"\n * import * as Stream from \"effect/Stream\"\n *\n * class Summary extends Schema.TaggedClass<Summary>()(\"Summary\", { text: Schema.String, throughSeq: Schema.Int }) {}\n * class DailyBudgetReached extends Schema.TaggedClass<DailyBudgetReached>()(\"DailyBudgetReached\", {}) {}\n *\n * const MyAssistant = Assistant.make(\"my-assistant\", { events: [Summary, DailyBudgetReached] })\n *\n * // The summary is for the model: only the budget notice reaches the user.\n * const watch = (chatId: ChatId.ChatId, after: number) =>\n *   Stream.unwrap(\n *     MyAssistant.useSync((assistant) =>\n *       assistant.subscribe(chatId).pipe(Timeline.changes(MyAssistant, { show: [DailyBudgetReached], after }))\n *     )\n *   )\n * ```\n *\n * @see {@link fold} for folding the changes into a timeline on the client\n *\n * @category utils\n * @since 0.3.0\n */\nexport const changes: {\n  <Events, const Show extends Shown<Events> = readonly []>(\n    definition: Definition<Events>,\n    options?: ChangesOptions<Show>\n  ): <E, R>(entries: Stream.Stream<AssistantEvent.AnyEntry, E, R>) => Stream.Stream<Change<Show[number][\"Type\"]>, E, R>\n  <E, R, Events, const Show extends Shown<Events> = readonly []>(\n    entries: Stream.Stream<AssistantEvent.AnyEntry, E, R>,\n    definition: Definition<Events>,\n    options?: ChangesOptions<Show>\n  ): Stream.Stream<Change<Show[number][\"Type\"]>, E, R>\n} = dual((args) => Stream.isStream(args[0]), changesWith)\n"],"mappings":"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"}