effect-assistant 0.1.0 → 0.3.0

package/dist/AssistantEngine.js

@@ -4,10 +4,10 @@ import { Entry, Input, StoredAppEvent } from "./AssistantEvent.js";
 import { ChatLog } from "./ChatLog.js";
 import { needsTurn } from "./internal/history.js";
 import { make } from "./internal/chat.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 Predicate from "effect/Predicate";
 import * as Schema from "effect/Schema";
 import * as Stream from "effect/Stream";
 import * as ClusterSchema from "effect/cluster/ClusterSchema";
@@ -22,19 +22,21 @@ import * as Rpc from "effect/rpc/Rpc";
 import * as Scope from "effect/Scope";
 //#region src/AssistantEngine.ts
 /**
-* This module provides the `AssistantEngine` service, which runs assistants' chats, and its two
+* This module provides the `AssistantEngine` service, which runs assistants' chats, and its
 * implementations.
 *
 * An assistant's `toLayer` registers the assistant with the engine, and the assistant's `submit`
 * and `subscribe` go through it. Pick one engine for the app, as with a workflow engine.
 * {@link layerMemory} runs chats in the process, for tests and single-process apps.
-* {@link layerCluster} runs each chat as a cluster entity, so a turn cut off by a crash resumes.
+* {@link layerCluster} runs each chat as a cluster entity, so a turn cut off by a crash resumes, and
+* {@link layerClusterClient} reaches those chats from a process that runs none.
 *
 * @since 0.1.0
 */
 var AssistantEngine_exports = /* @__PURE__ */ __exportAll({
 	AssistantEngine: () => AssistantEngine,
 	layerCluster: () => layerCluster,
+	layerClusterClient: () => layerClusterClient,
 	layerMemory: () => layerMemory
 });
 /**
@@ -114,11 +116,11 @@ const layerMemory = Layer.effect(AssistantEngine, Effect.gen(function* () {
 		})));
 	}, Effect.scoped);
 	const resumeAll = Effect.fnUntraced(function* (registration) {
-		const { name, app } = registration.definition;
+		const { name } = registration.definition;
 		for (const chatId of yield* log.unfinished) {
 			const entries = yield* log.read(chatId);
 			const lastTurn = entries.findLast(({ event }) => Predicate.isTagged(event, "TurnStarted"))?.event;
-			if (Predicate.isTagged(lastTurn, "TurnStarted") && lastTurn.assistant === name && needsTurn(entries, app.wakes)) yield* withChat(name, chatId, (chat) => chat.resume);
+			if (Predicate.isTagged(lastTurn, "TurnStarted") && lastTurn.assistant === name && needsTurn(entries)) yield* withChat(name, chatId, (chat) => chat.resume);
 		}
 	});
 	return AssistantEngine.of({
@@ -154,6 +156,33 @@ const chatEntity = (assistant) => Entity.make(`Assistant/${assistant}`, [
 	Subscribe,
 	Delete
 ]);
+const makeClusterClient = Effect.gen(function* () {
+	const context = yield* Effect.context();
+	const clients = /* @__PURE__ */ new Map();
+	const clientOf = Effect.fnUntraced(function* (assistant) {
+		const known = clients.get(assistant);
+		if (known !== void 0) return known;
+		const makeClient = yield* chatEntity(assistant).client.pipe(Effect.provide(context));
+		const client = {
+			submit: (chatId, input) => makeClient(chatId).Submit({ input }, { discard: true }).pipe(Effect.orDie),
+			subscribe: (chatId, after) => makeClient(chatId).Subscribe({ after }).pipe(Stream.orDie),
+			delete: (chatId) => makeClient(chatId).Delete().pipe(Effect.orDie)
+		};
+		clients.set(assistant, client);
+		return client;
+	});
+	return {
+		submit: Effect.fn("AssistantEngine.submit")(function* (assistant, chatId, input) {
+			yield* (yield* clientOf(assistant)).submit(chatId, input);
+		}),
+		subscribe: (assistant, chatId, after) => Stream.unwrap(Effect.gen(function* () {
+			return (yield* clientOf(assistant)).subscribe(chatId, after);
+		})),
+		delete: Effect.fn("AssistantEngine.delete")(function* (assistant, chatId) {
+			yield* (yield* clientOf(assistant)).delete(chatId);
+		})
+	};
+});
 /**
 * Layer that runs chats as cluster entities, one entity per chat, keyed by chat id.
 *
@@ -191,6 +220,7 @@ const chatEntity = (assistant) => Entity.make(`Assistant/${assistant}`, [
 * ```
 *
 * @see {@link layerMemory} for running chats in one process
+* @see {@link layerClusterClient} for a process that only reaches chats the cluster runs
 *
 * @category layers
 * @since 0.1.0
@@ -198,7 +228,6 @@ const chatEntity = (assistant) => Entity.make(`Assistant/${assistant}`, [
 const layerCluster = Layer.effect(AssistantEngine, Effect.gen(function* () {
 	const context = yield* Effect.context();
 	const sharding = yield* Sharding.Sharding;
-	const clients = /* @__PURE__ */ new Map();
 	const register = Effect.fnUntraced(function* (registration) {
 		const ChatEntity = chatEntity(registration.definition.name);
 		const handlers = Effect.gen(function* () {
@@ -224,32 +253,56 @@ const layerCluster = Layer.effect(AssistantEngine, Effect.gen(function* () {
 			concurrency: "unbounded"
 		});
 	});
-	const clientOf = Effect.fnUntraced(function* (assistant) {
-		const known = clients.get(assistant);
-		if (known !== void 0) return known;
-		const makeClient = yield* chatEntity(assistant).client.pipe(Effect.provide(context));
-		const client = {
-			submit: (chatId, input) => makeClient(chatId).Submit({ input }, { discard: true }).pipe(Effect.orDie),
-			subscribe: (chatId, after) => makeClient(chatId).Subscribe({ after }).pipe(Stream.orDie),
-			delete: (chatId) => makeClient(chatId).Delete().pipe(Effect.orDie)
-		};
-		clients.set(assistant, client);
-		return client;
-	});
+	const client = yield* makeClusterClient;
 	return AssistantEngine.of({
 		register: (registration) => register(registration).pipe(Effect.provide(context)),
-		submit: Effect.fn("AssistantEngine.submit")(function* (assistant, chatId, input) {
-			yield* (yield* clientOf(assistant)).submit(chatId, input);
-		}),
-		subscribe: (assistant, chatId, after) => Stream.unwrap(Effect.gen(function* () {
-			return (yield* clientOf(assistant)).subscribe(chatId, after);
-		})),
-		delete: Effect.fn("AssistantEngine.delete")(function* (assistant, chatId) {
-			yield* (yield* clientOf(assistant)).delete(chatId);
-		})
+		...client
+	});
+}));
+/**
+* Layer that reaches chats running as cluster entities elsewhere, and runs none itself.
+*
+* **When to use**
+*
+* Use it in a process that only submits to, subscribes to, and deletes chats that the cluster's
+* runners run with {@link layerCluster}, such as a web server that provides an assistant's
+* `layerClient`. It needs no `ChatLog`, since the runners store the chats.
+*
+* **Details**
+*
+* The layer requires `Sharding`. An assistant's `toLayer` can't register with it: it dies, since
+* no chats run in this process.
+*
+* **Example** (A web server in front of the cluster)
+*
+* ```ts
+* import { Assistant, AssistantEngine } from "effect-assistant"
+* import type * as Sharding from "effect/cluster/Sharding"
+* import * as Layer from "effect/Layer"
+*
+* declare const ShardingLive: Layer.Layer<Sharding.Sharding>
+*
+* export const MyAssistant = Assistant.make("my-assistant")
+*
+* const MyAssistantClient = MyAssistant.layerClient.pipe(
+*   Layer.provide(AssistantEngine.layerClusterClient),
+*   Layer.provide(ShardingLive)
+* )
+* ```
+*
+* @see {@link layerCluster} for the runners that run the chats
+*
+* @category layers
+* @since 0.3.0
+*/
+const layerClusterClient = Layer.effect(AssistantEngine, Effect.gen(function* () {
+	const client = yield* makeClusterClient;
+	return AssistantEngine.of({
+		register: (registration) => Effect.die(`The ${registration.definition.name} assistant can't register with AssistantEngine.layerClusterClient, which runs no chats: provide AssistantEngine.layerCluster where its toLayer runs.`),
+		...client
 	});
 }));
 //#endregion
-export { AssistantEngine, AssistantEngine_exports, layerCluster, layerMemory };
+export { AssistantEngine, AssistantEngine_exports, layerCluster, layerClusterClient, layerMemory };
 
 //# sourceMappingURL=AssistantEngine.js.map

package/dist/AssistantEngine.js.map

@@ -1 +1 @@
-{"version":3,"file":"AssistantEngine.js","names":["Chat.make","History.needsTurn","AssistantEvent.Input","AssistantEvent.StoredAppEvent","AssistantEvent.Entry"],"sources":["../src/AssistantEngine.ts"],"sourcesContent":["/**\n * This module provides the `AssistantEngine` service, which runs assistants' chats, and its two\n * implementations.\n *\n * An assistant's `toLayer` registers the assistant with the engine, and the assistant's `submit`\n * and `subscribe` go through it. Pick one engine for the app, as with a workflow engine.\n * {@link layerMemory} runs chats in the process, for tests and single-process apps.\n * {@link layerCluster} runs each chat as a cluster entity, so a turn cut off by a crash resumes.\n *\n * @since 0.1.0\n */\nimport * as ClusterSchema from \"effect/cluster/ClusterSchema\"\nimport * as Entity from \"effect/cluster/Entity\"\nimport * as Sharding from \"effect/cluster/Sharding\"\nimport * as Context from \"effect/Context\"\nimport * as Data from \"effect/Data\"\nimport * as Effect from \"effect/Effect\"\nimport * as Exit from \"effect/Exit\"\nimport * as Layer from \"effect/Layer\"\nimport * as MutableHashMap from \"effect/MutableHashMap\"\nimport * as Option from \"effect/Option\"\nimport * as Predicate from \"effect/Predicate\"\nimport * as RcMap from \"effect/RcMap\"\nimport * as Rpc from \"effect/rpc/Rpc\"\nimport * as Schema from \"effect/Schema\"\nimport * as Scope from \"effect/Scope\"\nimport * as Stream from \"effect/Stream\"\nimport * as AssistantEvent from \"./AssistantEvent.ts\"\nimport { ChatId } from \"./ChatId.ts\"\nimport { ChatLog } from \"./ChatLog.ts\"\nimport * as Chat from \"./internal/chat.ts\"\nimport * as History from \"./internal/history.ts\"\nimport type * as Turns from \"./internal/turns.ts\"\n\n/**\n * Service that runs assistants' chats. An assistant's `toLayer` registers the assistant with it,\n * and the assistant's `submit` and `subscribe` use it.\n *\n * @category services\n * @since 0.1.0\n */\nexport class AssistantEngine extends Context.Service<\n  AssistantEngine,\n  {\n    /** Registers an assistant for as long as the scope is open. */\n    readonly register: (registration: Turns.Registration) => Effect.Effect<void, never, Scope.Scope>\n    /**\n     * Stores an input in one of the assistant's chats. The assistant works on it in the\n     * background.\n     */\n    readonly submit: (\n      assistant: string,\n      chatId: ChatId,\n      input: AssistantEvent.Input | AssistantEvent.StoredAppEvent\n    ) => Effect.Effect<void>\n    /** Streams the chat's stored entries after the `after` seq, then live ones. */\n    readonly subscribe: (assistant: string, chatId: ChatId, after: number) => Stream.Stream<AssistantEvent.Entry>\n    /**\n     * Deletes one of the assistant's chats. The chat's log records the deletion, and everything\n     * that works in the chat stops.\n     */\n    readonly delete: (assistant: string, chatId: ChatId) => Effect.Effect<void>\n  }\n>()(\"effect-assistant/AssistantEngine\") {}\n\nclass ChatKey extends Data.Class<{ readonly assistant: string; readonly chatId: ChatId }> {}\n\nconst notRegistered = (assistant: string) =>\n  Effect.die(`The ${assistant} assistant isn't registered: provide its toLayer.`)\n\n/**\n * Layer that runs chats in the current process. Each chat's turns run as fibers, one at a time.\n *\n * **Details**\n *\n * With `ChatLog.layerSql`, the engine resumes chats at startup. When an assistant registers, the\n * engine finds the chats that assistant was working on when the process stopped (a turn cut off\n * partway, or an input that no turn read) and runs a turn for each. Run this engine in one process\n * only, because two processes would run the same chat and write its log at the same time.\n *\n * **Example** (Running chats in memory)\n *\n * ```ts\n * import { Assistant, AssistantEngine, ChatLog } from \"effect-assistant\"\n * import type * as LanguageModel from \"effect/ai/LanguageModel\"\n * import * as Layer from \"effect/Layer\"\n *\n * declare const ModelLive: Layer.Layer<LanguageModel.LanguageModel>\n *\n * const MyAssistant = Assistant.make(\"my-assistant\")\n *\n * const AppLive = MyAssistant.toLayer((turn) => turn.loop({ instructions: \"Be brief.\" })).pipe(\n *   Layer.provide(ModelLive),\n *   Layer.provideMerge(AssistantEngine.layerMemory),\n *   Layer.provideMerge(ChatLog.layerMemory)\n * )\n * ```\n *\n * @see {@link layerCluster} for running each chat as a cluster entity\n *\n * @category layers\n * @since 0.1.0\n */\nexport const layerMemory: Layer.Layer<AssistantEngine, never, ChatLog> = Layer.effect(\n  AssistantEngine,\n  Effect.gen(function* () {\n    const context = yield* Effect.context<ChatLog>()\n    const log = yield* ChatLog\n    const registered = new Map<string, Turns.Registration>()\n    // A chat's keep-alive: a hold on its entry, so it stays open while runs or turns work in the background.\n    const held = MutableHashMap.empty<ChatKey, Scope.Closeable>()\n\n    // One entry per open chat, like a cluster entity: opened when used, closed five minutes after the last use.\n    const chats: RcMap.RcMap<ChatKey, Chat.Chat> = yield* RcMap.make({\n      lookup: Effect.fnUntraced(function* (key: ChatKey) {\n        const registration = registered.get(key.assistant)\n\n        if (registration === undefined) return yield* notRegistered(key.assistant)\n\n        return yield* Chat.make({\n          registration,\n          chatId: key.chatId,\n          keepAlive: (enabled) => keepAlive(key, enabled)\n        }).pipe(Effect.provide(context))\n      }),\n      idleTimeToLive: \"5 minutes\"\n    })\n\n    // On: a hold on the chat's entry, in a scope of its own. Off: closing that scope lets the entry go idle.\n    const keepAlive = Effect.fnUntraced(function* (key: ChatKey, enabled: boolean) {\n      if (enabled) {\n        const scope = yield* Scope.make()\n\n        yield* Effect.provideService(RcMap.get(chats, key), Scope.Scope, scope)\n\n        return MutableHashMap.set(held, key, scope)\n      }\n\n      const scope = MutableHashMap.get(held, key)\n\n      MutableHashMap.remove(held, key)\n\n      if (Option.isSome(scope)) yield* Scope.close(scope.value, Exit.void)\n    })\n\n    const withChat = Effect.fnUntraced(function* <A>(\n      assistant: string,\n      chatId: ChatId,\n      f: (chat: Chat.Chat) => Effect.Effect<A>\n    ) {\n      const chat = yield* RcMap.get(chats, new ChatKey({ assistant, chatId }))\n\n      return yield* f(chat)\n    }, Effect.scoped)\n\n    // A chat owes a turn when its last turn was cut off, or an input came after.\n    const resumeAll = Effect.fnUntraced(function* (registration: Turns.Registration) {\n      const { name, app } = registration.definition\n\n      for (const chatId of yield* log.unfinished) {\n        const entries = yield* log.read(chatId)\n\n        const lastTurn = entries.findLast(({ event }) => Predicate.isTagged(event, \"TurnStarted\"))?.event\n        const ours = Predicate.isTagged(lastTurn, \"TurnStarted\") && lastTurn.assistant === name\n\n        if (ours && History.needsTurn(entries, app.wakes)) yield* withChat(name, chatId, (chat) => chat.resume)\n      }\n    })\n\n    return AssistantEngine.of({\n      register: Effect.fn(\"AssistantEngine.register\")(function* (registration: Turns.Registration) {\n        registered.set(registration.definition.name, registration)\n        // Chats this assistant was working on when the process stopped: pick them up again.\n        yield* Effect.forkScoped(resumeAll(registration))\n      }),\n      submit: (assistant, chatId, input) => withChat(assistant, chatId, (chat) => chat.submitInBackground(input)),\n      // The chat deletes itself, so a chat that's open stops; the entry goes, and the next open finds it deleted.\n      delete: Effect.fn(\"AssistantEngine.delete\")(function* (assistant: string, chatId: ChatId) {\n        yield* withChat(assistant, chatId, (chat) => chat.delete)\n        yield* RcMap.invalidate(chats, new ChatKey({ assistant, chatId }))\n      }),\n      // The subscriber holds the chat open while it streams.\n      subscribe: (assistant, chatId, after) =>\n        Stream.unwrap(\n          Effect.gen(function* () {\n            const chat = yield* RcMap.get(chats, new ChatKey({ assistant, chatId }))\n\n            return chat.stream(after)\n          })\n        )\n    })\n  })\n)\n\ninterface EntityClient {\n  readonly submit: (chatId: ChatId, input: AssistantEvent.Input | AssistantEvent.StoredAppEvent) => Effect.Effect<void>\n  readonly subscribe: (chatId: ChatId, after: number) => Stream.Stream<AssistantEvent.Entry>\n  readonly delete: (chatId: ChatId) => Effect.Effect<void>\n}\n\nconst Submit = Rpc.make(\"Submit\", {\n  payload: { input: Schema.Union([AssistantEvent.Input, AssistantEvent.StoredAppEvent]) }\n}).annotate(ClusterSchema.Persisted, true)\n\nconst Subscribe = Rpc.make(\"Subscribe\", {\n  payload: { after: Schema.Int },\n  success: AssistantEvent.Entry,\n  stream: true\n})\n\nconst Delete = Rpc.make(\"Delete\")\n\nconst chatEntity = (assistant: string) => Entity.make(`Assistant/${assistant}`, [Submit, Subscribe, Delete])\n\n/**\n * Layer that runs chats as cluster entities, one entity per chat, keyed by chat id.\n *\n * **Details**\n *\n * The layer requires `Sharding`. Use a `SingleRunner` for one process with SQL storage, a runner\n * of the app's cluster, or `TestRunner` in tests.\n *\n * **Example** (Running chats on a single runner with Postgres)\n *\n * ```ts\n * import * as NodeCrypto from \"@effect/platform-node/NodeCrypto\"\n * import * as PgClient from \"@effect/sql-pg/PgClient\"\n * import { Assistant, AssistantEngine, ChatLog } from \"effect-assistant\"\n * import type * as LanguageModel from \"effect/ai/LanguageModel\"\n * import * as SingleRunner from \"effect/cluster/SingleRunner\"\n * import * as Config from \"effect/Config\"\n * import * as Layer from \"effect/Layer\"\n *\n * declare const ModelLive: Layer.Layer<LanguageModel.LanguageModel>\n *\n * const MyAssistant = Assistant.make(\"my-assistant\")\n *\n * const AppLive = MyAssistant.toLayer((turn) => turn.loop({ instructions: \"Be brief.\" })).pipe(\n *   Layer.provide(ModelLive),\n *   Layer.provideMerge(AssistantEngine.layerCluster),\n *   Layer.provideMerge(\n *     Layer.merge(\n *       ChatLog.layerSql,\n *       SingleRunner.layer({ runnerStorage: \"sql\" }).pipe(Layer.provide(NodeCrypto.layer))\n *     )\n *   ),\n *   Layer.provide(PgClient.layerConfig({ url: Config.Redacted(\"DATABASE_URL\") }))\n * )\n * ```\n *\n * @see {@link layerMemory} for running chats in one process\n *\n * @category layers\n * @since 0.1.0\n */\nexport const layerCluster: Layer.Layer<AssistantEngine, never, ChatLog | Sharding.Sharding> = Layer.effect(\n  AssistantEngine,\n  Effect.gen(function* () {\n    const context = yield* Effect.context<ChatLog | Sharding.Sharding>()\n    const sharding = yield* Sharding.Sharding\n    const clients = new Map<string, EntityClient>()\n\n    const register = Effect.fnUntraced(function* (registration: Turns.Registration) {\n      const ChatEntity = chatEntity(registration.definition.name)\n\n      const handlers = Effect.gen(function* () {\n        const address = yield* Entity.CurrentAddress\n        const chatId = yield* Schema.decodeUnknownEffect(ChatId)(address.entityId).pipe(Effect.orDie)\n        // The entity's own: `Entity.keepAlive` needs its address and keep-alive latch, which is in there too.\n        const entityContext = yield* Effect.context<Entity.CurrentAddress | Sharding.Sharding>()\n\n        const keepAlive = (enabled: boolean) =>\n          Entity.keepAlive(enabled).pipe(\n            Effect.provide(entityContext),\n            Effect.catchCause((cause) => Effect.logWarning(\"assistant chat keep-alive failed\", cause))\n          )\n\n        // A keep-alive left on from before a restart (by a run cut off) has done its job: it started the entity.\n        yield* keepAlive(false)\n\n        const chat = yield* Chat.make({ registration, chatId, keepAlive })\n        yield* chat.resume\n\n        return ChatEntity.of({\n          // The turns run inside the request, so a crash leaves it unprocessed and the cluster redelivers it.\n          Submit: (request) => chat.submit(request.payload.input),\n          Subscribe: (request) => chat.stream(request.payload.after),\n          Delete: () => chat.delete\n        })\n      })\n\n      yield* sharding.registerEntity(ChatEntity, handlers.pipe(Effect.provide(context)), {\n        maxIdleTime: \"5 minutes\",\n        concurrency: \"unbounded\"\n      })\n    })\n\n    // Made on first use, so a process that registers no assistant can still reach its chats.\n    const clientOf = Effect.fnUntraced(function* (assistant: string) {\n      const known = clients.get(assistant)\n\n      if (known !== undefined) return known\n\n      const makeClient = yield* chatEntity(assistant).client.pipe(Effect.provide(context))\n\n      const client: EntityClient = {\n        submit: (chatId, input) => makeClient(chatId).Submit({ input }, { discard: true }).pipe(Effect.orDie),\n        subscribe: (chatId, after) => makeClient(chatId).Subscribe({ after }).pipe(Stream.orDie),\n        delete: (chatId) => makeClient(chatId).Delete().pipe(Effect.orDie)\n      }\n\n      clients.set(assistant, client)\n\n      return client\n    })\n\n    return AssistantEngine.of({\n      register: (registration) => register(registration).pipe(Effect.provide(context)),\n      submit: Effect.fn(\"AssistantEngine.submit\")(function* (\n        assistant: string,\n        chatId: ChatId,\n        input: AssistantEvent.Input | AssistantEvent.StoredAppEvent\n      ) {\n        const client = yield* clientOf(assistant)\n\n        yield* client.submit(chatId, input)\n      }),\n      subscribe: (assistant, chatId, after) =>\n        Stream.unwrap(\n          Effect.gen(function* () {\n            const client = yield* clientOf(assistant)\n\n            return client.subscribe(chatId, after)\n          })\n        ),\n      delete: Effect.fn(\"AssistantEngine.delete\")(function* (assistant: string, chatId: ChatId) {\n        const client = yield* clientOf(assistant)\n\n        yield* client.delete(chatId)\n      })\n    })\n  })\n)\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCA,IAAa,kBAAb,cAAqC,QAAQ,QAsB3C,CAAC,CAAC,kCAAkC,CAAC,CAAC,CAAC;AAEzC,IAAM,UAAN,cAAsB,KAAK,MAA+D,CAAC;AAE3F,MAAM,iBAAiB,cACrB,OAAO,IAAI,OAAO,UAAU,kDAAkD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmChF,MAAa,cAA4D,MAAM,OAC7E,iBACA,OAAO,IAAI,aAAa;CACtB,MAAM,UAAU,OAAO,OAAO,QAAiB;CAC/C,MAAM,MAAM,OAAO;CACnB,MAAM,6BAAa,IAAI,IAAgC;CAEvD,MAAM,OAAO,eAAe,MAAgC;CAG5D,MAAM,QAAyC,OAAO,MAAM,KAAK;EAC/D,QAAQ,OAAO,WAAW,WAAW,KAAc;GACjD,MAAM,eAAe,WAAW,IAAI,IAAI,SAAS;GAEjD,IAAI,iBAAiB,KAAA,GAAW,OAAO,OAAO,cAAc,IAAI,SAAS;GAEzE,OAAO,OAAOA,KAAU;IACtB;IACA,QAAQ,IAAI;IACZ,YAAY,YAAY,UAAU,KAAK,OAAO;GAChD,CAAC,CAAC,CAAC,KAAK,OAAO,QAAQ,OAAO,CAAC;EACjC,CAAC;EACD,gBAAgB;CAClB,CAAC;CAGD,MAAM,YAAY,OAAO,WAAW,WAAW,KAAc,SAAkB;EAC7E,IAAI,SAAS;GACX,MAAM,QAAQ,OAAO,MAAM,KAAK;GAEhC,OAAO,OAAO,eAAe,MAAM,IAAI,OAAO,GAAG,GAAG,MAAM,OAAO,KAAK;GAEtE,OAAO,eAAe,IAAI,MAAM,KAAK,KAAK;EAC5C;EAEA,MAAM,QAAQ,eAAe,IAAI,MAAM,GAAG;EAE1C,eAAe,OAAO,MAAM,GAAG;EAE/B,IAAI,OAAO,OAAO,KAAK,GAAG,OAAO,MAAM,MAAM,MAAM,OAAO,KAAK,IAAI;CACrE,CAAC;CAED,MAAM,WAAW,OAAO,WAAW,WACjC,WACA,QACA,GACA;EAGA,OAAO,OAAO,EAAE,OAFI,MAAM,IAAI,OAAO,IAAI,QAAQ;GAAE;GAAW;EAAO,CAAC,CAAC,CAEnD;CACtB,GAAG,OAAO,MAAM;CAGhB,MAAM,YAAY,OAAO,WAAW,WAAW,cAAkC;EAC/E,MAAM,EAAE,MAAM,QAAQ,aAAa;EAEnC,KAAK,MAAM,UAAU,OAAO,IAAI,YAAY;GAC1C,MAAM,UAAU,OAAO,IAAI,KAAK,MAAM;GAEtC,MAAM,WAAW,QAAQ,UAAU,EAAE,YAAY,UAAU,SAAS,OAAO,aAAa,CAAC,CAAC,EAAE;GAG5F,IAFa,UAAU,SAAS,UAAU,aAAa,KAAK,SAAS,cAAc,QAEvEC,UAAkB,SAAS,IAAI,KAAK,GAAG,OAAO,SAAS,MAAM,SAAS,SAAS,KAAK,MAAM;EACxG;CACF,CAAC;CAED,OAAO,gBAAgB,GAAG;EACxB,UAAU,OAAO,GAAG,0BAA0B,CAAC,CAAC,WAAW,cAAkC;GAC3F,WAAW,IAAI,aAAa,WAAW,MAAM,YAAY;GAEzD,OAAO,OAAO,WAAW,UAAU,YAAY,CAAC;EAClD,CAAC;EACD,SAAS,WAAW,QAAQ,UAAU,SAAS,WAAW,SAAS,SAAS,KAAK,mBAAmB,KAAK,CAAC;EAE1G,QAAQ,OAAO,GAAG,wBAAwB,CAAC,CAAC,WAAW,WAAmB,QAAgB;GACxF,OAAO,SAAS,WAAW,SAAS,SAAS,KAAK,MAAM;GACxD,OAAO,MAAM,WAAW,OAAO,IAAI,QAAQ;IAAE;IAAW;GAAO,CAAC,CAAC;EACnE,CAAC;EAED,YAAY,WAAW,QAAQ,UAC7B,OAAO,OACL,OAAO,IAAI,aAAa;GAGtB,QAAO,OAFa,MAAM,IAAI,OAAO,IAAI,QAAQ;IAAE;IAAW;GAAO,CAAC,CAAC,EAAA,CAE3D,OAAO,KAAK;EAC1B,CAAC,CACH;CACJ,CAAC;AACH,CAAC,CACH;AAQA,MAAM,SAAS,IAAI,KAAK,UAAU,EAChC,SAAS,EAAE,OAAO,OAAO,MAAM,CAACC,OAAsBC,cAA6B,CAAC,EAAE,EACxF,CAAC,CAAC,CAAC,SAAS,cAAc,WAAW,IAAI;AAEzC,MAAM,YAAY,IAAI,KAAK,aAAa;CACtC,SAAS,EAAE,OAAO,OAAO,IAAI;CAC7B,SAASC;CACT,QAAQ;AACV,CAAC;AAED,MAAM,SAAS,IAAI,KAAK,QAAQ;AAEhC,MAAM,cAAc,cAAsB,OAAO,KAAK,aAAa,aAAa;CAAC;CAAQ;CAAW;AAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2C3G,MAAa,eAAiF,MAAM,OAClG,iBACA,OAAO,IAAI,aAAa;CACtB,MAAM,UAAU,OAAO,OAAO,QAAqC;CACnE,MAAM,WAAW,OAAO,SAAS;CACjC,MAAM,0BAAU,IAAI,IAA0B;CAE9C,MAAM,WAAW,OAAO,WAAW,WAAW,cAAkC;EAC9E,MAAM,aAAa,WAAW,aAAa,WAAW,IAAI;EAE1D,MAAM,WAAW,OAAO,IAAI,aAAa;GACvC,MAAM,UAAU,OAAO,OAAO;GAC9B,MAAM,SAAS,OAAO,OAAO,oBAAoB,MAAM,CAAC,CAAC,QAAQ,QAAQ,CAAC,CAAC,KAAK,OAAO,KAAK;GAE5F,MAAM,gBAAgB,OAAO,OAAO,QAAmD;GAEvF,MAAM,aAAa,YACjB,OAAO,UAAU,OAAO,CAAC,CAAC,KACxB,OAAO,QAAQ,aAAa,GAC5B,OAAO,YAAY,UAAU,OAAO,WAAW,oCAAoC,KAAK,CAAC,CAC3F;GAGF,OAAO,UAAU,KAAK;GAEtB,MAAM,OAAO,OAAOJ,KAAU;IAAE;IAAc;IAAQ;GAAU,CAAC;GACjE,OAAO,KAAK;GAEZ,OAAO,WAAW,GAAG;IAEnB,SAAS,YAAY,KAAK,OAAO,QAAQ,QAAQ,KAAK;IACtD,YAAY,YAAY,KAAK,OAAO,QAAQ,QAAQ,KAAK;IACzD,cAAc,KAAK;GACrB,CAAC;EACH,CAAC;EAED,OAAO,SAAS,eAAe,YAAY,SAAS,KAAK,OAAO,QAAQ,OAAO,CAAC,GAAG;GACjF,aAAa;GACb,aAAa;EACf,CAAC;CACH,CAAC;CAGD,MAAM,WAAW,OAAO,WAAW,WAAW,WAAmB;EAC/D,MAAM,QAAQ,QAAQ,IAAI,SAAS;EAEnC,IAAI,UAAU,KAAA,GAAW,OAAO;EAEhC,MAAM,aAAa,OAAO,WAAW,SAAS,CAAC,CAAC,OAAO,KAAK,OAAO,QAAQ,OAAO,CAAC;EAEnF,MAAM,SAAuB;GAC3B,SAAS,QAAQ,UAAU,WAAW,MAAM,CAAC,CAAC,OAAO,EAAE,MAAM,GAAG,EAAE,SAAS,KAAK,CAAC,CAAC,CAAC,KAAK,OAAO,KAAK;GACpG,YAAY,QAAQ,UAAU,WAAW,MAAM,CAAC,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC,CAAC,KAAK,OAAO,KAAK;GACvF,SAAS,WAAW,WAAW,MAAM,CAAC,CAAC,OAAO,CAAC,CAAC,KAAK,OAAO,KAAK;EACnE;EAEA,QAAQ,IAAI,WAAW,MAAM;EAE7B,OAAO;CACT,CAAC;CAED,OAAO,gBAAgB,GAAG;EACxB,WAAW,iBAAiB,SAAS,YAAY,CAAC,CAAC,KAAK,OAAO,QAAQ,OAAO,CAAC;EAC/E,QAAQ,OAAO,GAAG,wBAAwB,CAAC,CAAC,WAC1C,WACA,QACA,OACA;GAGA,QAAO,OAFe,SAAS,SAAS,EAAA,CAE1B,OAAO,QAAQ,KAAK;EACpC,CAAC;EACD,YAAY,WAAW,QAAQ,UAC7B,OAAO,OACL,OAAO,IAAI,aAAa;GAGtB,QAAO,OAFe,SAAS,SAAS,EAAA,CAE1B,UAAU,QAAQ,KAAK;EACvC,CAAC,CACH;EACF,QAAQ,OAAO,GAAG,wBAAwB,CAAC,CAAC,WAAW,WAAmB,QAAgB;GAGxF,QAAO,OAFe,SAAS,SAAS,EAAA,CAE1B,OAAO,MAAM;EAC7B,CAAC;CACH,CAAC;AACH,CAAC,CACH"}
+{"version":3,"file":"AssistantEngine.js","names":["Chat.make","History.needsTurn","AssistantEvent.Input","AssistantEvent.StoredAppEvent","AssistantEvent.Entry"],"sources":["../src/AssistantEngine.ts"],"sourcesContent":["/**\n * This module provides the `AssistantEngine` service, which runs assistants' chats, and its\n * implementations.\n *\n * An assistant's `toLayer` registers the assistant with the engine, and the assistant's `submit`\n * and `subscribe` go through it. Pick one engine for the app, as with a workflow engine.\n * {@link layerMemory} runs chats in the process, for tests and single-process apps.\n * {@link layerCluster} runs each chat as a cluster entity, so a turn cut off by a crash resumes, and\n * {@link layerClusterClient} reaches those chats from a process that runs none.\n *\n * @since 0.1.0\n */\nimport * as ClusterSchema from \"effect/cluster/ClusterSchema\"\nimport * as Entity from \"effect/cluster/Entity\"\nimport * as Sharding from \"effect/cluster/Sharding\"\nimport * as Context from \"effect/Context\"\nimport * as Data from \"effect/Data\"\nimport * as Effect from \"effect/Effect\"\nimport * as Exit from \"effect/Exit\"\nimport * as Layer from \"effect/Layer\"\nimport * as MutableHashMap from \"effect/MutableHashMap\"\nimport * as Option from \"effect/Option\"\nimport * as Predicate from \"effect/Predicate\"\nimport * as RcMap from \"effect/RcMap\"\nimport * as Rpc from \"effect/rpc/Rpc\"\nimport * as Schema from \"effect/Schema\"\nimport * as Scope from \"effect/Scope\"\nimport * as Stream from \"effect/Stream\"\nimport * as AssistantEvent from \"./AssistantEvent.ts\"\nimport { ChatId } from \"./ChatId.ts\"\nimport { ChatLog } from \"./ChatLog.ts\"\nimport * as Chat from \"./internal/chat.ts\"\nimport * as History from \"./internal/history.ts\"\nimport type * as Turns from \"./internal/turns.ts\"\n\n/**\n * Service that runs assistants' chats. An assistant's `toLayer` registers the assistant with it,\n * and the assistant's `submit` and `subscribe` use it.\n *\n * @category services\n * @since 0.1.0\n */\nexport class AssistantEngine extends Context.Service<\n  AssistantEngine,\n  {\n    /** Registers an assistant for as long as the scope is open. */\n    readonly register: (registration: Turns.Registration) => Effect.Effect<void, never, Scope.Scope>\n    /**\n     * Stores an input in one of the assistant's chats. The assistant works on it in the\n     * background.\n     */\n    readonly submit: (\n      assistant: string,\n      chatId: ChatId,\n      input: AssistantEvent.Input | AssistantEvent.StoredAppEvent\n    ) => Effect.Effect<void>\n    /** Streams the chat's stored entries after the `after` seq, then live ones. */\n    readonly subscribe: (assistant: string, chatId: ChatId, after: number) => Stream.Stream<AssistantEvent.Entry>\n    /**\n     * Deletes one of the assistant's chats. The chat's log records the deletion, and everything\n     * that works in the chat stops.\n     */\n    readonly delete: (assistant: string, chatId: ChatId) => Effect.Effect<void>\n  }\n>()(\"effect-assistant/AssistantEngine\") {}\n\nclass ChatKey extends Data.Class<{ readonly assistant: string; readonly chatId: ChatId }> {}\n\nconst notRegistered = (assistant: string) =>\n  Effect.die(`The ${assistant} assistant isn't registered: provide its toLayer.`)\n\n/**\n * Layer that runs chats in the current process. Each chat's turns run as fibers, one at a time.\n *\n * **Details**\n *\n * With `ChatLog.layerSql`, the engine resumes chats at startup. When an assistant registers, the\n * engine finds the chats that assistant was working on when the process stopped (a turn cut off\n * partway, or an input that no turn read) and runs a turn for each. Run this engine in one process\n * only, because two processes would run the same chat and write its log at the same time.\n *\n * **Example** (Running chats in memory)\n *\n * ```ts\n * import { Assistant, AssistantEngine, ChatLog } from \"effect-assistant\"\n * import type * as LanguageModel from \"effect/ai/LanguageModel\"\n * import * as Layer from \"effect/Layer\"\n *\n * declare const ModelLive: Layer.Layer<LanguageModel.LanguageModel>\n *\n * const MyAssistant = Assistant.make(\"my-assistant\")\n *\n * const AppLive = MyAssistant.toLayer((turn) => turn.loop({ instructions: \"Be brief.\" })).pipe(\n *   Layer.provide(ModelLive),\n *   Layer.provideMerge(AssistantEngine.layerMemory),\n *   Layer.provideMerge(ChatLog.layerMemory)\n * )\n * ```\n *\n * @see {@link layerCluster} for running each chat as a cluster entity\n *\n * @category layers\n * @since 0.1.0\n */\nexport const layerMemory: Layer.Layer<AssistantEngine, never, ChatLog> = Layer.effect(\n  AssistantEngine,\n  Effect.gen(function* () {\n    const context = yield* Effect.context<ChatLog>()\n    const log = yield* ChatLog\n    const registered = new Map<string, Turns.Registration>()\n    // A chat's keep-alive: a hold on its entry, so it stays open while runs or turns work in the background.\n    const held = MutableHashMap.empty<ChatKey, Scope.Closeable>()\n\n    // One entry per open chat, like a cluster entity: opened when used, closed five minutes after the last use.\n    const chats: RcMap.RcMap<ChatKey, Chat.Chat> = yield* RcMap.make({\n      lookup: Effect.fnUntraced(function* (key: ChatKey) {\n        const registration = registered.get(key.assistant)\n\n        if (registration === undefined) return yield* notRegistered(key.assistant)\n\n        return yield* Chat.make({\n          registration,\n          chatId: key.chatId,\n          keepAlive: (enabled) => keepAlive(key, enabled)\n        }).pipe(Effect.provide(context))\n      }),\n      idleTimeToLive: \"5 minutes\"\n    })\n\n    // On: a hold on the chat's entry, in a scope of its own. Off: closing that scope lets the entry go idle.\n    const keepAlive = Effect.fnUntraced(function* (key: ChatKey, enabled: boolean) {\n      if (enabled) {\n        const scope = yield* Scope.make()\n\n        yield* Effect.provideService(RcMap.get(chats, key), Scope.Scope, scope)\n\n        return MutableHashMap.set(held, key, scope)\n      }\n\n      const scope = MutableHashMap.get(held, key)\n\n      MutableHashMap.remove(held, key)\n\n      if (Option.isSome(scope)) yield* Scope.close(scope.value, Exit.void)\n    })\n\n    const withChat = Effect.fnUntraced(function* <A>(\n      assistant: string,\n      chatId: ChatId,\n      f: (chat: Chat.Chat) => Effect.Effect<A>\n    ) {\n      const chat = yield* RcMap.get(chats, new ChatKey({ assistant, chatId }))\n\n      return yield* f(chat)\n    }, Effect.scoped)\n\n    // A chat owes a turn when its last turn was cut off, or an input came after.\n    const resumeAll = Effect.fnUntraced(function* (registration: Turns.Registration) {\n      const { name } = registration.definition\n\n      for (const chatId of yield* log.unfinished) {\n        const entries = yield* log.read(chatId)\n\n        const lastTurn = entries.findLast(({ event }) => Predicate.isTagged(event, \"TurnStarted\"))?.event\n        const ours = Predicate.isTagged(lastTurn, \"TurnStarted\") && lastTurn.assistant === name\n\n        if (ours && History.needsTurn(entries)) yield* withChat(name, chatId, (chat) => chat.resume)\n      }\n    })\n\n    return AssistantEngine.of({\n      register: Effect.fn(\"AssistantEngine.register\")(function* (registration: Turns.Registration) {\n        registered.set(registration.definition.name, registration)\n        // Chats this assistant was working on when the process stopped: pick them up again.\n        yield* Effect.forkScoped(resumeAll(registration))\n      }),\n      submit: (assistant, chatId, input) => withChat(assistant, chatId, (chat) => chat.submitInBackground(input)),\n      // The chat deletes itself, so a chat that's open stops; the entry goes, and the next open finds it deleted.\n      delete: Effect.fn(\"AssistantEngine.delete\")(function* (assistant: string, chatId: ChatId) {\n        yield* withChat(assistant, chatId, (chat) => chat.delete)\n        yield* RcMap.invalidate(chats, new ChatKey({ assistant, chatId }))\n      }),\n      // The subscriber holds the chat open while it streams.\n      subscribe: (assistant, chatId, after) =>\n        Stream.unwrap(\n          Effect.gen(function* () {\n            const chat = yield* RcMap.get(chats, new ChatKey({ assistant, chatId }))\n\n            return chat.stream(after)\n          })\n        )\n    })\n  })\n)\n\ninterface EntityClient {\n  readonly submit: (chatId: ChatId, input: AssistantEvent.Input | AssistantEvent.StoredAppEvent) => Effect.Effect<void>\n  readonly subscribe: (chatId: ChatId, after: number) => Stream.Stream<AssistantEvent.Entry>\n  readonly delete: (chatId: ChatId) => Effect.Effect<void>\n}\n\nconst Submit = Rpc.make(\"Submit\", {\n  payload: { input: Schema.Union([AssistantEvent.Input, AssistantEvent.StoredAppEvent]) }\n}).annotate(ClusterSchema.Persisted, true)\n\nconst Subscribe = Rpc.make(\"Subscribe\", {\n  payload: { after: Schema.Int },\n  success: AssistantEvent.Entry,\n  stream: true\n})\n\nconst Delete = Rpc.make(\"Delete\")\n\nconst chatEntity = (assistant: string) => Entity.make(`Assistant/${assistant}`, [Submit, Subscribe, Delete])\n\ntype EngineClient = Omit<AssistantEngine[\"Service\"], \"register\">\n\n// Entity clients are made on first use, so a process that registers no assistant can still reach its chats.\nconst makeClusterClient = Effect.gen(function* () {\n  const context = yield* Effect.context<Sharding.Sharding>()\n  const clients = new Map<string, EntityClient>()\n\n  const clientOf = Effect.fnUntraced(function* (assistant: string) {\n    const known = clients.get(assistant)\n\n    if (known !== undefined) return known\n\n    const makeClient = yield* chatEntity(assistant).client.pipe(Effect.provide(context))\n\n    const client: EntityClient = {\n      submit: (chatId, input) => makeClient(chatId).Submit({ input }, { discard: true }).pipe(Effect.orDie),\n      subscribe: (chatId, after) => makeClient(chatId).Subscribe({ after }).pipe(Stream.orDie),\n      delete: (chatId) => makeClient(chatId).Delete().pipe(Effect.orDie)\n    }\n\n    clients.set(assistant, client)\n\n    return client\n  })\n\n  const engine: EngineClient = {\n    submit: Effect.fn(\"AssistantEngine.submit\")(function* (\n      assistant: string,\n      chatId: ChatId,\n      input: AssistantEvent.Input | AssistantEvent.StoredAppEvent\n    ) {\n      const client = yield* clientOf(assistant)\n\n      yield* client.submit(chatId, input)\n    }),\n    subscribe: (assistant, chatId, after) =>\n      Stream.unwrap(\n        Effect.gen(function* () {\n          const client = yield* clientOf(assistant)\n\n          return client.subscribe(chatId, after)\n        })\n      ),\n    delete: Effect.fn(\"AssistantEngine.delete\")(function* (assistant: string, chatId: ChatId) {\n      const client = yield* clientOf(assistant)\n\n      yield* client.delete(chatId)\n    })\n  }\n\n  return engine\n})\n\n/**\n * Layer that runs chats as cluster entities, one entity per chat, keyed by chat id.\n *\n * **Details**\n *\n * The layer requires `Sharding`. Use a `SingleRunner` for one process with SQL storage, a runner\n * of the app's cluster, or `TestRunner` in tests.\n *\n * **Example** (Running chats on a single runner with Postgres)\n *\n * ```ts\n * import * as NodeCrypto from \"@effect/platform-node/NodeCrypto\"\n * import * as PgClient from \"@effect/sql-pg/PgClient\"\n * import { Assistant, AssistantEngine, ChatLog } from \"effect-assistant\"\n * import type * as LanguageModel from \"effect/ai/LanguageModel\"\n * import * as SingleRunner from \"effect/cluster/SingleRunner\"\n * import * as Config from \"effect/Config\"\n * import * as Layer from \"effect/Layer\"\n *\n * declare const ModelLive: Layer.Layer<LanguageModel.LanguageModel>\n *\n * const MyAssistant = Assistant.make(\"my-assistant\")\n *\n * const AppLive = MyAssistant.toLayer((turn) => turn.loop({ instructions: \"Be brief.\" })).pipe(\n *   Layer.provide(ModelLive),\n *   Layer.provideMerge(AssistantEngine.layerCluster),\n *   Layer.provideMerge(\n *     Layer.merge(\n *       ChatLog.layerSql,\n *       SingleRunner.layer({ runnerStorage: \"sql\" }).pipe(Layer.provide(NodeCrypto.layer))\n *     )\n *   ),\n *   Layer.provide(PgClient.layerConfig({ url: Config.Redacted(\"DATABASE_URL\") }))\n * )\n * ```\n *\n * @see {@link layerMemory} for running chats in one process\n * @see {@link layerClusterClient} for a process that only reaches chats the cluster runs\n *\n * @category layers\n * @since 0.1.0\n */\nexport const layerCluster: Layer.Layer<AssistantEngine, never, ChatLog | Sharding.Sharding> = Layer.effect(\n  AssistantEngine,\n  Effect.gen(function* () {\n    const context = yield* Effect.context<ChatLog | Sharding.Sharding>()\n    const sharding = yield* Sharding.Sharding\n\n    const register = Effect.fnUntraced(function* (registration: Turns.Registration) {\n      const ChatEntity = chatEntity(registration.definition.name)\n\n      const handlers = Effect.gen(function* () {\n        const address = yield* Entity.CurrentAddress\n        const chatId = yield* Schema.decodeUnknownEffect(ChatId)(address.entityId).pipe(Effect.orDie)\n        // The entity's own: `Entity.keepAlive` needs its address and keep-alive latch, which is in there too.\n        const entityContext = yield* Effect.context<Entity.CurrentAddress | Sharding.Sharding>()\n\n        const keepAlive = (enabled: boolean) =>\n          Entity.keepAlive(enabled).pipe(\n            Effect.provide(entityContext),\n            Effect.catchCause((cause) => Effect.logWarning(\"assistant chat keep-alive failed\", cause))\n          )\n\n        // A keep-alive left on from before a restart (by a run cut off) has done its job: it started the entity.\n        yield* keepAlive(false)\n\n        const chat = yield* Chat.make({ registration, chatId, keepAlive })\n        yield* chat.resume\n\n        return ChatEntity.of({\n          // The turns run inside the request, so a crash leaves it unprocessed and the cluster redelivers it.\n          Submit: (request) => chat.submit(request.payload.input),\n          Subscribe: (request) => chat.stream(request.payload.after),\n          Delete: () => chat.delete\n        })\n      })\n\n      yield* sharding.registerEntity(ChatEntity, handlers.pipe(Effect.provide(context)), {\n        maxIdleTime: \"5 minutes\",\n        concurrency: \"unbounded\"\n      })\n    })\n\n    const client = yield* makeClusterClient\n\n    return AssistantEngine.of({\n      register: (registration) => register(registration).pipe(Effect.provide(context)),\n      ...client\n    })\n  })\n)\n\n/**\n * Layer that reaches chats running as cluster entities elsewhere, and runs none itself.\n *\n * **When to use**\n *\n * Use it in a process that only submits to, subscribes to, and deletes chats that the cluster's\n * runners run with {@link layerCluster}, such as a web server that provides an assistant's\n * `layerClient`. It needs no `ChatLog`, since the runners store the chats.\n *\n * **Details**\n *\n * The layer requires `Sharding`. An assistant's `toLayer` can't register with it: it dies, since\n * no chats run in this process.\n *\n * **Example** (A web server in front of the cluster)\n *\n * ```ts\n * import { Assistant, AssistantEngine } from \"effect-assistant\"\n * import type * as Sharding from \"effect/cluster/Sharding\"\n * import * as Layer from \"effect/Layer\"\n *\n * declare const ShardingLive: Layer.Layer<Sharding.Sharding>\n *\n * export const MyAssistant = Assistant.make(\"my-assistant\")\n *\n * const MyAssistantClient = MyAssistant.layerClient.pipe(\n *   Layer.provide(AssistantEngine.layerClusterClient),\n *   Layer.provide(ShardingLive)\n * )\n * ```\n *\n * @see {@link layerCluster} for the runners that run the chats\n *\n * @category layers\n * @since 0.3.0\n */\nexport const layerClusterClient: Layer.Layer<AssistantEngine, never, Sharding.Sharding> = Layer.effect(\n  AssistantEngine,\n  Effect.gen(function* () {\n    const client = yield* makeClusterClient\n\n    return AssistantEngine.of({\n      register: (registration) =>\n        Effect.die(\n          `The ${registration.definition.name} assistant can't register with AssistantEngine.layerClusterClient, which runs no chats: provide AssistantEngine.layerCluster where its toLayer runs.`\n        ),\n      ...client\n    })\n  })\n)\n"],"mappings":"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"}

package/dist/AssistantEvent.d.ts

@@ -1,8 +1,9 @@
 import { ChatId } from "./ChatId.js";
 import * as Schema from "effect/Schema";
 import * as Response from "effect/ai/Response";
+import * as SchemaAST from "effect/SchemaAST";
 declare namespace AssistantEvent_d_exports {
-  export { AnyEntry, AppTag, AssistantEvent, AssistantMessage, Attachment, BlockAnswer, BlocksClosed, CallOrigin, ChatDeleted, DecisionOutcome, DecisionRequested, DecisionResolved, Entry, Input, MessageBlock, ModelOutput, ModelPart, SpecialistFinished, SpecialistStarted, StoredAppEvent, ToolCallPart, ToolOutcome, ToolResult, ToolStarted, TurnCompleted, TurnFailed, TurnStarted, UserInput, UserMessage, assistantTexts, attachmentLine, formatSize, isInput, isLibraryEvent, isTurnEnd, isUserInput, isWaking, maxAttachments, textWithAttachments };
+  export { AnyEntry, AppEventSchema, AppTag, AssistantEvent, AssistantMessage, Attachment, BlockAnswer, BlocksClosed, ChatDeleted, Entry, Input, MessageBlock, ModelOutput, ModelPart, SpecialistFinished, SpecialistStarted, StoredAppEvent, ToolCallPart, ToolOutcome, ToolResult, ToolStarted, TurnCompleted, TurnFailed, TurnStarted, UserInput, UserMessage, assistantTexts, attachmentLine, formatSize, isAppInput, isInput, isLibraryEvent, isTurnEnd, isUserInput, isWaking, maxAttachments, textWithAttachments };
 }
 /**
  * Schema for a file the user attached to a message, kept by reference.
@@ -116,69 +117,6 @@ declare const SpecialistFinished_base: Schema.Class<SpecialistFinished, Schema.T
  * @since 0.1.0
  */
 export declare class SpecialistFinished extends SpecialistFinished_base {}
-/**
- * Schema for how the user decided, either `"approved"` or `"declined"`.
- *
- * @category schemas
- * @since 0.1.0
- */
-export declare const DecisionOutcome: Schema.Literals<readonly ["approved", "declined"]>;
-/**
- * Represents how the user decided.
- *
- * @category models
- * @since 0.1.0
- */
-export type DecisionOutcome = typeof DecisionOutcome.Type;
-/**
- * Schema for the origin of a decision that a tool call waits for.
- *
- * It holds the call as the model wrote it. Approving the decision runs exactly this call.
- *
- * @category schemas
- * @since 0.1.0
- */
-export declare const CallOrigin: Schema.TaggedStruct<"Call", {
-  readonly callId: Schema.String;
-  readonly tool: Schema.String;
-  readonly params: Schema.Codec<Schema.Json, Schema.Json, never, never>;
-}>;
-/**
- * Represents the origin of a decision that a tool call waits for.
- *
- * @category models
- * @since 0.1.0
- */
-export type CallOrigin = typeof CallOrigin.Type;
-declare const DecisionRequested_base: Schema.Class<DecisionRequested, Schema.TaggedStruct<"DecisionRequested", {
-  readonly id: Schema.brand<Schema.TemplateLiteral<readonly ["decision:", Schema.String]>, "~effect-assistant/DecisionId">;
-  readonly origin: Schema.TaggedStruct<"Call", {
-    readonly callId: Schema.String;
-    readonly tool: Schema.String;
-    readonly params: Schema.Codec<Schema.Json, Schema.Json, never, never>;
-  }>;
-}>, {}>;
-/**
- * Represents a request for the user to decide something, by approving or declining it.
- *
- * @category schemas
- * @since 0.1.0
- */
-export declare class DecisionRequested extends DecisionRequested_base {}
-declare const DecisionResolved_base: Schema.Class<DecisionResolved, Schema.TaggedStruct<"DecisionResolved", {
-  readonly id: Schema.brand<Schema.TemplateLiteral<readonly ["decision:", Schema.String]>, "~effect-assistant/DecisionId">;
-  readonly outcome: Schema.Literals<readonly ["approved", "declined"]>;
-  readonly answer: Schema.brand<Schema.String, "~effect-assistant/InputId">;
-}>, {}>;
-/**
- * Represents a decision the user made by answering a decision block for it.
- *
- * `answer` is the id of that `BlockAnswer`. An approved call runs at the turn's next step.
- *
- * @category schemas
- * @since 0.1.0
- */
-export declare class DecisionResolved extends DecisionResolved_base {}
 /**
  * Schema for every input `Assistant.submit` accepts.
  *
@@ -476,7 +414,7 @@ export declare class BlocksClosed extends BlocksClosed_base {}
  * @category schemas
  * @since 0.1.0
  */
-export declare const AssistantEvent: Schema.Union<readonly [typeof UserMessage, typeof BlockAnswer, typeof AssistantMessage, typeof ModelOutput, typeof ToolStarted, typeof ToolResult, typeof TurnStarted, typeof TurnCompleted, typeof TurnFailed, typeof SpecialistStarted, typeof SpecialistFinished, typeof BlocksClosed, typeof DecisionRequested, typeof DecisionResolved, typeof ChatDeleted]>;
+export declare const AssistantEvent: Schema.Union<readonly [typeof UserMessage, typeof BlockAnswer, typeof AssistantMessage, typeof ModelOutput, typeof ToolStarted, typeof ToolResult, typeof TurnStarted, typeof TurnCompleted, typeof TurnFailed, typeof SpecialistStarted, typeof SpecialistFinished, typeof BlocksClosed, typeof ChatDeleted]>;
 /**
  * Represents an event the library defines.
  *
@@ -495,18 +433,49 @@ export type AssistantEvent = typeof AssistantEvent.Type;
  * @since 0.1.0
  */
 export declare const AppTag: Schema.brand<Schema.String, "~effect-assistant/AppTag">;
+/**
+ * Represents the schema of one of the application's own events, as `Assistant.make`'s `events`
+ * takes it.
+ *
+ * **Details**
+ *
+ * It is a tagged struct or class (`Schema.TaggedStruct`, `Schema.TaggedClass`) whose `_tag` is a
+ * string literal other than the library's, and that needs no services. The log stores the event in
+ * the schema's JSON form.
+ *
+ * @category models
+ * @since 0.3.0
+ */
+export type AppEventSchema = Schema.Codec<{
+  readonly _tag: string;
+}, {
+  readonly _tag: string;
+}> & {
+  readonly fields: {
+    readonly _tag: {
+      readonly ast: SchemaAST.AST;
+    };
+  };
+};
 /**
  * Schema for one of the application's own events as it is stored, with its `_tag` and its fields
  * in JSON.
  *
- * An assistant made with `events: [AppEvent.make(Summary)]` decodes it to a `Summary` in
- * `CurrentChat`'s `entries` and in its `subscribe`.
+ * **Details**
+ *
+ * An assistant made with `events: [Summary]` decodes it to a `Summary` in `CurrentChat`'s
+ * `entries` and in its `subscribe`.
+ *
+ * An event that came in through the assistant's `submit`, from outside a turn, is an input, and the
+ * log marks it with a `"~effect-assistant/input": true` key (see {@link isAppInput}); one a turn
+ * appended has none. Decoding drops the key, so the app's schemas never see it.
  *
  * @category schemas
  * @since 0.1.0
  */
 export declare const StoredAppEvent: Schema.StructWithRest<Schema.Struct<{
   readonly _tag: Schema.brand<Schema.String, "~effect-assistant/AppTag">;
+  readonly "~effect-assistant/input": Schema.optionalKey<Schema.Literal<true>>;
 }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
 /**
  * Represents one of the application's own events, as it is stored.
@@ -524,6 +493,18 @@ export type StoredAppEvent = typeof StoredAppEvent.Type;
 export declare const isLibraryEvent: (event: {
   readonly _tag: string;
 }) => event is AssistantEvent;
+/**
+ * Returns whether one of the application's events, as the log stores it, is an input: it came in
+ * through the assistant's `submit`, from outside a turn, so storing it woke a turn. An event a turn
+ * appended (`CurrentChat`'s `append`) isn't, and neither is a decoded one, which no longer has the
+ * mark.
+ *
+ * @category guards
+ * @since 0.3.0
+ */
+export declare const isAppInput: (event: {
+  readonly _tag: string;
+}) => boolean;
 /**
  * Represents a chat's entry with any event in it, either the library's or the application's own
  * (decoded or not).
@@ -554,8 +535,9 @@ export declare const Entry: Schema.Struct<{
   readonly chatId: Schema.brand<Schema.TemplateLiteral<readonly ["chat:", Schema.String]>, "~effect-assistant/ChatId">;
   readonly seq: Schema.Int;
   readonly at: Schema.Finite;
-  readonly event: Schema.Union<readonly [Schema.Union<readonly [typeof UserMessage, typeof BlockAnswer, typeof AssistantMessage, typeof ModelOutput, typeof ToolStarted, typeof ToolResult, typeof TurnStarted, typeof TurnCompleted, typeof TurnFailed, typeof SpecialistStarted, typeof SpecialistFinished, typeof BlocksClosed, typeof DecisionRequested, typeof DecisionResolved, typeof ChatDeleted]>, Schema.StructWithRest<Schema.Struct<{
+  readonly event: Schema.Union<readonly [Schema.Union<readonly [typeof UserMessage, typeof BlockAnswer, typeof AssistantMessage, typeof ModelOutput, typeof ToolStarted, typeof ToolResult, typeof TurnStarted, typeof TurnCompleted, typeof TurnFailed, typeof SpecialistStarted, typeof SpecialistFinished, typeof BlocksClosed, typeof ChatDeleted]>, Schema.StructWithRest<Schema.Struct<{
     readonly _tag: Schema.brand<Schema.String, "~effect-assistant/AppTag">;
+    readonly "~effect-assistant/input": Schema.optionalKey<Schema.Literal<true>>;
   }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>]>;
 }>;
 /**
@@ -569,8 +551,8 @@ export type Entry = typeof Entry.Type;
  * Returns whether an event is one of the library's inputs, which are a user message, a block
  * answer, or a finished specialist run.
  *
- * The application's events that wake a turn are inputs too, but only their assistant knows which
- * (see `AppEvent`).
+ * The application's events that came in through the assistant's `submit` are inputs too (see
+ * {@link isAppInput}).
  *
  * @category guards
  * @since 0.1.0

package/dist/AssistantEvent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AssistantEvent.d.ts","names":[],"sources":["../src/AssistantEvent.ts"],"mappings":";;;;;;;;;;;;;;qBA0Ba,YAAU,OAAA;;;;;;;;;;;;;;;qBAgBV;;;;;;;YAQD,oBAAoB,WAAW;;;;;;;qBAQ9B,aAAU;;;;;;;;;qBAiBV,iBAAc,YAAgB;;;;;;;qBAS9B,sBAAmB,cAAgB,aAAe,cAAc;;;;;;;;;;;;;;;;;;;;;qBAchE,oBAAoB;;;;;;;;;;;;;;;;qBAepB,oBAAoB;;;;;;;;;;;;;;;;;;;;;qBAgBpB,2BAA2B;;;;;;;qBAkB3B,iBAAe,OAAA;;;;;;;YAQhB,yBAAyB,gBAAgB;;;;;;;;;qBAUxC,YAAU,OAAA;;;;;;;;;;;YAYX,oBAAoB,WAAW;;;;;;;;;;;;;;;qBAQ9B,0BAA0B;;;;;;;;;;;;;;qBAa1B,yBAAyB;;;;;;;qBAYzB,OAAK,OAAA,uBAAA,oBAAA,oBAAA;;;;;;;YAQN,eAAe,MAAM;;;;;;;;;;qBAWpB,WAAS,OAAA,uBAAA,oBAAA;;;;;;;YAQV,mBAAmB,UAAU;;;;;;;;;;;;qBAS5B,qBAAqB;;;;;;;;;;;;;;;qBAYrB,yBAAyB;;;;;;;;;;qBAiBzB,cAAY,OAAA;;;;;;;;;;;;;;;YAWb,sBAAsB,aAAa;;;;;;;;;;qBAWlC,WAAS,OAAA,gBAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;YAQV,mBAAmB,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAU5B,oBAAoB;;;;;;;;;;;;;;qBA2BpB,oBAAoB;;;;;;;;qBAYpB,aAAW,OAAA;;;;;;;YAQZ,qBAAqB,YAAY;;;;;;;;;;;;;;;;;;qBAYhC,mBAAmB;;;;;;;;;;;;;;;qBAcnB,oBAAoB;;;;;;;;;;;;qBAiBpB,sBAAsB;;;;;;;;;;;;;;qBAatB,mBAAmB;;;;;;;;;;;;;;;;;qBAenB,0BAA0B;;;;;;;;;;;qBAgB1B,oBAAoB;;;;;;;;;;;;;qBAWpB,qBAAqB;;;;;;;qBAUrB,gBAAc,OAAA,uBAAA,oBAAA,oBAAA,yBAAA,oBAAA,oBAAA,mBAAA,oBAAA,sBAAA,mBAAA,0BAAA,2BAAA,qBAAA,0BAAA,yBAAA;;;;;;;YAwBf,wBAAwB,eAAe;;;;;;;;;;;qBAgBtC,QAAM,OAAA,MAAA,OAAA;;;;;;;;;;;qBAYN,gBAAc,OAAA,eAAA,OAAA;;cAE2F,OAAA,QAAA,OAAA,QAAA,OAAA,MAAA,OAAA,MAAA,OAAA;;;;;;;YAQ1G,wBAAwB,eAAe;;;;;;;qBAQtC,iBAAc;WAAsB;MAAiB,SAAS;;;;;;;;;;iBAW1D;WACN,QAAQ;WACR;WACA;WACA;aAAkB;;;;;;;;;;;;qBAYhB,OAAK,OAAA;;;;;;;;;;;;;;YAaN,eAAe,MAAM;;;;;;;;;;;qBAYpB,UAAO;WAAsB;MAAiB,SAAS;;;;;;;;qBAYvD,WAAQ,OAAW;;;;;;;qBASnB,cAAW,OAAW,UAAQ,SAAS;;;;;;;qBASvC,YAAS;WAAsB;MAAiB,SAAS,gBAAgB;;;;;;;qBASzE,iBAAc,SAAa,cAAc,cAAY"}
+{"version":3,"file":"AssistantEvent.d.ts","names":[],"sources":["../src/AssistantEvent.ts"],"mappings":";;;;;;;;;;;;;;;qBA2Ba,YAAU,OAAA;;;;;;;;;;;;;;;qBAgBV;;;;;;;YAQD,oBAAoB,WAAW;;;;;;;qBAQ9B,aAAU;;;;;;;;;qBAiBV,iBAAc,YAAgB;;;;;;;qBAS9B,sBAAmB,cAAgB,aAAe,cAAc;;;;;;;;;;;;;;;;;;;;;qBAchE,oBAAoB;;;;;;;;;;;;;;;;qBAepB,oBAAoB;;;;;;;;;;;;;;;;;;;;;qBAgBpB,2BAA2B;;;;;;;qBAkB3B,OAAK,OAAA,uBAAA,oBAAA,oBAAA;;;;;;;YAQN,eAAe,MAAM;;;;;;;;;;qBAWpB,WAAS,OAAA,uBAAA,oBAAA;;;;;;;YAQV,mBAAmB,UAAU;;;;;;;;;;;;qBAS5B,qBAAqB;;;;;;;;;;;;;;;qBAYrB,yBAAyB;;;;;;;;;;qBAiBzB,cAAY,OAAA;;;;;;;;;;;;;;;YAWb,sBAAsB,aAAa;;;;;;;;;;qBAWlC,WAAS,OAAA,gBAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;YAQV,mBAAmB,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAU5B,oBAAoB;;;;;;;;;;;;;;qBA2BpB,oBAAoB;;;;;;;;qBAYpB,aAAW,OAAA;;;;;;;YAQZ,qBAAqB,YAAY;;;;;;;;;;;;;;;;;;qBAYhC,mBAAmB;;;;;;;;;;;;;;;qBAcnB,oBAAoB;;;;;;;;;;;;qBAiBpB,sBAAsB;;;;;;;;;;;;;;qBAatB,mBAAmB;;;;;;;;;;;;;;;;;qBAenB,0BAA0B;;;;;;;;;;;qBAgB1B,oBAAoB;;;;;;;;;;;;;qBAWpB,qBAAqB;;;;;;;qBAUrB,gBAAc,OAAA,uBAAA,oBAAA,oBAAA,yBAAA,oBAAA,oBAAA,mBAAA,oBAAA,sBAAA,mBAAA,0BAAA,2BAAA,qBAAA;;;;;;;YAsBf,wBAAwB,eAAe;;;;;;;;;;;qBAgBtC,QAAM,OAAA,MAAA,OAAA;;;;;;;;;;;;;;YAeP,iBAAiB,OAAO;WAAiB;;WAA2B;;WACrE;aAAmB;eAAiB,KAAK,UAAU;;;;;;;;;;;;;;;;;;;;qBAmBjD,gBAAc,OAAA,eAAA,OAAA;;;cAG0F,OAAA,QAAA,OAAA,QAAA,OAAA,MAAA,OAAA,MAAA,OAAA;;;;;;;YAQzG,wBAAwB,eAAe;;;;;;;qBAQtC,iBAAc;WAAsB;MAAiB,SAAS;;;;;;;;;;qBAW9D,aAAU;WAAsB;;;;;;;;;;;iBAY5B;WACN,QAAQ;WACR;WACA;WACA;aAAkB;;;;;;;;;;;;qBAYhB,OAAK,OAAA;;;;;;;;;;;;;;;YAaN,eAAe,MAAM;;;;;;;;;;;qBAYpB,UAAO;WAAsB;MAAiB,SAAS;;;;;;;;qBAYvD,WAAQ,OAAW;;;;;;;qBASnB,cAAW,OAAW,UAAQ,SAAS;;;;;;;qBASvC,YAAS;WAAsB;MAAiB,SAAS,gBAAgB;;;;;;;qBASzE,iBAAc,SAAa,cAAc,cAAY"}

package/dist/AssistantEvent.js

@@ -1,7 +1,7 @@
 import { __exportAll } from "./_virtual/_rolldown/runtime.js";
 import { ChatId } from "./ChatId.js";
-import { DecisionId } from "./DecisionId.js";
 import { InputId, make } from "./InputId.js";
+import { inputKey } from "./internal/input.js";
 import { RunId } from "./RunId.js";
 import * as Predicate from "effect/Predicate";
 import * as Schema from "effect/Schema";
@@ -11,7 +11,7 @@ import * as Response from "effect/ai/Response";
 * Defines the events that can happen in a chat.
 *
 * A chat is an append-only log of these events, and the log is the source of truth. A chat client
-* receives the part of the log its user sees (`ChatView`), and the model's history is rebuilt
+* receives the part of the log its user sees (its `Timeline`), and the model's history is rebuilt
 * from the log before every model call. Besides the library's events ({@link AssistantEvent}), a
 * log holds the application's own events ({@link StoredAppEvent}).
 *
@@ -24,11 +24,7 @@ var AssistantEvent_exports = /* @__PURE__ */ __exportAll({
 	Attachment: () => Attachment,
 	BlockAnswer: () => BlockAnswer,
 	BlocksClosed: () => BlocksClosed,
-	CallOrigin: () => CallOrigin,
 	ChatDeleted: () => ChatDeleted,
-	DecisionOutcome: () => DecisionOutcome,
-	DecisionRequested: () => DecisionRequested,
-	DecisionResolved: () => DecisionResolved,
 	Entry: () => Entry,
 	Input: () => Input,
 	MessageBlock: () => MessageBlock,
@@ -49,6 +45,7 @@ var AssistantEvent_exports = /* @__PURE__ */ __exportAll({
 	assistantTexts: () => assistantTexts,
 	attachmentLine: () => attachmentLine,
 	formatSize: () => formatSize,
+	isAppInput: () => isAppInput,
 	isInput: () => isInput,
 	isLibraryEvent: () => isLibraryEvent,
 	isTurnEnd: () => isTurnEnd,
@@ -159,49 +156,6 @@ var SpecialistFinished = class extends Schema.TaggedClass()("SpecialistFinished"
 	error: Schema.optional(Schema.String)
 }) {};
 /**
-* Schema for how the user decided, either `"approved"` or `"declined"`.
-*
-* @category schemas
-* @since 0.1.0
-*/
-const DecisionOutcome = Schema.Literals(["approved", "declined"]);
-/**
-* Schema for the origin of a decision that a tool call waits for.
-*
-* It holds the call as the model wrote it. Approving the decision runs exactly this call.
-*
-* @category schemas
-* @since 0.1.0
-*/
-const CallOrigin = Schema.TaggedStruct("Call", {
-	callId: Schema.String,
-	tool: Schema.String,
-	params: Schema.Json
-});
-/**
-* Represents a request for the user to decide something, by approving or declining it.
-*
-* @category schemas
-* @since 0.1.0
-*/
-var DecisionRequested = class extends Schema.TaggedClass()("DecisionRequested", {
-	id: DecisionId,
-	origin: CallOrigin
-}) {};
-/**
-* Represents a decision the user made by answering a decision block for it.
-*
-* `answer` is the id of that `BlockAnswer`. An approved call runs at the turn's next step.
-*
-* @category schemas
-* @since 0.1.0
-*/
-var DecisionResolved = class extends Schema.TaggedClass()("DecisionResolved", {
-	id: DecisionId,
-	outcome: DecisionOutcome,
-	answer: InputId
-}) {};
-/**
 * Schema for every input `Assistant.submit` accepts.
 *
 * @category schemas
@@ -428,8 +382,6 @@ const AssistantEvent = Schema.Union([
 	SpecialistStarted,
 	SpecialistFinished,
 	BlocksClosed,
-	DecisionRequested,
-	DecisionResolved,
 	ChatDeleted
 ]);
 const libraryTags = new Set(AssistantEvent.members.map((member) => member.fields._tag.schema.literal));
@@ -448,13 +400,22 @@ const AppTag = Schema.String.pipe(Schema.brand("~effect-assistant/AppTag"));
 * Schema for one of the application's own events as it is stored, with its `_tag` and its fields
 * in JSON.
 *
-* An assistant made with `events: [AppEvent.make(Summary)]` decodes it to a `Summary` in
-* `CurrentChat`'s `entries` and in its `subscribe`.
+* **Details**
+*
+* An assistant made with `events: [Summary]` decodes it to a `Summary` in `CurrentChat`'s
+* `entries` and in its `subscribe`.
+*
+* An event that came in through the assistant's `submit`, from outside a turn, is an input, and the
+* log marks it with a `"~effect-assistant/input": true` key (see {@link isAppInput}); one a turn
+* appended has none. Decoding drops the key, so the app's schemas never see it.
 *
 * @category schemas
 * @since 0.1.0
 */
-const StoredAppEvent = Schema.StructWithRest(Schema.Struct({ _tag: AppTag }), [Schema.Record(Schema.String, Schema.Json)]).check(Schema.makeFilter((event) => !libraryTags.has(event._tag) || `${event._tag} is one of the library's events`));
+const StoredAppEvent = Schema.StructWithRest(Schema.Struct({
+	_tag: AppTag,
+	[inputKey]: Schema.optionalKey(Schema.Literal(true))
+}), [Schema.Record(Schema.String, Schema.Json)]).check(Schema.makeFilter((event) => !libraryTags.has(event._tag) || `${event._tag} is one of the library's events`));
 /**
 * Returns whether an event is one of the library's, not one of the app's own.
 *
@@ -463,6 +424,16 @@ const StoredAppEvent = Schema.StructWithRest(Schema.Struct({ _tag: AppTag }), [S
 */
 const isLibraryEvent = (event) => libraryTags.has(event._tag);
 /**
+* Returns whether one of the application's events, as the log stores it, is an input: it came in
+* through the assistant's `submit`, from outside a turn, so storing it woke a turn. An event a turn
+* appended (`CurrentChat`'s `append`) isn't, and neither is a decoded one, which no longer has the
+* mark.
+*
+* @category guards
+* @since 0.3.0
+*/
+const isAppInput = (event) => !isLibraryEvent(event) && Predicate.hasProperty(event, "~effect-assistant/input") && event["~effect-assistant/input"] === true;
+/**
 * Schema for a stored event with its position in the chat.
 *
 * `seq` starts at 1 and has no gaps. `at` is the time the event was stored, in epoch
@@ -481,8 +452,8 @@ const Entry = Schema.Struct({
 * Returns whether an event is one of the library's inputs, which are a user message, a block
 * answer, or a finished specialist run.
 *
-* The application's events that wake a turn are inputs too, but only their assistant knows which
-* (see `AppEvent`).
+* The application's events that came in through the assistant's `submit` are inputs too (see
+* {@link isAppInput}).
 *
 * @category guards
 * @since 0.1.0
@@ -518,6 +489,6 @@ const isTurnEnd = (event) => Predicate.isTagged(event, "TurnCompleted") || Predi
 */
 const assistantTexts = (entries) => entries.flatMap(({ event }) => isLibraryEvent(event) && Predicate.isTagged(event, "AssistantMessage") ? [event.text] : []);
 //#endregion
-export { AppTag, AssistantEvent, AssistantEvent_exports, AssistantMessage, Attachment, BlockAnswer, BlocksClosed, CallOrigin, ChatDeleted, DecisionOutcome, DecisionRequested, DecisionResolved, Entry, Input, MessageBlock, ModelOutput, ModelPart, SpecialistFinished, SpecialistStarted, StoredAppEvent, ToolCallPart, ToolOutcome, ToolResult, ToolStarted, TurnCompleted, TurnFailed, TurnStarted, UserInput, UserMessage, assistantTexts, attachmentLine, formatSize, isInput, isLibraryEvent, isTurnEnd, isUserInput, isWaking, maxAttachments, textWithAttachments };
+export { AppTag, AssistantEvent, AssistantEvent_exports, AssistantMessage, Attachment, BlockAnswer, BlocksClosed, ChatDeleted, Entry, Input, MessageBlock, ModelOutput, ModelPart, SpecialistFinished, SpecialistStarted, StoredAppEvent, ToolCallPart, ToolOutcome, ToolResult, ToolStarted, TurnCompleted, TurnFailed, TurnStarted, UserInput, UserMessage, assistantTexts, attachmentLine, formatSize, isAppInput, isInput, isLibraryEvent, isTurnEnd, isUserInput, isWaking, maxAttachments, textWithAttachments };
 
 //# sourceMappingURL=AssistantEvent.js.map