effect-assistant 0.0.0-stage → 0.1.0

package/dist/ChatLog.js

@@ -0,0 +1,177 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import { ChatId } from "./ChatId.js";
+import { AssistantEvent, Entry, StoredAppEvent, isTurnEnd } from "./AssistantEvent.js";
+import * as Predicate from "effect/Predicate";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Schema from "effect/Schema";
+import * as Clock from "effect/Clock";
+import * as Ref from "effect/Ref";
+import * as SqlClient from "effect/sql/SqlClient";
+//#region src/ChatLog.ts
+/**
+* This module provides the `ChatLog` service, which stores each chat as an append-only list of
+* `AssistantEvent`s.
+*
+* A log is built on a {@link Storage}. {@link layerMemory} keeps every chat in memory, for tests
+* and local runs, and {@link layerSql} stores chats in a SQL table so they survive restarts. To
+* use another store, implement a `Storage` and pass it to {@link make}.
+*
+* @since 0.1.0
+*/
+var ChatLog_exports = /* @__PURE__ */ __exportAll({
+	ChatLog: () => ChatLog,
+	layerMemory: () => layerMemory,
+	layerSql: () => layerSql,
+	make: () => make
+});
+/**
+* Service that stores each chat's events as an ordered list of entries.
+*
+* @category services
+* @since 0.1.0
+*/
+var ChatLog = class extends Context.Service()("effect-assistant/ChatLog") {};
+/**
+* Creates a `ChatLog` from a {@link Storage}. `append` numbers new entries after the chat's last
+* `seq` and stamps them with the current time.
+*
+* @category constructors
+* @since 0.1.0
+*/
+const make = (storage) => ChatLog.of({
+	read: storage.read,
+	append: Effect.fn("ChatLog.append")(function* (chatId, events) {
+		if (events.length === 0) return [];
+		const seq = yield* storage.lastSeq(chatId);
+		const at = yield* Clock.currentTimeMillis;
+		const entries = events.map((event, n) => Entry.make({
+			chatId,
+			seq: seq + n + 1,
+			at,
+			event
+		}));
+		yield* storage.write(chatId, entries);
+		return entries;
+	}),
+	unfinished: Effect.gen(function* () {
+		return (yield* storage.lastEntries).flatMap((entry) => isTurnEnd(entry.event) || Predicate.isTagged(entry.event, "ChatDeleted") ? [] : [entry.chatId]);
+	})
+});
+/**
+* Layer that keeps every chat in memory. The log is lost when the process stops.
+*
+* @category layers
+* @since 0.1.0
+*/
+const layerMemory = Layer.effect(ChatLog, Effect.gen(function* () {
+	const chats = yield* Ref.make(/* @__PURE__ */ new Map());
+	return make({
+		read: Effect.fnUntraced(function* (chatId, options) {
+			return ((yield* Ref.get(chats)).get(chatId) ?? []).filter((entry) => entry.seq > (options?.after ?? 0));
+		}),
+		lastSeq: Effect.fnUntraced(function* (chatId) {
+			return (yield* Ref.get(chats)).get(chatId)?.at(-1)?.seq ?? 0;
+		}),
+		write: (chatId, entries) => Ref.update(chats, (all) => new Map(all).set(chatId, [...all.get(chatId) ?? [], ...entries])),
+		lastEntries: Effect.gen(function* () {
+			return [...(yield* Ref.get(chats)).values()].flatMap((entries) => entries.slice(-1));
+		})
+	});
+}));
+const EventJson = Schema.fromJsonString(Schema.Union([AssistantEvent, StoredAppEvent]));
+const SqlNumber = Schema.Union([Schema.Finite, Schema.FiniteFromString]);
+const Row = Schema.Struct({
+	chat_id: ChatId,
+	seq: SqlNumber,
+	at: SqlNumber,
+	event: EventJson
+});
+const decodeLastSeq = Schema.decodeUnknownEffect(Schema.Array(Schema.Struct({ seq: Schema.NullOr(SqlNumber) })));
+/**
+* Layer that stores chats in a SQL table named `chat_log`.
+*
+* **Details**
+*
+* The table must already exist. It has the columns `chat_id`, `seq`, `at`, and `event`, with the
+* primary key `(chat_id, seq)`. The layer requires a `SqlClient`.
+*
+* **Example** (Storing chats in Postgres)
+*
+* ```ts
+* import * as PgClient from "@effect/sql-pg/PgClient"
+* import { ChatLog } from "effect-assistant"
+* import * as Config from "effect/Config"
+* import * as Layer from "effect/Layer"
+*
+* const ChatLogLive = ChatLog.layerSql.pipe(
+*   Layer.provide(PgClient.layerConfig({ url: Config.Redacted("DATABASE_URL") }))
+* )
+* ```
+*
+* The table, in Postgres:
+*
+* ```sql
+* CREATE TABLE chat_log (
+*   chat_id TEXT NOT NULL,
+*   seq INTEGER NOT NULL,
+*   at DOUBLE PRECISION NOT NULL,
+*   event TEXT NOT NULL,
+*   PRIMARY KEY (chat_id, seq)
+* );
+* ```
+*
+* @category layers
+* @since 0.1.0
+*/
+const layerSql = Layer.effect(ChatLog, Effect.gen(function* () {
+	const sql = (yield* SqlClient.SqlClient).withoutTransforms();
+	const toEntries = Effect.fnUntraced(function* (rows) {
+		return (yield* Schema.decodeUnknownEffect(Schema.Array(Row))(rows)).map((row) => Entry.make({
+			chatId: row.chat_id,
+			seq: row.seq,
+			at: row.at,
+			event: row.event
+		}));
+	});
+	const encodeEvent = Schema.encodeEffect(EventJson);
+	return make({
+		read: Effect.fnUntraced(function* (chatId, options) {
+			const rows = yield* sql`
+          SELECT chat_id, seq, at, event FROM chat_log WHERE chat_id = ${chatId} AND seq > ${options?.after ?? 0} ORDER BY seq
+        `;
+			return yield* toEntries(rows);
+		}, Effect.orDie),
+		lastSeq: Effect.fnUntraced(function* (chatId) {
+			const result = yield* sql`
+          SELECT MAX(seq) AS seq FROM chat_log WHERE chat_id = ${chatId}
+        `;
+			return (yield* decodeLastSeq(result))[0]?.seq ?? 0;
+		}, Effect.orDie),
+		write: Effect.fnUntraced(function* (chatId, entries) {
+			const rows = yield* Effect.forEach(entries, Effect.fnUntraced(function* (entry) {
+				const event = yield* encodeEvent(entry.event);
+				return {
+					chat_id: chatId,
+					seq: entry.seq,
+					at: entry.at,
+					event
+				};
+			}));
+			yield* sql`INSERT INTO chat_log ${sql.insert(rows)}`;
+		}, Effect.orDie),
+		lastEntries: Effect.gen(function* () {
+			const rows = yield* sql`
+          SELECT e.chat_id, e.seq, e.at, e.event FROM chat_log e
+          JOIN (SELECT chat_id, MAX(seq) AS seq FROM chat_log GROUP BY chat_id) last
+            ON last.chat_id = e.chat_id AND last.seq = e.seq
+        `;
+			return yield* toEntries(rows);
+		}).pipe(Effect.orDie)
+	});
+}));
+//#endregion
+export { ChatLog, ChatLog_exports, layerMemory, layerSql, make };
+
+//# sourceMappingURL=ChatLog.js.map

package/dist/ChatLog.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChatLog.js","names":["AssistantEvent.isTurnEnd","AssistantEvent.AssistantEvent","AssistantEvent.StoredAppEvent"],"sources":["../src/ChatLog.ts"],"sourcesContent":["/**\n * This module provides the `ChatLog` service, which stores each chat as an append-only list of\n * `AssistantEvent`s.\n *\n * A log is built on a {@link Storage}. {@link layerMemory} keeps every chat in memory, for tests\n * and local runs, and {@link layerSql} stores chats in a SQL table so they survive restarts. To\n * use another store, implement a `Storage` and pass it to {@link make}.\n *\n * @since 0.1.0\n */\nimport * as Clock from \"effect/Clock\"\nimport * as Context from \"effect/Context\"\nimport * as Effect from \"effect/Effect\"\nimport * as Layer from \"effect/Layer\"\nimport * as Predicate from \"effect/Predicate\"\nimport * as Ref from \"effect/Ref\"\nimport * as Schema from \"effect/Schema\"\nimport * as SqlClient from \"effect/sql/SqlClient\"\nimport * as AssistantEvent from \"./AssistantEvent.ts\"\nimport { ChatId } from \"./ChatId.ts\"\n\n/**\n * Service that stores each chat's events as an ordered list of entries.\n *\n * @category services\n * @since 0.1.0\n */\nexport class ChatLog extends Context.Service<\n  ChatLog,\n  {\n    /** Appends events to a chat and returns them as stored entries. */\n    readonly append: (\n      chatId: ChatId,\n      events: ReadonlyArray<AssistantEvent.AssistantEvent | AssistantEvent.StoredAppEvent>\n    ) => Effect.Effect<ReadonlyArray<AssistantEvent.Entry>>\n    /** Reads a chat's stored entries in order, either all of them or only those after a `seq`. */\n    readonly read: (chatId: ChatId, options?: ReadOptions) => Effect.Effect<ReadonlyArray<AssistantEvent.Entry>>\n    /**\n     * Returns the chats whose last entry ends neither a turn nor the chat. After a restart, these\n     * are the chats that may still owe a turn.\n     */\n    readonly unfinished: Effect.Effect<ReadonlyArray<ChatId>>\n  }\n>()(\"effect-assistant/ChatLog\") {}\n\n/**\n * Represents the options that select which of a chat's entries to read.\n *\n * @category models\n * @since 0.1.0\n */\nexport interface ReadOptions {\n  /** Reads only the entries after this `seq`. */\n  readonly after?: number | undefined\n}\n\n/**\n * Represents the storage that a `ChatLog` is built on.\n *\n * A storage reads a chat's entries, finds a chat's last `seq`, writes new entries, and finds every\n * chat's last entry. Entries are never removed, so a deleted chat keeps its log, which ends in\n * `ChatDeleted`.\n *\n * @category models\n * @since 0.1.0\n */\nexport interface Storage {\n  readonly read: (chatId: ChatId, options?: ReadOptions) => Effect.Effect<ReadonlyArray<AssistantEvent.Entry>>\n  readonly lastSeq: (chatId: ChatId) => Effect.Effect<number>\n  readonly write: (chatId: ChatId, entries: ReadonlyArray<AssistantEvent.Entry>) => Effect.Effect<void>\n  /** Returns the last entry of every chat. */\n  readonly lastEntries: Effect.Effect<ReadonlyArray<AssistantEvent.Entry>>\n}\n\n/**\n * Creates a `ChatLog` from a {@link Storage}. `append` numbers new entries after the chat's last\n * `seq` and stamps them with the current time.\n *\n * @category constructors\n * @since 0.1.0\n */\nexport const make = (storage: Storage): ChatLog[\"Service\"] =>\n  ChatLog.of({\n    read: storage.read,\n    append: Effect.fn(\"ChatLog.append\")(function* (\n      chatId: ChatId,\n      events: ReadonlyArray<AssistantEvent.AssistantEvent | AssistantEvent.StoredAppEvent>\n    ) {\n      if (events.length === 0) return []\n\n      const seq = yield* storage.lastSeq(chatId)\n      const at = yield* Clock.currentTimeMillis\n      const entries = events.map((event, n) => AssistantEvent.Entry.make({ chatId, seq: seq + n + 1, at, event }))\n\n      yield* storage.write(chatId, entries)\n\n      return entries\n    }),\n    unfinished: Effect.gen(function* () {\n      const last = yield* storage.lastEntries\n\n      // A deleted chat owes nothing.\n      return last.flatMap((entry) =>\n        AssistantEvent.isTurnEnd(entry.event) || Predicate.isTagged(entry.event, \"ChatDeleted\") ? [] : [entry.chatId]\n      )\n    })\n  })\n\n/**\n * Layer that keeps every chat in memory. The log is lost when the process stops.\n *\n * @category layers\n * @since 0.1.0\n */\nexport const layerMemory: Layer.Layer<ChatLog> = Layer.effect(\n  ChatLog,\n  Effect.gen(function* () {\n    const chats = yield* Ref.make(new Map<ChatId, ReadonlyArray<AssistantEvent.Entry>>())\n\n    return make({\n      read: Effect.fnUntraced(function* (chatId: ChatId, options?: ReadOptions) {\n        const all = yield* Ref.get(chats)\n\n        return (all.get(chatId) ?? []).filter((entry) => entry.seq > (options?.after ?? 0))\n      }),\n      lastSeq: Effect.fnUntraced(function* (chatId: ChatId) {\n        const all = yield* Ref.get(chats)\n\n        return all.get(chatId)?.at(-1)?.seq ?? 0\n      }),\n      write: (chatId, entries) =>\n        Ref.update(chats, (all) => new Map(all).set(chatId, [...(all.get(chatId) ?? []), ...entries])),\n      lastEntries: Effect.gen(function* () {\n        const all = yield* Ref.get(chats)\n\n        return [...all.values()].flatMap((entries) => entries.slice(-1))\n      })\n    })\n  })\n)\n\nconst EventJson = Schema.fromJsonString(Schema.Union([AssistantEvent.AssistantEvent, AssistantEvent.StoredAppEvent]))\n\n// Postgres returns BIGINT and DOUBLE PRECISION columns as strings; other databases as numbers.\nconst SqlNumber = Schema.Union([Schema.Finite, Schema.FiniteFromString])\n\nconst Row = Schema.Struct({ chat_id: ChatId, seq: SqlNumber, at: SqlNumber, event: EventJson })\n\nconst decodeLastSeq = Schema.decodeUnknownEffect(Schema.Array(Schema.Struct({ seq: Schema.NullOr(SqlNumber) })))\n\n/**\n * Layer that stores chats in a SQL table named `chat_log`.\n *\n * **Details**\n *\n * The table must already exist. It has the columns `chat_id`, `seq`, `at`, and `event`, with the\n * primary key `(chat_id, seq)`. The layer requires a `SqlClient`.\n *\n * **Example** (Storing chats in Postgres)\n *\n * ```ts\n * import * as PgClient from \"@effect/sql-pg/PgClient\"\n * import { ChatLog } from \"effect-assistant\"\n * import * as Config from \"effect/Config\"\n * import * as Layer from \"effect/Layer\"\n *\n * const ChatLogLive = ChatLog.layerSql.pipe(\n *   Layer.provide(PgClient.layerConfig({ url: Config.Redacted(\"DATABASE_URL\") }))\n * )\n * ```\n *\n * The table, in Postgres:\n *\n * ```sql\n * CREATE TABLE chat_log (\n *   chat_id TEXT NOT NULL,\n *   seq INTEGER NOT NULL,\n *   at DOUBLE PRECISION NOT NULL,\n *   event TEXT NOT NULL,\n *   PRIMARY KEY (chat_id, seq)\n * );\n * ```\n *\n * @category layers\n * @since 0.1.0\n */\nexport const layerSql: Layer.Layer<ChatLog, never, SqlClient.SqlClient> = Layer.effect(\n  ChatLog,\n  Effect.gen(function* () {\n    const sql = (yield* SqlClient.SqlClient).withoutTransforms()\n\n    const toEntries = Effect.fnUntraced(function* (rows: ReadonlyArray<unknown>) {\n      const decoded = yield* Schema.decodeUnknownEffect(Schema.Array(Row))(rows)\n\n      return decoded.map((row) =>\n        AssistantEvent.Entry.make({\n          chatId: row.chat_id,\n          seq: row.seq,\n          at: row.at,\n          event: row.event\n        })\n      )\n    })\n\n    const encodeEvent = Schema.encodeEffect(EventJson)\n\n    return make({\n      read: Effect.fnUntraced(function* (chatId: ChatId, options?: ReadOptions) {\n        const rows = yield* sql`\n          SELECT chat_id, seq, at, event FROM chat_log WHERE chat_id = ${chatId} AND seq > ${options?.after ?? 0} ORDER BY seq\n        `\n\n        return yield* toEntries(rows)\n      }, Effect.orDie),\n      lastSeq: Effect.fnUntraced(function* (chatId: ChatId) {\n        const result = yield* sql`\n          SELECT MAX(seq) AS seq FROM chat_log WHERE chat_id = ${chatId}\n        `\n\n        const rows = yield* decodeLastSeq(result)\n\n        return rows[0]?.seq ?? 0\n      }, Effect.orDie),\n      write: Effect.fnUntraced(function* (chatId: ChatId, entries: ReadonlyArray<AssistantEvent.Entry>) {\n        const rows = yield* Effect.forEach(\n          entries,\n          Effect.fnUntraced(function* (entry: AssistantEvent.Entry) {\n            const event = yield* encodeEvent(entry.event)\n\n            return { chat_id: chatId, seq: entry.seq, at: entry.at, event }\n          })\n        )\n\n        yield* sql`INSERT INTO chat_log ${sql.insert(rows)}`\n      }, Effect.orDie),\n      lastEntries: Effect.gen(function* () {\n        const rows = yield* sql`\n          SELECT e.chat_id, e.seq, e.at, e.event FROM chat_log e\n          JOIN (SELECT chat_id, MAX(seq) AS seq FROM chat_log GROUP BY chat_id) last\n            ON last.chat_id = e.chat_id AND last.seq = e.seq\n        `\n\n        return yield* toEntries(rows)\n      }).pipe(Effect.orDie)\n    })\n  })\n)\n"],"mappings":"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"}

package/dist/ChatView.d.ts

@@ -0,0 +1,459 @@
+import { AnyEntry, AssistantEvent_d_exports } from "./AssistantEvent.js";
+import * as Schema from "effect/Schema";
+import * as Stream from "effect/Stream";
+declare namespace ChatView_d_exports {
+  export { Activity, AssistantMessage, Block, BlockStatus, Definition, Message, Options, PendingDecision, SpecialistWorking, Update, UpdatesOptions, UserMessage, View, apply, empty, fromEntries, isIdle, updates };
+}
+/**
+ * Schema for a decision as the user sees it on a decision block. It holds the call the decision is
+ * for (its tool and params, which the app can display as it likes) and, once the user has
+ * decided, the outcome.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare const PendingDecision: Schema.Struct<{
+  readonly id: Schema.brand<Schema.TemplateLiteral<readonly ["decision:", Schema.String]>, "~effect-assistant/DecisionId">;
+  readonly tool: Schema.String;
+  readonly params: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+  readonly outcome: Schema.optional<Schema.Literals<readonly ["approved", "declined"]>>;
+}>;
+/**
+ * Represents a decision as the user sees it.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type PendingDecision = typeof PendingDecision.Type;
+/**
+ * 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
+ */
+export declare const BlockStatus: Schema.Literals<readonly ["open", "answered", "closed"]>;
+/**
+ * The status of a block.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type BlockStatus = typeof BlockStatus.Type;
+/**
+ * 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, the user's answer (JSON, as the block's
+ * answer schema encodes it), and, for a decision block, its decisions.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare const Block: Schema.Struct<{
+  readonly kind: Schema.String;
+  readonly props: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+  readonly status: Schema.Literals<readonly ["open", "answered", "closed"]>;
+  readonly answer: Schema.optional<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+  readonly decisions: Schema.optional<Schema.$Array<Schema.Struct<{
+    readonly id: Schema.brand<Schema.TemplateLiteral<readonly ["decision:", Schema.String]>, "~effect-assistant/DecisionId">;
+    readonly tool: Schema.String;
+    readonly params: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly outcome: Schema.optional<Schema.Literals<readonly ["approved", "declined"]>>;
+  }>>>;
+}>;
+/**
+ * Represents a block on an assistant's message.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type Block = typeof Block.Type;
+/**
+ * Schema for a message the user sent. `at` is when it was stored, in epoch
+ * milliseconds.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare const UserMessage: Schema.TaggedStruct<"UserMessage", {
+  readonly id: Schema.brand<Schema.String, "~effect-assistant/InputId">;
+  readonly text: Schema.String;
+  readonly attachments: Schema.optional<Schema.$Array<Schema.Struct<{
+    readonly fileId: Schema.String;
+    readonly name: Schema.String;
+    readonly mediaType: Schema.String;
+    readonly size: Schema.Finite;
+  }>>>;
+  readonly at: Schema.Finite;
+}>;
+/**
+ * Represents a message the user sent.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type UserMessage = typeof UserMessage.Type;
+/**
+ * Schema for a message the assistant sent the user, including its block if it has one.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare const AssistantMessage: Schema.TaggedStruct<"AssistantMessage", {
+  readonly id: Schema.String;
+  readonly text: Schema.String;
+  readonly at: Schema.Finite;
+  readonly block: Schema.optional<Schema.Struct<{
+    readonly kind: Schema.String;
+    readonly props: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly status: Schema.Literals<readonly ["open", "answered", "closed"]>;
+    readonly answer: Schema.optional<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    readonly decisions: Schema.optional<Schema.$Array<Schema.Struct<{
+      readonly id: Schema.brand<Schema.TemplateLiteral<readonly ["decision:", Schema.String]>, "~effect-assistant/DecisionId">;
+      readonly tool: Schema.String;
+      readonly params: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+      readonly outcome: Schema.optional<Schema.Literals<readonly ["approved", "declined"]>>;
+    }>>>;
+  }>>;
+}>;
+/**
+ * Represents a message the assistant sent the user.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type AssistantMessage = typeof AssistantMessage.Type;
+/**
+ * Schema for a message in the chat, sent by either the user or the assistant.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare const Message: Schema.Union<readonly [Schema.TaggedStruct<"UserMessage", {
+  readonly id: Schema.brand<Schema.String, "~effect-assistant/InputId">;
+  readonly text: Schema.String;
+  readonly attachments: Schema.optional<Schema.$Array<Schema.Struct<{
+    readonly fileId: Schema.String;
+    readonly name: Schema.String;
+    readonly mediaType: Schema.String;
+    readonly size: Schema.Finite;
+  }>>>;
+  readonly at: Schema.Finite;
+}>, Schema.TaggedStruct<"AssistantMessage", {
+  readonly id: Schema.String;
+  readonly text: Schema.String;
+  readonly at: Schema.Finite;
+  readonly block: Schema.optional<Schema.Struct<{
+    readonly kind: Schema.String;
+    readonly props: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly status: Schema.Literals<readonly ["open", "answered", "closed"]>;
+    readonly answer: Schema.optional<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    readonly decisions: Schema.optional<Schema.$Array<Schema.Struct<{
+      readonly id: Schema.brand<Schema.TemplateLiteral<readonly ["decision:", Schema.String]>, "~effect-assistant/DecisionId">;
+      readonly tool: Schema.String;
+      readonly params: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+      readonly outcome: Schema.optional<Schema.Literals<readonly ["approved", "declined"]>>;
+    }>>>;
+  }>>;
+}>]>;
+/**
+ * Represents a message in the chat.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type Message = typeof Message.Type;
+/**
+ * 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
+ */
+export declare const SpecialistWorking: Schema.Struct<{
+  readonly specialist: Schema.String;
+  readonly since: Schema.Finite;
+}>;
+/**
+ * Represents a specialist that is working for the assistant.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type SpecialistWorking = typeof SpecialistWorking.Type;
+/**
+ * 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 a decision.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare const Activity: Schema.Struct<{
+  readonly working: Schema.Boolean;
+  readonly specialists: Schema.$Array<Schema.Struct<{
+    readonly specialist: Schema.String;
+    readonly since: Schema.Finite;
+  }>>;
+}>;
+/**
+ * Represents what is working in the chat.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type Activity = typeof Activity.Type;
+/**
+ * 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
+ */
+export declare const View: Schema.Struct<{
+  readonly seq: Schema.Int;
+  readonly messages: Schema.$Array<Schema.Union<readonly [Schema.TaggedStruct<"UserMessage", {
+    readonly id: Schema.brand<Schema.String, "~effect-assistant/InputId">;
+    readonly text: Schema.String;
+    readonly attachments: Schema.optional<Schema.$Array<Schema.Struct<{
+      readonly fileId: Schema.String;
+      readonly name: Schema.String;
+      readonly mediaType: Schema.String;
+      readonly size: Schema.Finite;
+    }>>>;
+    readonly at: Schema.Finite;
+  }>, Schema.TaggedStruct<"AssistantMessage", {
+    readonly id: Schema.String;
+    readonly text: Schema.String;
+    readonly at: Schema.Finite;
+    readonly block: Schema.optional<Schema.Struct<{
+      readonly kind: Schema.String;
+      readonly props: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+      readonly status: Schema.Literals<readonly ["open", "answered", "closed"]>;
+      readonly answer: Schema.optional<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+      readonly decisions: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly id: Schema.brand<Schema.TemplateLiteral<readonly ["decision:", Schema.String]>, "~effect-assistant/DecisionId">;
+        readonly tool: Schema.String;
+        readonly params: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly outcome: Schema.optional<Schema.Literals<readonly ["approved", "declined"]>>;
+      }>>>;
+    }>>;
+  }>]>>;
+  readonly activity: Schema.Struct<{
+    readonly working: Schema.Boolean;
+    readonly specialists: Schema.$Array<Schema.Struct<{
+      readonly specialist: Schema.String;
+      readonly since: Schema.Finite;
+    }>>;
+  }>;
+  /** Whether the last turn failed with no message after it. */
+  readonly failed: Schema.Boolean;
+  /** Whether the chat was deleted. A deleted chat accepts nothing more, and its stream ends. */
+  readonly deleted: Schema.Boolean;
+}>;
+/**
+ * Represents a chat as its user sees it.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type View = typeof View.Type;
+/**
+ * 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,
+ * or a decision made), 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
+ */
+export declare const Update: Schema.Struct<{
+  readonly seq: Schema.Int;
+  readonly messages: Schema.$Array<Schema.Union<readonly [Schema.TaggedStruct<"UserMessage", {
+    readonly id: Schema.brand<Schema.String, "~effect-assistant/InputId">;
+    readonly text: Schema.String;
+    readonly attachments: Schema.optional<Schema.$Array<Schema.Struct<{
+      readonly fileId: Schema.String;
+      readonly name: Schema.String;
+      readonly mediaType: Schema.String;
+      readonly size: Schema.Finite;
+    }>>>;
+    readonly at: Schema.Finite;
+  }>, Schema.TaggedStruct<"AssistantMessage", {
+    readonly id: Schema.String;
+    readonly text: Schema.String;
+    readonly at: Schema.Finite;
+    readonly block: Schema.optional<Schema.Struct<{
+      readonly kind: Schema.String;
+      readonly props: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+      readonly status: Schema.Literals<readonly ["open", "answered", "closed"]>;
+      readonly answer: Schema.optional<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+      readonly decisions: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly id: Schema.brand<Schema.TemplateLiteral<readonly ["decision:", Schema.String]>, "~effect-assistant/DecisionId">;
+        readonly tool: Schema.String;
+        readonly params: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly outcome: Schema.optional<Schema.Literals<readonly ["approved", "declined"]>>;
+      }>>>;
+    }>>;
+  }>]>>;
+  readonly activity: Schema.Struct<{
+    readonly working: Schema.Boolean;
+    readonly specialists: Schema.$Array<Schema.Struct<{
+      readonly specialist: Schema.String;
+      readonly since: Schema.Finite;
+    }>>;
+  }>;
+  readonly failed: Schema.Boolean;
+  readonly deleted: Schema.Boolean;
+}>;
+/**
+ * Represents a change to a chat's view.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type Update = typeof Update.Type;
+/**
+ * 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
+ */
+export declare const empty: View;
+/**
+ * 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
+ */
+export declare const apply: (view: View, update: Update) => View;
+/**
+ * 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
+ */
+export declare const isIdle: (view: View) => boolean;
+/**
+ * Represents the options for building a view from a chat's log.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export interface Options {
+  /**
+   * The tags of the app's events that wake a turn. After such an event, the view shows a turn as
+   * about to start. Defaults to none.
+   */
+  readonly wakes?: ReadonlySet<string> | undefined;
+}
+/**
+ * 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
+ */
+export declare const fromEntries: (entries: ReadonlyArray<AnyEntry>, options?: Options) => View;
+/**
+ * Represents an assistant's definition as {@link updates} reads it: the app's events it
+ * registered, and whether each one wakes a turn. An assistant made with `Assistant.make` fits it.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export interface Definition {
+  readonly events: ReadonlyArray<{
+    readonly tag: string;
+    readonly wakes: boolean;
+  }>;
+}
+/**
+ * Represents the options accepted by {@link updates}.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export interface UpdatesOptions {
+  /**
+   * The `seq` up to which the client already has the view. The result contains only the updates
+   * after it. Defaults to `0`, every update.
+   */
+  readonly after?: number | undefined;
+}
+/**
+ * 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, and a decision is made 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
+ */
+export declare const updates: {
+  (definition: Definition, options?: UpdatesOptions): <E, R>(entries: Stream.Stream<AnyEntry, E, R>) => Stream.Stream<Update, E, R>;
+  <E, R>(entries: Stream.Stream<AnyEntry, E, R>, definition: Definition, options?: UpdatesOptions): Stream.Stream<Update, E, R>;
+};
+//#endregion
+export { ChatView_d_exports };
+//# sourceMappingURL=ChatView.d.ts.map

package/dist/ChatView.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChatView.d.ts","names":[],"sources":["../src/ChatView.ts"],"mappings":";;;;;;;;;;;;;;qBAkCa,iBAAe,OAAA;;;;;;;;;;;;YAahB,yBAAyB,gBAAgB;;;;;;;;;qBAUxC,aAAW,OAAA;;;;;;;YAQZ,qBAAqB,YAAY;;;;;;;;;qBAUhC,OAAK,OAAA;;;;;;;;;;;;;;;;;;YAcN,eAAe,MAAM;;;;;;;;qBASpB,aAAW,OAAA;;;;;;;;;;;;;;;;;YAaZ,qBAAqB,YAAY;;;;;;;qBAQhC,kBAAgB,OAAA;;;;;;;;;;;;;;;;;;;;;;;YAajB,0BAA0B,iBAAiB;;;;;;;qBAQ1C,SAAO,OAAA,gBAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAQR,iBAAiB,QAAQ;;;;;;;;qBASxB,mBAAiB,OAAA;;;;;;;;;;YAWlB,2BAA2B,kBAAkB;;;;;;;;;;;qBAY5C,UAAQ,OAAA;;;;;;;;;;;;;YAWT,kBAAkB,SAAS;;;;;;;;;qBAU1B,MAAI,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAgBL,cAAc,KAAK;;;;;;;;;;;;qBAalB,QAAM,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAcP,gBAAgB,OAAO;;;;;;;;qBAStB,OAAO;;;;;;;;;;;;;;qBAqBP,QAAK,MAAU,MAAI,QAAU,WAAS;;;;;;;;qBAuBtC,SAAM,MAAU;;;;;;;iBAQZ;;;;;WAKN,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA4BN,cAAW,SAAa,cAAc,WAAwB,UAAY,YAAU;;;;;;;;iBAgOhF;WACN,QAAQ;aAAyB;aAAsB;;;;;;;;;iBASjD;;;;;WAKN;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA2CE;GAET,YAAY,YACZ,UAAU,kBACR,GAAG,GAAG,SAAS,OAAO,OAAO,UAAyB,GAAG,OAAO,OAAO,OAAO,QAAQ,GAAG;GAC5F,GAAG,GACF,SAAS,OAAO,OAAO,UAAyB,GAAG,IACnD,YAAY,YACZ,UAAU,iBACT,OAAO,OAAO,QAAQ,GAAG"}