effect-assistant 0.0.0-stage → 0.1.0

package/dist/BlockKit.d.ts

@@ -0,0 +1,184 @@
+import { AnyEntry, AssistantEvent_d_exports, BlockAnswer } from "./AssistantEvent.js";
+import { Any, Block_d_exports } from "./Block.js";
+import { AssistantMessage, ChatView_d_exports, PendingDecision } from "./ChatView.js";
+import { CurrentChat } from "./CurrentChat.js";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+declare namespace BlockKit_d_exports {
+  export { BlockKit, RenderArgs, RenderOptions, Renderers, State, apply, closeStale, fromEntries, make, staleBlocks, toClient };
+}
+/**
+ * Represents a catalog of blocks, with a lookup by kind.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export interface BlockKit<Blocks extends Any = Any> {
+  readonly blocks: ReadonlyArray<Blocks>;
+  readonly byKind: ReadonlyMap<string, Blocks>;
+}
+/**
+ * Creates a kit from blocks.
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export declare const make: <const Blocks extends ReadonlyArray<Any>>(blocks: Blocks) => BlockKit<Blocks[number]>;
+type KindOf<B> = B extends {
+  readonly kind: infer K extends string;
+} ? K : never;
+type BlockOf<Kit extends BlockKit, K> = Extract<Kit["blocks"][number], {
+  readonly kind: K;
+}>;
+type PropsOf<B> = B extends {
+  readonly props: Schema.Top;
+} ? B["props"]["Type"] : never;
+type AnswerOf<B> = B extends {
+  readonly answer: infer A;
+} ? (A extends Schema.Top ? A["Type"] : never) : never;
+/**
+ * Represents the state of a message's block.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export interface State {
+  readonly open: boolean;
+  /** The user's answer, if they used the block. */
+  readonly answer: BlockAnswer | undefined;
+}
+/**
+ * Returns the block states after one more event.
+ *
+ * @category utils
+ * @since 0.1.0
+ */
+export declare const apply: (states: ReadonlyMap<string, State>, event: {
+  readonly _tag: string;
+}) => ReadonlyMap<string, State>;
+/**
+ * Returns the state of every message's block, by message id.
+ *
+ * @category utils
+ * @since 0.1.0
+ */
+export declare const fromEntries: (entries: ReadonlyArray<AnyEntry>) => ReadonlyMap<string, State>;
+/**
+ * Returns the ids of the messages whose blocks are still open after the user typed the given
+ * number of messages without using them.
+ *
+ * **Details**
+ *
+ * These are the blocks {@link closeStale} closes. Decision blocks never go stale, since work waits
+ * on them and closing one would leave it waiting.
+ *
+ * @category utils
+ * @since 0.1.0
+ */
+export declare const staleBlocks: (entries: ReadonlyArray<AnyEntry>, options: {
+  readonly messages: number;
+}) => ReadonlyArray<string>;
+/**
+ * Closes the blocks the user moved on from, which are still open after the given number of typed
+ * messages.
+ *
+ * **Details**
+ *
+ * Run it from a turn, before or after its loop. It records a `BlocksClosed` event, so every
+ * client folds the blocks closed.
+ *
+ * @see {@link staleBlocks} for the blocks it closes
+ *
+ * @category utils
+ * @since 0.1.0
+ */
+export declare const closeStale: (options: {
+  readonly messages: number;
+}) => Effect.Effect<void, never, CurrentChat>;
+/**
+ * Represents what a renderer receives for one block.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export interface RenderArgs<B> {
+  readonly text: string;
+  readonly props: PropsOf<B>;
+  /**
+   * Whether the block is open. It is `false` once the block is answered, with the block or in
+   * words; show it read-only then.
+   */
+  readonly open: boolean;
+  /** The user's answer, if they used the block. */
+  readonly answer: AnswerOf<B> | undefined;
+  /**
+   * For the decision block, the call each decision is for (its tool and params) and how it was
+   * decided. Empty for other blocks.
+   */
+  readonly decisions: ReadonlyArray<PendingDecision>;
+  /** Sends an answer. Only call it while `open`. */
+  readonly respond: (answer: AnswerOf<B>) => void;
+}
+/**
+ * Represents a renderer for every kind in a kit.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type Renderers<Kit extends BlockKit, Out> = { readonly [K in KindOf<Kit["blocks"][number]>]: (args: RenderArgs<BlockOf<Kit, K>>) => Out; };
+/**
+ * Represents the options for rendering one message's block.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export interface RenderOptions {
+  /** Submits an answer, for example over RPC. */
+  readonly respond: (answer: BlockAnswer) => void;
+}
+/**
+ * Creates a client-side renderer for the blocks on a chat view's messages
+ * (`ChatView.AssistantMessage`).
+ *
+ * **Details**
+ *
+ * The renderers are type-checked, so every kind in the kit needs one, and each receives typed
+ * `props` and `answer`. A renderer's `respond` builds a `BlockAnswer` input, with the answer
+ * encoded by the block's answer schema, and passes it to the `respond` option to submit.
+ *
+ * The returned function returns `undefined` for a message without a block, or with a block it
+ * can't decode or has no renderer for.
+ *
+ * **Example** (Rendering blocks with React)
+ *
+ * ```tsx
+ * import { BlockKit, Decision } from "effect-assistant"
+ * import type { ReactNode } from "react"
+ *
+ * const Blocks = BlockKit.make([PickOne, Decision.block])
+ *
+ * const renderBlock = BlockKit.toClient<typeof Blocks, ReactNode>(Blocks, {
+ *   pick_one: ({ props, open, respond }) =>
+ *     props.options.map((option) => (
+ *       <button key={option} disabled={!open} onClick={() => respond({ picked: option })}>
+ *         {option}
+ *       </button>
+ *     )),
+ *   decision: ({ props, open, respond }) => (
+ *     <button disabled={!open} onClick={() => respond(Decision.answerAll(props, "approved"))}>
+ *       {props.approveLabel ?? "Approve"}
+ *     </button>
+ *   )
+ * })
+ *
+ * // For each AssistantMessage in the chat's view:
+ * renderBlock(message, { respond: (answer) => submit(answer) })
+ * ```
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export declare function toClient<Kit extends BlockKit, Out>(kit: Kit, renderers: Renderers<Kit, Out>): (message: AssistantMessage, options: RenderOptions) => Out | undefined;
+//#endregion
+export { BlockKit_d_exports };
+//# sourceMappingURL=BlockKit.d.ts.map

package/dist/BlockKit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BlockKit.d.ts","names":[],"sources":["../src/BlockKit.ts"],"mappings":";;;;;;;;;;;;;;;iBA2BiB,SAAS,eAAe,MAAY;WAC1C,QAAQ,cAAc;WACtB,QAAQ,oBAAoB;;;;;;;;qBAS1B,aAAc,eAAe,cAAc,MAAU,QAAU,WAAS,SAAS;KAKzF,OAAO,KAAK;WAAqB,YAAY;IAAqB;KAElE,QAAQ,YAAY,UAAU,KAAK,QAAQ;WAAkC,MAAM;;KAEnF,QAAQ,KAAK;WAAqB,OAAO,OAAO;IAAQ;KAExD,SAAS,KAAK;WAAqB,cAAc;KAAO,UAAU,OAAO,MAAM;;;;;;;iBAQnE;WACN;;WAEA,QAAQ;;;;;;;;qBASN,QAAK,QACR,oBAAoB,QAAM;WAChB;MACjB,oBAAoB;;;;;;;qBAkCV,cAAW,SAAa,cAAc,cAA2B,oBAAoB;;;;;;;;;;;;;qBAoBrF,cAAW,SACb,cAAc,WAAwB;WAC3B;MACnB;;;;;;;;;;;;;;;qBAuCU,aAAU;WAAsD;MAK3E,OAAA,oBAAA;;;;;;;iBAQe,WAAW;WACjB;WACA,OAAO,QAAQ;;;;;WAKf;;WAEA,QAAQ,SAAS;;;;;WAKjB,WAAW,cAAc;;WAEzB,UAAU,QAAQ,SAAS;;;;;;;;YAS1B,UAAU,YAAY,UAAU,mBAChC,KAAK,OAAO,0BAA0B,MAAM,WAAW,QAAQ,KAAK,QAAQ;;;;;;;iBASvE;;WAEN,UAAU,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA6Cb,SAAS,YAAY,UAAU,KAC7C,KAAK,KACL,WAAW,UAAU,KAAK,QACxB,SAAS,kBAA2B,SAAS,kBAAkB"}

package/dist/BlockKit.js

@@ -0,0 +1,151 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import { fromKey } from "./InputId.js";
+import { BlockAnswer, BlocksClosed, isLibraryEvent } from "./AssistantEvent.js";
+import { CurrentChat } from "./CurrentChat.js";
+import "./Decision.js";
+import * as Predicate from "effect/Predicate";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import * as Option from "effect/Option";
+//#region src/BlockKit.ts
+/**
+* Groups the blocks an assistant may put in its messages, and renders them on the client.
+*
+* A kit is created with {@link make} and passed to `Assistant.make`. {@link fromEntries} computes
+* the state of every message's block from a chat's log, {@link closeStale} closes the blocks the
+* user moved on from, and {@link toClient} creates a client-side renderer with one function per
+* block kind.
+*
+* @since 0.1.0
+*/
+var BlockKit_exports = /* @__PURE__ */ __exportAll({
+	apply: () => apply,
+	closeStale: () => closeStale,
+	fromEntries: () => fromEntries,
+	make: () => make,
+	staleBlocks: () => staleBlocks,
+	toClient: () => toClient
+});
+/**
+* Creates a kit from blocks.
+*
+* @category constructors
+* @since 0.1.0
+*/
+const make = (blocks) => ({
+	blocks,
+	byKind: new Map(blocks.map((block) => [block.kind, block]))
+});
+/**
+* Returns the block states after one more event.
+*
+* @category utils
+* @since 0.1.0
+*/
+const apply = (states, event) => {
+	if (!isLibraryEvent(event)) return states;
+	const close = (ids) => {
+		const open = ids.filter((id) => states.get(id)?.open === true);
+		if (open.length === 0) return states;
+		const next = new Map(states);
+		for (const id of open) next.set(id, {
+			open: false,
+			answer: void 0
+		});
+		return next;
+	};
+	if (Predicate.isTagged(event, "BlocksClosed")) return close(event.messageIds);
+	if (Predicate.isTagged(event, "AssistantMessage")) {
+		const closed = close(event.closes ?? []);
+		return event.block === void 0 ? closed : new Map(closed).set(event.id, {
+			open: true,
+			answer: void 0
+		});
+	}
+	if (!Predicate.isTagged(event, "BlockAnswer") || states.get(event.messageId)?.open !== true) return states;
+	return new Map(states).set(event.messageId, {
+		open: false,
+		answer: event
+	});
+};
+/**
+* Returns the state of every message's block, by message id.
+*
+* @category utils
+* @since 0.1.0
+*/
+const fromEntries = (entries) => {
+	let states = /* @__PURE__ */ new Map();
+	for (const entry of entries) states = apply(states, entry.event);
+	return states;
+};
+/**
+* Returns the ids of the messages whose blocks are still open after the user typed the given
+* number of messages without using them.
+*
+* **Details**
+*
+* These are the blocks {@link closeStale} closes. Decision blocks never go stale, since work waits
+* on them and closing one would leave it waiting.
+*
+* @category utils
+* @since 0.1.0
+*/
+const staleBlocks = (entries, options) => {
+	return [...fromEntries(entries)].flatMap(([id, state]) => state.open ? [id] : []).filter((id) => {
+		const shown = entries.findIndex(({ event }) => isLibraryEvent(event) && Predicate.isTagged(event, "AssistantMessage") && event.id === id);
+		const message = entries[shown]?.event;
+		if (message === void 0 || isLibraryEvent(message) && Predicate.isTagged(message, "AssistantMessage") && message.block?.kind === "decision") return false;
+		return entries.slice(shown + 1).filter(({ event }) => Predicate.isTagged(event, "UserMessage")).length >= options.messages;
+	});
+};
+/**
+* Closes the blocks the user moved on from, which are still open after the given number of typed
+* messages.
+*
+* **Details**
+*
+* Run it from a turn, before or after its loop. It records a `BlocksClosed` event, so every
+* client folds the blocks closed.
+*
+* @see {@link staleBlocks} for the blocks it closes
+*
+* @category utils
+* @since 0.1.0
+*/
+const closeStale = Effect.fn(function* (options) {
+	const chat = yield* CurrentChat;
+	const stale = staleBlocks(yield* chat.entries, options);
+	if (stale.length > 0) yield* chat.append(BlocksClosed.make({ messageIds: stale }));
+});
+function toClient(kit, renderers) {
+	return (message, options) => {
+		if (message.block === void 0) return void 0;
+		const { kind } = message.block;
+		const block = kit.byKind.get(kind);
+		const render = renderers[kind];
+		if (block === void 0 || render === void 0) return void 0;
+		const props = Schema.decodeUnknownOption(block.props)(message.block.props);
+		if (Option.isNone(props)) return void 0;
+		const given = message.block.answer;
+		const answerCodec = block.answer === void 0 ? void 0 : Schema.toCodecJson(block.answer);
+		const answer = given === void 0 || answerCodec === void 0 ? Option.none() : Schema.decodeUnknownOption(answerCodec)(given);
+		return render({
+			text: message.text,
+			props: props.value,
+			open: message.block.status === "open",
+			answer: Option.getOrUndefined(answer),
+			decisions: message.block.decisions ?? [],
+			respond: (value) => options.respond(BlockAnswer.make({
+				id: fromKey(`${message.id}:answer`),
+				messageId: message.id,
+				kind,
+				value: answerCodec === void 0 ? value : Schema.encodeUnknownSync(answerCodec)(value)
+			}))
+		});
+	};
+}
+//#endregion
+export { BlockKit_exports, apply, closeStale, fromEntries, make, staleBlocks, toClient };
+
+//# sourceMappingURL=BlockKit.js.map

package/dist/BlockKit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BlockKit.js","names":["AssistantEvent.isLibraryEvent","InputId.fromKey"],"sources":["../src/BlockKit.ts"],"sourcesContent":["/**\n * Groups the blocks an assistant may put in its messages, and renders them on the client.\n *\n * A kit is created with {@link make} and passed to `Assistant.make`. {@link fromEntries} computes\n * the state of every message's block from a chat's log, {@link closeStale} closes the blocks the\n * user moved on from, and {@link toClient} creates a client-side renderer with one function per\n * block kind.\n *\n * @since 0.1.0\n */\nimport * as Effect from \"effect/Effect\"\nimport * as Option from \"effect/Option\"\nimport * as Predicate from \"effect/Predicate\"\nimport * as Schema from \"effect/Schema\"\nimport * as AssistantEvent from \"./AssistantEvent.ts\"\nimport type * as Block from \"./Block.ts\"\nimport type * as ChatView from \"./ChatView.ts\"\nimport { CurrentChat } from \"./CurrentChat.ts\"\nimport * as Decision from \"./Decision.ts\"\nimport * as InputId from \"./InputId.ts\"\n\n/**\n * Represents a catalog of blocks, with a lookup by kind.\n *\n * @category models\n * @since 0.1.0\n */\nexport interface BlockKit<Blocks extends Block.Any = Block.Any> {\n  readonly blocks: ReadonlyArray<Blocks>\n  readonly byKind: ReadonlyMap<string, Blocks>\n}\n\n/**\n * Creates a kit from blocks.\n *\n * @category constructors\n * @since 0.1.0\n */\nexport const make = <const Blocks extends ReadonlyArray<Block.Any>>(blocks: Blocks): BlockKit<Blocks[number]> => ({\n  blocks,\n  byKind: new Map(blocks.map((block) => [block.kind, block]))\n})\n\ntype KindOf<B> = B extends { readonly kind: infer K extends string } ? K : never\n\ntype BlockOf<Kit extends BlockKit, K> = Extract<Kit[\"blocks\"][number], { readonly kind: K }>\n\ntype PropsOf<B> = B extends { readonly props: Schema.Top } ? B[\"props\"][\"Type\"] : never\n\ntype AnswerOf<B> = B extends { readonly answer: infer A } ? (A extends Schema.Top ? A[\"Type\"] : never) : never\n\n/**\n * Represents the state of a message's block.\n *\n * @category models\n * @since 0.1.0\n */\nexport interface State {\n  readonly open: boolean\n  /** The user's answer, if they used the block. */\n  readonly answer: AssistantEvent.BlockAnswer | undefined\n}\n\n/**\n * Returns the block states after one more event.\n *\n * @category utils\n * @since 0.1.0\n */\nexport const apply = (\n  states: ReadonlyMap<string, State>,\n  event: { readonly _tag: string }\n): ReadonlyMap<string, State> => {\n  if (!AssistantEvent.isLibraryEvent(event)) return states\n\n  const close = (ids: ReadonlyArray<string>) => {\n    const open = ids.filter((id) => states.get(id)?.open === true)\n\n    if (open.length === 0) return states\n\n    const next = new Map(states)\n\n    for (const id of open) next.set(id, { open: false, answer: undefined })\n\n    return next\n  }\n\n  if (Predicate.isTagged(event, \"BlocksClosed\")) return close(event.messageIds)\n\n  if (Predicate.isTagged(event, \"AssistantMessage\")) {\n    const closed = close(event.closes ?? [])\n\n    return event.block === undefined ? closed : new Map(closed).set(event.id, { open: true, answer: undefined })\n  }\n\n  if (!Predicate.isTagged(event, \"BlockAnswer\") || states.get(event.messageId)?.open !== true) return states\n\n  return new Map(states).set(event.messageId, { open: false, answer: event })\n}\n\n/**\n * Returns the state of every message's block, by message id.\n *\n * @category utils\n * @since 0.1.0\n */\nexport const fromEntries = (entries: ReadonlyArray<AssistantEvent.AnyEntry>): ReadonlyMap<string, State> => {\n  let states: ReadonlyMap<string, State> = new Map()\n\n  for (const entry of entries) states = apply(states, entry.event)\n\n  return states\n}\n\n/**\n * Returns the ids of the messages whose blocks are still open after the user typed the given\n * number of messages without using them.\n *\n * **Details**\n *\n * These are the blocks {@link closeStale} closes. Decision blocks never go stale, since work waits\n * on them and closing one would leave it waiting.\n *\n * @category utils\n * @since 0.1.0\n */\nexport const staleBlocks = (\n  entries: ReadonlyArray<AssistantEvent.AnyEntry>,\n  options: { readonly messages: number }\n): ReadonlyArray<string> => {\n  const open = [...fromEntries(entries)].flatMap(([id, state]) => (state.open ? [id] : []))\n\n  return open.filter((id) => {\n    const shown = entries.findIndex(\n      ({ event }) =>\n        AssistantEvent.isLibraryEvent(event) && Predicate.isTagged(event, \"AssistantMessage\") && event.id === id\n    )\n\n    const message = entries[shown]?.event\n\n    if (\n      message === undefined ||\n      (AssistantEvent.isLibraryEvent(message) &&\n        Predicate.isTagged(message, \"AssistantMessage\") &&\n        message.block?.kind === Decision.kind)\n    )\n      return false\n\n    const typed = entries.slice(shown + 1).filter(({ event }) => Predicate.isTagged(event, \"UserMessage\")).length\n\n    return typed >= options.messages\n  })\n}\n\n/**\n * Closes the blocks the user moved on from, which are still open after the given number of typed\n * messages.\n *\n * **Details**\n *\n * Run it from a turn, before or after its loop. It records a `BlocksClosed` event, so every\n * client folds the blocks closed.\n *\n * @see {@link staleBlocks} for the blocks it closes\n *\n * @category utils\n * @since 0.1.0\n */\nexport const closeStale = Effect.fn(function* (options: { readonly messages: number }) {\n  const chat = yield* CurrentChat\n  const stale = staleBlocks(yield* chat.entries, options)\n\n  if (stale.length > 0) yield* chat.append(AssistantEvent.BlocksClosed.make({ messageIds: stale }))\n})\n\n/**\n * Represents what a renderer receives for one block.\n *\n * @category models\n * @since 0.1.0\n */\nexport interface RenderArgs<B> {\n  readonly text: string\n  readonly props: PropsOf<B>\n  /**\n   * Whether the block is open. It is `false` once the block is answered, with the block or in\n   * words; show it read-only then.\n   */\n  readonly open: boolean\n  /** The user's answer, if they used the block. */\n  readonly answer: AnswerOf<B> | undefined\n  /**\n   * For the decision block, the call each decision is for (its tool and params) and how it was\n   * decided. Empty for other blocks.\n   */\n  readonly decisions: ReadonlyArray<ChatView.PendingDecision>\n  /** Sends an answer. Only call it while `open`. */\n  readonly respond: (answer: AnswerOf<B>) => void\n}\n\n/**\n * Represents a renderer for every kind in a kit.\n *\n * @category models\n * @since 0.1.0\n */\nexport type Renderers<Kit extends BlockKit, Out> = {\n  readonly [K in KindOf<Kit[\"blocks\"][number]>]: (args: RenderArgs<BlockOf<Kit, K>>) => Out\n}\n\n/**\n * Represents the options for rendering one message's block.\n *\n * @category models\n * @since 0.1.0\n */\nexport interface RenderOptions {\n  /** Submits an answer, for example over RPC. */\n  readonly respond: (answer: AssistantEvent.BlockAnswer) => void\n}\n\n/**\n * Creates a client-side renderer for the blocks on a chat view's messages\n * (`ChatView.AssistantMessage`).\n *\n * **Details**\n *\n * The renderers are type-checked, so every kind in the kit needs one, and each receives typed\n * `props` and `answer`. A renderer's `respond` builds a `BlockAnswer` input, with the answer\n * encoded by the block's answer schema, and passes it to the `respond` option to submit.\n *\n * The returned function returns `undefined` for a message without a block, or with a block it\n * can't decode or has no renderer for.\n *\n * **Example** (Rendering blocks with React)\n *\n * ```tsx\n * import { BlockKit, Decision } from \"effect-assistant\"\n * import type { ReactNode } from \"react\"\n *\n * const Blocks = BlockKit.make([PickOne, Decision.block])\n *\n * const renderBlock = BlockKit.toClient<typeof Blocks, ReactNode>(Blocks, {\n *   pick_one: ({ props, open, respond }) =>\n *     props.options.map((option) => (\n *       <button key={option} disabled={!open} onClick={() => respond({ picked: option })}>\n *         {option}\n *       </button>\n *     )),\n *   decision: ({ props, open, respond }) => (\n *     <button disabled={!open} onClick={() => respond(Decision.answerAll(props, \"approved\"))}>\n *       {props.approveLabel ?? \"Approve\"}\n *     </button>\n *   )\n * })\n *\n * // For each AssistantMessage in the chat's view:\n * renderBlock(message, { respond: (answer) => submit(answer) })\n * ```\n *\n * @category constructors\n * @since 0.1.0\n */\nexport function toClient<Kit extends BlockKit, Out>(\n  kit: Kit,\n  renderers: Renderers<Kit, Out>\n): (message: ChatView.AssistantMessage, options: RenderOptions) => Out | undefined\n// The overload above checks that every kind has a renderer; here each one takes any block's\n// arguments.\nexport function toClient<Out>(\n  kit: BlockKit,\n  renderers: Readonly<Record<string, (args: RenderArgs<Block.Any>) => Out>>\n): (message: ChatView.AssistantMessage, options: RenderOptions) => Out | undefined {\n  return (message, options) => {\n    if (message.block === undefined) return undefined\n\n    const { kind } = message.block\n    const block = kit.byKind.get(kind)\n    const render = renderers[kind]\n\n    if (block === undefined || render === undefined) return undefined\n\n    const props = Schema.decodeUnknownOption(block.props)(message.block.props)\n\n    if (Option.isNone(props)) return undefined\n\n    const given = message.block.answer\n    const answerCodec = block.answer === undefined ? undefined : Schema.toCodecJson(block.answer)\n\n    const answer =\n      given === undefined || answerCodec === undefined ? Option.none() : Schema.decodeUnknownOption(answerCodec)(given)\n\n    return render({\n      text: message.text,\n      props: props.value,\n      open: message.block.status === \"open\",\n      answer: Option.getOrUndefined(answer),\n      decisions: message.block.decisions ?? [],\n      respond: (value) =>\n        options.respond(\n          AssistantEvent.BlockAnswer.make({\n            // A block takes one answer: the same id every time, so a second click is stored once.\n            id: InputId.fromKey(`${message.id}:answer`),\n            messageId: message.id,\n            kind,\n            value: answerCodec === undefined ? value : Schema.encodeUnknownSync(answerCodec)(value)\n          })\n        )\n    })\n  }\n}\n"],"mappings":"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"}

package/dist/ChatId.d.ts

@@ -0,0 +1,31 @@
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+declare namespace ChatId_d_exports {
+  export { ChatId, make };
+}
+/**
+ * Schema for chat ids of the form `` `chat:${uuid}` ``. The schema is branded, so a run id or a
+ * plain string can't be passed where a chat id is required.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare const ChatId: Schema.brand<Schema.TemplateLiteral<readonly ["chat:", Schema.String]>, "~effect-assistant/ChatId">;
+/**
+ * Represents a chat id.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type ChatId = typeof ChatId.Type;
+/**
+ * Creates a new random chat id using Effect's `Random`. Seed `Random` in tests to get the same ids
+ * on every run.
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export declare const make: () => Effect.Effect<ChatId>;
+//#endregion
+export { ChatId_d_exports };
+//# sourceMappingURL=ChatId.d.ts.map

package/dist/ChatId.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChatId.d.ts","names":[],"sources":["../src/ChatId.ts"],"mappings":";;;;;;;;;;;;qBAkBa,QAAM,OAAA,MAAA,OAAA,mCAAA,OAAA;;;;;;;YAQP,gBAAgB,OAAO;;;;;;;;qBAStB,YAAW,OAAO,OAAO"}

package/dist/ChatId.js

@@ -0,0 +1,36 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import { Uuid, make as make$1 } from "./internal/uuid.js";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+//#region src/ChatId.ts
+/**
+* This module provides the id of a chat, which is `chat:` followed by a UUID.
+*
+* A chat id keys everything about a chat: its log, its cluster entity, and its trace session.
+*
+* @since 0.1.0
+*/
+var ChatId_exports = /* @__PURE__ */ __exportAll({
+	ChatId: () => ChatId,
+	make: () => make
+});
+/**
+* Schema for chat ids of the form `` `chat:${uuid}` ``. The schema is branded, so a run id or a
+* plain string can't be passed where a chat id is required.
+*
+* @category schemas
+* @since 0.1.0
+*/
+const ChatId = Schema.TemplateLiteral(["chat:", Uuid]).pipe(Schema.brand("~effect-assistant/ChatId"));
+/**
+* Creates a new random chat id using Effect's `Random`. Seed `Random` in tests to get the same ids
+* on every run.
+*
+* @category constructors
+* @since 0.1.0
+*/
+const make = () => Effect.map(make$1, (uuid) => ChatId.make(`chat:${uuid}`));
+//#endregion
+export { ChatId, ChatId_exports, make };
+
+//# sourceMappingURL=ChatId.js.map

package/dist/ChatId.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChatId.js","names":["Uuid.Uuid","Uuid.make"],"sources":["../src/ChatId.ts"],"sourcesContent":["/**\n * This module provides the id of a chat, which is `chat:` followed by a UUID.\n *\n * A chat id keys everything about a chat: its log, its cluster entity, and its trace session.\n *\n * @since 0.1.0\n */\nimport * as Effect from \"effect/Effect\"\nimport * as Schema from \"effect/Schema\"\nimport * as Uuid from \"./internal/uuid.ts\"\n\n/**\n * Schema for chat ids of the form `` `chat:${uuid}` ``. The schema is branded, so a run id or a\n * plain string can't be passed where a chat id is required.\n *\n * @category schemas\n * @since 0.1.0\n */\nexport const ChatId = Schema.TemplateLiteral([\"chat:\", Uuid.Uuid]).pipe(Schema.brand(\"~effect-assistant/ChatId\"))\n\n/**\n * Represents a chat id.\n *\n * @category models\n * @since 0.1.0\n */\nexport type ChatId = typeof ChatId.Type\n\n/**\n * Creates a new random chat id using Effect's `Random`. Seed `Random` in tests to get the same ids\n * on every run.\n *\n * @category constructors\n * @since 0.1.0\n */\nexport const make = (): Effect.Effect<ChatId> => Effect.map(Uuid.make, (uuid) => ChatId.make(`chat:${uuid}`))\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAkBA,MAAa,SAAS,OAAO,gBAAgB,CAAC,SAASA,IAAS,CAAC,CAAC,CAAC,KAAK,OAAO,MAAM,0BAA0B,CAAC;;;;;;;;AAiBhH,MAAa,aAAoC,OAAO,IAAIC,SAAY,SAAS,OAAO,KAAK,QAAQ,MAAM,CAAC"}

package/dist/ChatLog.d.ts

@@ -0,0 +1,109 @@
+import { ChatId } from "./ChatId.js";
+import { AssistantEvent, AssistantEvent_d_exports, Entry, StoredAppEvent } from "./AssistantEvent.js";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as SqlClient from "effect/sql/SqlClient";
+declare namespace ChatLog_d_exports {
+  export { ChatLog, ReadOptions, Storage, layerMemory, layerSql, make };
+}
+declare const ChatLog_base: Context.ServiceClass<ChatLog, "effect-assistant/ChatLog", {
+  /** Appends events to a chat and returns them as stored entries. */
+  readonly append: (chatId: ChatId, events: ReadonlyArray<AssistantEvent | StoredAppEvent>) => Effect.Effect<ReadonlyArray<Entry>>;
+  /** Reads a chat's stored entries in order, either all of them or only those after a `seq`. */
+  readonly read: (chatId: ChatId, options?: ReadOptions) => Effect.Effect<ReadonlyArray<Entry>>;
+  /**
+   * Returns the chats whose last entry ends neither a turn nor the chat. After a restart, these
+   * are the chats that may still owe a turn.
+   */
+  readonly unfinished: Effect.Effect<ReadonlyArray<ChatId>>;
+}>;
+/**
+ * Service that stores each chat's events as an ordered list of entries.
+ *
+ * @category services
+ * @since 0.1.0
+ */
+export declare class ChatLog extends ChatLog_base {}
+/**
+ * Represents the options that select which of a chat's entries to read.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export interface ReadOptions {
+  /** Reads only the entries after this `seq`. */
+  readonly after?: number | undefined;
+}
+/**
+ * Represents the storage that a `ChatLog` is built on.
+ *
+ * A storage reads a chat's entries, finds a chat's last `seq`, writes new entries, and finds every
+ * chat's last entry. Entries are never removed, so a deleted chat keeps its log, which ends in
+ * `ChatDeleted`.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export interface Storage {
+  readonly read: (chatId: ChatId, options?: ReadOptions) => Effect.Effect<ReadonlyArray<Entry>>;
+  readonly lastSeq: (chatId: ChatId) => Effect.Effect<number>;
+  readonly write: (chatId: ChatId, entries: ReadonlyArray<Entry>) => Effect.Effect<void>;
+  /** Returns the last entry of every chat. */
+  readonly lastEntries: Effect.Effect<ReadonlyArray<Entry>>;
+}
+/**
+ * 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
+ */
+export declare const make: (storage: Storage) => ChatLog["Service"];
+/**
+ * Layer that keeps every chat in memory. The log is lost when the process stops.
+ *
+ * @category layers
+ * @since 0.1.0
+ */
+export declare const layerMemory: Layer.Layer<ChatLog>;
+/**
+ * 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
+ */
+export declare const layerSql: Layer.Layer<ChatLog, never, SqlClient.SqlClient>;
+//#endregion
+export { ChatLog_d_exports };
+//# sourceMappingURL=ChatLog.d.ts.map

package/dist/ChatLog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChatLog.d.ts","names":[],"sources":["../src/ChatLog.ts"],"mappings":";;;;;;;;;;;WA+BqB,SACf,QAAQ,QACR,QAAQ,cAAc,iBAAgC,oBACnD,OAAO,OAAO,cAAc;;WAElB,OAAC,QAAQ,QAAQ,UAAU,gBAAgB,OAAO,OAAO,cAAc;;;;;WAKjE,YAAA,OAAO,OAAO,cAAc;;;;;;;;qBAdxC,gBAAgB;;;;;;;iBAwBZ;;WAEN;;;;;;;;;;;;iBAaM;WACN,OAAO,QAAQ,QAAQ,UAAU,gBAAgB,OAAO,OAAO,cAAc;WAC7E,UAAU,QAAQ,WAAW,OAAO;WACpC,QAAQ,QAAQ,QAAQ,SAAS,cAAc,WAA0B,OAAO;;WAEhF,aAAa,OAAO,OAAO,cAAc;;;;;;;;;qBAUvC,OAAI,SAAa,YAAU;;;;;;;qBAiC3B,aAAa,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAwEzB,UAAU,MAAM,MAAM,gBAAgB,UAAU"}