effect-assistant 0.0.0-stage → 0.2.0

package/dist/ChatView.js

@@ -0,0 +1,443 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import { InputId } from "./InputId.js";
+import { Attachment, isLibraryEvent } from "./AssistantEvent.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 { dual } from "effect/Function";
+import * as Match from "effect/Match";
+//#region src/ChatView.ts
+/**
+* This module provides the view of a chat as its user sees it. A chat client receives this view
+* and nothing else.
+*
+* A {@link View} holds the chat's messages with their blocks, the chat's
+* {@link Activity}, and whether the last turn failed or the chat was deleted. It never contains
+* the model's output, tool calls or results, what the model read, the app's own events, or why a
+* turn failed. The server streams {@link Update}s by piping the assistant's `subscribe` through
+* {@link updates}, and the client folds them with {@link apply}, starting from {@link empty}.
+* On the server, {@link fromEntries} builds a whole view from a chat's log.
+*
+* @since 0.1.0
+*/
+var ChatView_exports = /* @__PURE__ */ __exportAll({
+	Activity: () => Activity,
+	AssistantMessage: () => AssistantMessage,
+	Block: () => Block,
+	BlockStatus: () => BlockStatus,
+	Message: () => Message,
+	SpecialistWorking: () => SpecialistWorking,
+	Update: () => Update,
+	UserMessage: () => UserMessage,
+	View: () => View,
+	apply: () => apply,
+	empty: () => empty,
+	fromEntries: () => fromEntries,
+	isIdle: () => isIdle,
+	updates: () => updates
+});
+/**
+* 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 message in the chat, sent by either the user or the assistant.
+*
+* @category schemas
+* @since 0.1.0
+*/
+const Message = Schema.Union([UserMessage, AssistantMessage]);
+/**
+* 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)
+});
+/**
+* Schema for a chat as its user sees it. It holds the chat's messages, what is working in it,
+* whether the last turn failed, and whether the chat was deleted. `seq` is the position in the
+* chat's log that the view is up to.
+*
+* @category schemas
+* @since 0.1.0
+*/
+const View = Schema.Struct({
+	seq: Schema.Int,
+	messages: Schema.Array(Message),
+	activity: Activity,
+	/** Whether the last turn failed with no message after it. */
+	failed: Schema.Boolean,
+	/** Whether the chat was deleted. A deleted chat accepts nothing more, and its stream ends. */
+	deleted: Schema.Boolean
+});
+/**
+* Schema for a change to a chat's view.
+*
+* An update holds each message that is new or changed (for example, a block answered or
+* closed), in full. It also holds the current activity, whether the last turn failed,
+* and whether the chat was deleted. `seq` is the position in the chat's log that the update is up
+* to.
+*
+* @category schemas
+* @since 0.1.0
+*/
+const Update = Schema.Struct({
+	seq: Schema.Int,
+	messages: Schema.Array(Message),
+	activity: Activity,
+	failed: Schema.Boolean,
+	deleted: Schema.Boolean
+});
+/**
+* The view of a chat before anything has happened in it, with no messages and nothing working.
+* Use it as the starting point when folding updates with {@link apply}.
+*
+* @category constructors
+* @since 0.1.0
+*/
+const empty = {
+	seq: 0,
+	messages: [],
+	activity: {
+		working: false,
+		specialists: []
+	},
+	failed: false,
+	deleted: false
+};
+/**
+* Returns the view after applying an update.
+*
+* **Details**
+*
+* Each message in the update replaces the message with the same id, in place, and new messages
+* are added after the rest. The update's activity, `failed`, and `deleted` replace the view's.
+* Applying an update twice changes nothing, so a client that resubscribes from the start can fold
+* again and get the same view.
+*
+* @category combinators
+* @since 0.1.0
+*/
+const apply = (view, update) => {
+	const changed = new Map(update.messages.map((message) => [message.id, message]));
+	const known = new Set(view.messages.map((message) => message.id));
+	return {
+		seq: Math.max(view.seq, update.seq),
+		messages: [...view.messages.map((message) => changed.get(message.id) ?? message), ...update.messages.filter((message) => !known.has(message.id))],
+		activity: update.activity,
+		failed: update.failed,
+		deleted: update.deleted
+	};
+};
+/**
+* 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 = (view) => !view.activity.working && view.activity.specialists.length === 0;
+/**
+* Returns a chat's view, built from the entries of its log.
+*
+* **When to use**
+*
+* Use it in server-side code, for example to return a whole chat at once. A client gets the view
+* as a stream from {@link updates} instead.
+*
+* **Example** (Building a chat's view from its log)
+*
+* ```ts
+* import { type ChatId, ChatLog, ChatView } from "effect-assistant"
+* import * as Effect from "effect/Effect"
+*
+* const viewOf = (chatId: ChatId.ChatId) =>
+*   ChatLog.ChatLog.use((log) => log.read(chatId)).pipe(
+*     Effect.map((entries) => ChatView.fromEntries(entries))
+*   )
+* ```
+*
+* @see {@link updates} for a stream of changes instead of a whole view
+*
+* @category constructors
+* @since 0.1.0
+*/
+const fromEntries = (entries, options) => {
+	const fold = folding(options?.wakes ?? /* @__PURE__ */ new Set());
+	for (const entry of entries) fold.step(entry);
+	return fold.view;
+};
+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 = (wakes) => {
+	let seq = 0;
+	let failed = false;
+	let deleted = false;
+	let activity = empty$1;
+	let blocks = /* @__PURE__ */ new Map();
+	const messages = /* @__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 viewOf = (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) => {
+			messages.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);
+			messages.set(message.id, viewOf(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 step = (entry) => {
+		const before = {
+			activity: activityOf(activity),
+			failed,
+			deleted
+		};
+		const { event } = entry;
+		seq = entry.seq;
+		activity = apply$1(activity, entry, { wakes });
+		if (!isLibraryEvent(event)) {
+			const now = activityOf(activity);
+			return sameActivity(before.activity, now) ? void 0 : {
+				seq,
+				messages: [],
+				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 = messages.get(id);
+			if (message === void 0 || current === void 0) return current === void 0 ? [] : [current];
+			const next = viewOf(message, current.at);
+			messages.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,
+			messages: changed,
+			activity: now,
+			failed,
+			deleted
+		};
+	};
+	return {
+		step,
+		get view() {
+			return {
+				seq,
+				messages: [...messages.values()],
+				activity: activityOf(activity),
+				failed,
+				deleted
+			};
+		}
+	};
+};
+const merge = (updates) => {
+	const last = updates.at(-1);
+	if (last === void 0) return void 0;
+	const messages = /* @__PURE__ */ new Map();
+	for (const update of updates) for (const message of update.messages) messages.set(message.id, message);
+	return {
+		seq: last.seq,
+		messages: [...messages.values()],
+		activity: last.activity,
+		failed: last.failed,
+		deleted: last.deleted
+	};
+};
+const wakesOf = (definition) => new Set(definition.events.flatMap((event) => event.wakes ? [event.tag] : []));
+/**
+* Returns the stream of view updates that a chat's 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's view depends on earlier
+* entries: a block is answered or closed later. `after` only skips
+* emitting the updates up to that `seq`, so a client that has the view up to a `seq` receives only
+* what changed since. Pass `after` here, not to `subscribe`: a subscription that starts after a
+* `seq` gives the fold an incomplete log, and the updates it produces are wrong.
+*
+* The definition tells the fold which of the app's events wake a turn, so the view shows a turn as
+* about to start after one. Each chunk of entries becomes one update; the stored entries, for
+* example, arrive as one chunk.
+*
+* **Example** (Streaming a chat's view to a client)
+*
+* ```ts
+* import { Assistant, type ChatId, ChatView } from "effect-assistant"
+* import * as Stream from "effect/Stream"
+*
+* const MyAssistant = Assistant.make("my-assistant")
+*
+* const watch = (chatId: ChatId.ChatId, after: number) =>
+*   Stream.unwrap(
+*     MyAssistant.useSync((assistant) =>
+*       assistant.subscribe(chatId).pipe(ChatView.updates(MyAssistant, { after }))
+*     )
+*   )
+* ```
+*
+* @see {@link apply} for folding the updates into a view on the client
+*
+* @category utils
+* @since 0.1.0
+*/
+const updates = dual((args) => Stream.isStream(args[0]), (entries, definition, options) => {
+	const after = options?.after ?? 0;
+	const wakes = wakesOf(definition);
+	return entries.pipe(Stream.mapAccumArray(() => folding(wakes), (fold, chunk) => {
+		const changed = chunk.flatMap((entry) => {
+			const update = fold.step(entry);
+			return update === void 0 || entry.seq <= after ? [] : [update];
+		});
+		const merged = merge(changed);
+		return [fold, merged === void 0 ? [] : [merged]];
+	}));
+});
+//#endregion
+export { Activity, AssistantMessage, Block, BlockStatus, ChatView_exports, Message, SpecialistWorking, Update, UserMessage, View, apply, empty, fromEntries, isIdle, updates };
+
+//# sourceMappingURL=ChatView.js.map

package/dist/ChatView.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChatView.js","names":["AssistantEvent.Attachment","AssistantActivity.empty","AssistantActivity.apply","AssistantEvent.isLibraryEvent","BlockKit.apply"],"sources":["../src/ChatView.ts"],"sourcesContent":["/**\n * This module provides the view of a chat as its user sees it. A chat client receives this view\n * and nothing else.\n *\n * A {@link View} holds the chat's messages with their blocks, the chat's\n * {@link Activity}, and whether the last turn failed or the chat was deleted. It never contains\n * the model's output, tool calls or results, what the model read, the app's own events, or why a\n * turn failed. The server streams {@link Update}s by piping the assistant's `subscribe` through\n * {@link updates}, and the client folds them with {@link apply}, starting from {@link empty}.\n * On the server, {@link fromEntries} builds a whole view from a chat's log.\n *\n * @since 0.1.0\n */\nimport { dual } from \"effect/Function\"\nimport * as Match from \"effect/Match\"\nimport * as Schema from \"effect/Schema\"\nimport * as Stream from \"effect/Stream\"\nimport * as AssistantActivity from \"./AssistantActivity.ts\"\nimport * as AssistantEvent from \"./AssistantEvent.ts\"\nimport * as BlockKit from \"./BlockKit.ts\"\nimport { InputId } from \"./InputId.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 * Schema for a message in the chat, sent by either the user or the assistant.\n *\n * @category schemas\n * @since 0.1.0\n */\nexport const Message = Schema.Union([UserMessage, AssistantMessage])\n\n/**\n * Represents a message in the chat.\n *\n * @category models\n * @since 0.1.0\n */\nexport type Message = typeof Message.Type\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 * Schema for a chat as its user sees it. It holds the chat's messages, what is working in it,\n * whether the last turn failed, and whether the chat was deleted. `seq` is the position in the\n * chat's log that the view is up to.\n *\n * @category schemas\n * @since 0.1.0\n */\nexport const View = Schema.Struct({\n  seq: Schema.Int,\n  messages: Schema.Array(Message),\n  activity: Activity,\n  /** Whether the last turn failed with no message after it. */\n  failed: Schema.Boolean,\n  /** Whether the chat was deleted. A deleted chat accepts nothing more, and its stream ends. */\n  deleted: Schema.Boolean\n})\n\n/**\n * Represents a chat as its user sees it.\n *\n * @category models\n * @since 0.1.0\n */\nexport type View = typeof View.Type\n\n/**\n * Schema for a change to a chat's view.\n *\n * An update holds each message that is new or changed (for example, a block answered or\n * 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 update is up\n * to.\n *\n * @category schemas\n * @since 0.1.0\n */\nexport const Update = Schema.Struct({\n  seq: Schema.Int,\n  messages: Schema.Array(Message),\n  activity: Activity,\n  failed: Schema.Boolean,\n  deleted: Schema.Boolean\n})\n\n/**\n * Represents a change to a chat's view.\n *\n * @category models\n * @since 0.1.0\n */\nexport type Update = typeof Update.Type\n\n/**\n * The view of a chat before anything has happened in it, with no messages and nothing working.\n * Use it as the starting point when folding updates with {@link apply}.\n *\n * @category constructors\n * @since 0.1.0\n */\nexport const empty: View = {\n  seq: 0,\n  messages: [],\n  activity: { working: false, specialists: [] },\n  failed: false,\n  deleted: false\n}\n\n/**\n * Returns the view after applying an update.\n *\n * **Details**\n *\n * Each message in the update replaces the message with the same id, in place, and new messages\n * are added after the rest. The update's activity, `failed`, and `deleted` replace the view's.\n * Applying an update twice changes nothing, so a client that resubscribes from the start can fold\n * again and get the same view.\n *\n * @category combinators\n * @since 0.1.0\n */\nexport const apply = (view: View, update: Update): View => {\n  const changed = new Map(update.messages.map((message) => [message.id, message]))\n  const known = new Set(view.messages.map((message) => message.id))\n\n  return {\n    seq: Math.max(view.seq, update.seq),\n    messages: [\n      ...view.messages.map((message) => changed.get(message.id) ?? message),\n      ...update.messages.filter((message) => !known.has(message.id))\n    ],\n    activity: update.activity,\n    failed: update.failed,\n    deleted: update.deleted\n  }\n}\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 = (view: View): boolean => !view.activity.working && view.activity.specialists.length === 0\n\n/**\n * Represents the options for building a view from a chat's log.\n *\n * @category models\n * @since 0.1.0\n */\nexport interface Options {\n  /**\n   * The tags of the app's events that wake a turn. After such an event, the view shows a turn as\n   * about to start. Defaults to none.\n   */\n  readonly wakes?: ReadonlySet<string> | undefined\n}\n\n/**\n * Returns a chat's view, built from the entries of its log.\n *\n * **When to use**\n *\n * Use it in server-side code, for example to return a whole chat at once. A client gets the view\n * as a stream from {@link updates} instead.\n *\n * **Example** (Building a chat's view from its log)\n *\n * ```ts\n * import { type ChatId, ChatLog, ChatView } from \"effect-assistant\"\n * import * as Effect from \"effect/Effect\"\n *\n * const viewOf = (chatId: ChatId.ChatId) =>\n *   ChatLog.ChatLog.use((log) => log.read(chatId)).pipe(\n *     Effect.map((entries) => ChatView.fromEntries(entries))\n *   )\n * ```\n *\n * @see {@link updates} for a stream of changes instead of a whole view\n *\n * @category constructors\n * @since 0.1.0\n */\nexport const fromEntries = (entries: ReadonlyArray<AssistantEvent.AnyEntry>, options?: Options): View => {\n  const fold = folding(options?.wakes ?? new Set())\n\n  for (const entry of entries) fold.step(entry)\n\n  return fold.view\n}\n\ninterface Folding {\n  readonly step: (entry: AssistantEvent.AnyEntry) => Update | undefined\n  readonly view: View\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 = (wakes: ReadonlySet<string>): Folding => {\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 messages in order, and the assistant's as stored: their blocks change as the chat goes on.\n  const messages = new Map<string, Message>()\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 viewOf = (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          messages.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          messages.set(message.id, viewOf(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  const step = (entry: AssistantEvent.AnyEntry): Update | undefined => {\n    const before = { activity: activityOf(activity), failed, deleted }\n    const { event } = entry\n\n    seq = entry.seq\n    activity = AssistantActivity.apply(activity, entry, { wakes })\n\n    if (!AssistantEvent.isLibraryEvent(event)) {\n      const now = activityOf(activity)\n\n      return sameActivity(before.activity, now) ? undefined : { seq, messages: [], activity: now, failed, deleted }\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 = messages.get(id)\n\n      if (message === undefined || current === undefined) return current === undefined ? [] : [current]\n\n      const next = viewOf(message, current.at)\n      messages.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, messages: changed, activity: now, failed, deleted }\n  }\n\n  return {\n    step,\n    get view() {\n      return { seq, messages: [...messages.values()], activity: activityOf(activity), failed, deleted }\n    }\n  }\n}\n\nconst merge = (updates: ReadonlyArray<Update>): Update | undefined => {\n  const last = updates.at(-1)\n\n  if (last === undefined) return undefined\n\n  const messages = new Map<string, Message>()\n\n  for (const update of updates) for (const message of update.messages) messages.set(message.id, message)\n\n  return {\n    seq: last.seq,\n    messages: [...messages.values()],\n    activity: last.activity,\n    failed: last.failed,\n    deleted: last.deleted\n  }\n}\n\n/**\n * Represents an assistant's definition as {@link updates} reads it: the app's events it\n * registered, and whether each one wakes a turn. An assistant made with `Assistant.make` fits it.\n *\n * @category models\n * @since 0.1.0\n */\nexport interface Definition {\n  readonly events: ReadonlyArray<{ readonly tag: string; readonly wakes: boolean }>\n}\n\n/**\n * Represents the options accepted by {@link updates}.\n *\n * @category models\n * @since 0.1.0\n */\nexport interface UpdatesOptions {\n  /**\n   * The `seq` up to which the client already has the view. The result contains only the updates\n   * after it. Defaults to `0`, every update.\n   */\n  readonly after?: number | undefined\n}\n\nconst wakesOf = (definition: Definition): ReadonlySet<string> =>\n  new Set(definition.events.flatMap((event) => (event.wakes ? [event.tag] : [])))\n\n/**\n * Returns the stream of view updates that a chat's 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's view depends on earlier\n * entries: a block is answered or closed later. `after` only skips\n * emitting the updates up to that `seq`, so a client that has the view up to a `seq` receives only\n * what changed since. Pass `after` here, not to `subscribe`: a subscription that starts after a\n * `seq` gives the fold an incomplete log, and the updates it produces are wrong.\n *\n * The definition tells the fold which of the app's events wake a turn, so the view shows a turn as\n * about to start after one. Each chunk of entries becomes one update; the stored entries, for\n * example, arrive as one chunk.\n *\n * **Example** (Streaming a chat's view to a client)\n *\n * ```ts\n * import { Assistant, type ChatId, ChatView } from \"effect-assistant\"\n * import * as Stream from \"effect/Stream\"\n *\n * const MyAssistant = Assistant.make(\"my-assistant\")\n *\n * const watch = (chatId: ChatId.ChatId, after: number) =>\n *   Stream.unwrap(\n *     MyAssistant.useSync((assistant) =>\n *       assistant.subscribe(chatId).pipe(ChatView.updates(MyAssistant, { after }))\n *     )\n *   )\n * ```\n *\n * @see {@link apply} for folding the updates into a view on the client\n *\n * @category utils\n * @since 0.1.0\n */\nexport const updates: {\n  (\n    definition: Definition,\n    options?: UpdatesOptions\n  ): <E, R>(entries: Stream.Stream<AssistantEvent.AnyEntry, E, R>) => Stream.Stream<Update, E, R>\n  <E, R>(\n    entries: Stream.Stream<AssistantEvent.AnyEntry, E, R>,\n    definition: Definition,\n    options?: UpdatesOptions\n  ): Stream.Stream<Update, E, R>\n} = dual(\n  (args) => Stream.isStream(args[0]),\n  <E, R>(\n    entries: Stream.Stream<AssistantEvent.AnyEntry, E, R>,\n    definition: Definition,\n    options?: UpdatesOptions\n  ): Stream.Stream<Update, E, R> => {\n    const after = options?.after ?? 0\n    const wakes = wakesOf(definition)\n\n    return entries.pipe(\n      Stream.mapAccumArray(\n        () => folding(wakes),\n        (fold, chunk) => {\n          const changed = chunk.flatMap((entry) => {\n            const update = fold.step(entry)\n\n            return update === undefined || entry.seq <= after ? [] : [update]\n          })\n\n          const merged = merge(changed)\n\n          return [fold, merged === undefined ? [] : [merged]]\n        }\n      )\n    )\n  }\n)\n"],"mappings":"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"}

package/dist/Chats.d.ts

@@ -0,0 +1,110 @@
+import { ChatId } from "./ChatId.js";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+declare namespace Chats_d_exports {
+  export { ChatRecord, Chats, GetChatError, Reason, Service };
+}
+/**
+ * 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
+ */
+export declare const Reason: Schema.Literals<readonly ["NotFound", "Deleted"]>;
+/**
+ * The reason a chat can't be used.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type Reason = typeof Reason.Type;
+declare const GetChatError_base: Schema.Class<GetChatError, Schema.Struct<{
+  readonly _tag: Schema.tag<"GetChatError">;
+  readonly chatId: Schema.brand<Schema.TemplateLiteral<readonly ["chat:", Schema.String]>, "~effect-assistant/ChatId">;
+  readonly reason: Schema.Literals<readonly ["NotFound", "Deleted"]>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * 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
+ */
+export declare class GetChatError extends GetChatError_base {}
+/**
+ * Represents what the library needs to know about a chat, which is its id. The app's own record
+ * can carry more.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export interface ChatRecord {
+  readonly chatId: ChatId;
+}
+/**
+ * Represents the app's chats, as the `Chats` service exposes them.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export interface Service {
+  /** Returns the chat, or fails with a `GetChatError` that says why it can't be used. */
+  readonly get: (chatId: ChatId) => Effect.Effect<ChatRecord, GetChatError>;
+}
+/**
+ * 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
+ */
+export declare const Chats: Context.Reference<Service>;
+//#endregion
+export { Chats_d_exports };
+//# sourceMappingURL=Chats.d.ts.map

package/dist/Chats.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Chats.d.ts","names":[],"sources":["../src/Chats.ts"],"mappings":";;;;;;;;;;;;;;qBAuBa,QAAM,OAAA;;;;;;;YAQP,gBAAgB,OAAO;;;;;;;;;;;;;;;;;;;qBAetB,qBAAqB;;;;;;;;iBAajB;WACN,QAAQ;;;;;;;;iBASF;;WAEN,MAAM,QAAQ,WAAW,OAAO,OAAO,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAgDjD,OAAO,QAAQ,UAAU"}