effect-assistant 0.2.0 → 0.4.0

package/dist/ChatView.js

@@ -1,443 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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/internal/skills.js

@@ -1,28 +0,0 @@
-import { ToolFailure, fail } from "../ToolFailure.js";
-import { empty, withContext } from "./toolkit.js";
-import { resolve } from "../Instructions.js";
-import * as Effect from "effect/Effect";
-import * as Schema from "effect/Schema";
-import * as Tool from "effect/ai/Tool";
-import * as Toolkit from "effect/ai/Toolkit";
-//#region src/internal/skills.ts
-/** @internal */
-const toTools = (skills) => {
-	if (skills.length === 0) return empty;
-	const byName = new Map(skills.map((skill) => [skill.name, skill]));
-	const LoadSkill = Tool.make("load_skill", {
-		description: "Load a skill's instructions by name, in the same step as your first lookups (not in a step of its own). Follow them for the rest of the task.",
-		parameters: Schema.Struct({ name: Schema.Literals(skills.map((skill) => skill.name)) }),
-		success: Schema.String,
-		failure: ToolFailure
-	});
-	return withContext(Toolkit.make(LoadSkill), (context) => ({ load_skill: Effect.fnUntraced(function* ({ name }) {
-		const skill = byName.get(name);
-		if (skill === void 0) return yield* fail(`No skill named ${name}.`);
-		return (yield* resolve(skill.instructions).pipe(Effect.provideContext(context))).text;
-	}) }));
-};
-//#endregion
-export { toTools };
-
-//# sourceMappingURL=skills.js.map

package/dist/internal/skills.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"skills.js","names":["Toolkits.empty","ToolFailure.ToolFailure","Toolkits.withContext","ToolFailure.fail","Instructions.resolve"],"sources":["../../src/internal/skills.ts"],"sourcesContent":["import * as Tool from \"effect/ai/Tool\"\nimport * as Toolkit from \"effect/ai/Toolkit\"\nimport type * as Context from \"effect/Context\"\nimport * as Effect from \"effect/Effect\"\nimport * as Schema from \"effect/Schema\"\nimport * as Instructions from \"../Instructions.ts\"\nimport type { Skill } from \"../Skill.ts\"\nimport * as ToolFailure from \"../ToolFailure.ts\"\nimport * as Toolkits from \"./toolkit.ts\"\n\n/** @internal */\nexport const toTools = <R>(skills: ReadonlyArray<Skill<R>>): Toolkits.Tools<R> => {\n  if (skills.length === 0) return Toolkits.empty\n\n  const byName = new Map(skills.map((skill) => [skill.name, skill]))\n\n  const LoadSkill = Tool.make(\"load_skill\", {\n    description:\n      \"Load a skill's instructions by name, in the same step as your first lookups (not in a step of its own). Follow them for the rest of the task.\",\n    parameters: Schema.Struct({ name: Schema.Literals(skills.map((skill) => skill.name)) }),\n    success: Schema.String,\n    failure: ToolFailure.ToolFailure\n  })\n\n  // A skill's instructions resolve with the services of the loop that loads it.\n  return Toolkits.withContext(Toolkit.make(LoadSkill), (context: Context.Context<R>) => ({\n    load_skill: Effect.fnUntraced(function* ({ name }) {\n      const skill = byName.get(name)\n\n      if (skill === undefined) return yield* ToolFailure.fail(`No skill named ${name}.`)\n\n      const resolved = yield* Instructions.resolve(skill.instructions).pipe(Effect.provideContext(context))\n\n      return resolved.text\n    })\n  }))\n}\n"],"mappings":";;;;;;;;;AAWA,MAAa,WAAc,WAAuD;CAChF,IAAI,OAAO,WAAW,GAAG,OAAOA;CAEhC,MAAM,SAAS,IAAI,IAAI,OAAO,KAAK,UAAU,CAAC,MAAM,MAAM,KAAK,CAAC,CAAC;CAEjE,MAAM,YAAY,KAAK,KAAK,cAAc;EACxC,aACE;EACF,YAAY,OAAO,OAAO,EAAE,MAAM,OAAO,SAAS,OAAO,KAAK,UAAU,MAAM,IAAI,CAAC,EAAE,CAAC;EACtF,SAAS,OAAO;EAChB,SAASC;CACX,CAAC;CAGD,OAAOC,YAAqB,QAAQ,KAAK,SAAS,IAAI,aAAiC,EACrF,YAAY,OAAO,WAAW,WAAW,EAAE,QAAQ;EACjD,MAAM,QAAQ,OAAO,IAAI,IAAI;EAE7B,IAAI,UAAU,KAAA,GAAW,OAAO,OAAOC,KAAiB,kBAAkB,KAAK,EAAE;EAIjF,QAAO,OAFiBC,QAAqB,MAAM,YAAY,CAAC,CAAC,KAAK,OAAO,eAAe,OAAO,CAAC,EAAA,CAEpF;CAClB,CAAC,EACH,EAAE;AACJ"}

package/src/AppEvent.ts

@@ -1,134 +0,0 @@
-/**
- * Registers an application's own events with an assistant.
- *
- * An app event is a tagged schema for something the application reports into a chat, such as a
- * workflow's progress, a webhook, a summary for compaction, or the draft the user opened.
- * {@link make} registers one with two choices: whether storing it wakes a turn (`wakes`), and
- * how the model reads it (`render`).
- *
- * @since 0.1.0
- */
-import * as Predicate from "effect/Predicate"
-import type * as Schema from "effect/Schema"
-import * as SchemaAST from "effect/SchemaAST"
-
-/**
- * Schema for one of the application's own events.
- *
- * It is a tagged struct or class (`Schema.TaggedStruct`, `Schema.TaggedClass`) that needs no
- * services.
- *
- * @category models
- * @since 0.1.0
- */
-export type EventSchema = Schema.Codec<{ readonly _tag: string }, { readonly _tag: string }> & {
-  readonly fields: { readonly _tag: { readonly ast: SchemaAST.AST } }
-}
-
-/**
- * Describes how the model reads an event.
- *
- * `"json"` shows the event's tag and fields as JSON. A function shows the text it returns for the
- * event.
- *
- * @category models
- * @since 0.1.0
- */
-export type Render<A> = "json" | ((event: A) => string)
-
-/**
- * Represents one of the application's events, registered with an assistant.
- *
- * It holds the event's schema and tag, whether storing it wakes a turn, and how the model reads
- * it. A `render` of `undefined` means the model doesn't read it.
- *
- * @category models
- * @since 0.1.0
- */
-export interface AppEvent<S extends EventSchema = EventSchema> {
-  readonly schema: S
-  readonly tag: string
-  readonly wakes: boolean
-  readonly render: Render<S["Type"]> | undefined
-}
-
-/**
- * Represents any registered event, for generic constraints.
- *
- * @category utility types
- * @since 0.1.0
- */
-export type Any = AppEvent<any>
-
-/**
- * Extracts the type of a registered event's values.
- *
- * @category utility types
- * @since 0.1.0
- */
-export type Type<E extends Any> = E["schema"]["Type"]
-
-const tagOf = (schema: EventSchema): string => {
-  const ast = schema.fields._tag.ast
-
-  if (SchemaAST.isLiteral(ast) && Predicate.isString(ast.literal)) return ast.literal
-
-  throw new Error("An app event is a tagged struct or class.")
-}
-
-/**
- * Registers one of the application's events with an assistant.
- *
- * **Details**
- *
- * Storing the event wakes a turn only when `wakes` is `true`; it defaults to `false`. `render`
- * defaults to `"json"` for an event that wakes a turn. An event that doesn't wake a turn and has
- * no `render` isn't read by the model.
- *
- * The schema must be a tagged struct or class whose `_tag` is a string literal; `make` throws
- * otherwise.
- *
- * **Example** (Registering an event that wakes a turn)
- *
- * ```ts
- * import { AppEvent, Assistant, InputId } from "effect-assistant"
- * import * as Schema from "effect/Schema"
- *
- * class OrderShipped extends Schema.TaggedClass<OrderShipped>()("OrderShipped", {
- *   id: InputId.InputId,
- *   orderId: Schema.String,
- *   carrier: Schema.String
- * }) {}
- *
- * export const MyAssistant = Assistant.make("my-assistant", {
- *   events: [
- *     AppEvent.make(OrderShipped, {
- *       wakes: true,
- *       render: (shipped) =>
- *         `Order ${shipped.orderId} shipped with ${shipped.carrier}. Tell the user if it matters.`
- *     })
- *   ]
- * })
- * ```
- *
- * @category constructors
- * @since 0.1.0
- */
-export const make = <S extends EventSchema>(
-  schema: S,
-  options?: {
-    /** Whether storing it starts a turn, like a user's message. Default false. */
-    readonly wakes?: boolean | undefined
-    /** How the model reads it in its history. */
-    readonly render?: Render<S["Type"]> | undefined
-  }
-): AppEvent<S> => {
-  const wakes = options?.wakes ?? false
-
-  return {
-    schema,
-    tag: tagOf(schema),
-    wakes,
-    render: options?.render ?? (wakes ? "json" : undefined)
-  }
-}