effect-assistant 0.0.0-stage → 0.2.0

package/dist/AssistantEngine.js

@@ -0,0 +1,255 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import { ChatId } from "./ChatId.js";
+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 Schema from "effect/Schema";
+import * as Stream from "effect/Stream";
+import * as ClusterSchema from "effect/cluster/ClusterSchema";
+import * as Entity from "effect/cluster/Entity";
+import * as Sharding from "effect/cluster/Sharding";
+import * as Data from "effect/Data";
+import * as Exit from "effect/Exit";
+import * as MutableHashMap from "effect/MutableHashMap";
+import * as Option from "effect/Option";
+import * as RcMap from "effect/RcMap";
+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
+* 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.
+*
+* @since 0.1.0
+*/
+var AssistantEngine_exports = /* @__PURE__ */ __exportAll({
+	AssistantEngine: () => AssistantEngine,
+	layerCluster: () => layerCluster,
+	layerMemory: () => layerMemory
+});
+/**
+* Service that runs assistants' chats. An assistant's `toLayer` registers the assistant with it,
+* and the assistant's `submit` and `subscribe` use it.
+*
+* @category services
+* @since 0.1.0
+*/
+var AssistantEngine = class extends Context.Service()("effect-assistant/AssistantEngine") {};
+var ChatKey = class extends Data.Class {};
+const notRegistered = (assistant) => Effect.die(`The ${assistant} assistant isn't registered: provide its toLayer.`);
+/**
+* Layer that runs chats in the current process. Each chat's turns run as fibers, one at a time.
+*
+* **Details**
+*
+* With `ChatLog.layerSql`, the engine resumes chats at startup. When an assistant registers, the
+* engine finds the chats that assistant was working on when the process stopped (a turn cut off
+* partway, or an input that no turn read) and runs a turn for each. Run this engine in one process
+* only, because two processes would run the same chat and write its log at the same time.
+*
+* **Example** (Running chats in memory)
+*
+* ```ts
+* import { Assistant, AssistantEngine, ChatLog } from "effect-assistant"
+* import type * as LanguageModel from "effect/ai/LanguageModel"
+* import * as Layer from "effect/Layer"
+*
+* declare const ModelLive: Layer.Layer<LanguageModel.LanguageModel>
+*
+* const MyAssistant = Assistant.make("my-assistant")
+*
+* const AppLive = MyAssistant.toLayer((turn) => turn.loop({ instructions: "Be brief." })).pipe(
+*   Layer.provide(ModelLive),
+*   Layer.provideMerge(AssistantEngine.layerMemory),
+*   Layer.provideMerge(ChatLog.layerMemory)
+* )
+* ```
+*
+* @see {@link layerCluster} for running each chat as a cluster entity
+*
+* @category layers
+* @since 0.1.0
+*/
+const layerMemory = Layer.effect(AssistantEngine, Effect.gen(function* () {
+	const context = yield* Effect.context();
+	const log = yield* ChatLog;
+	const registered = /* @__PURE__ */ new Map();
+	const held = MutableHashMap.empty();
+	const chats = yield* RcMap.make({
+		lookup: Effect.fnUntraced(function* (key) {
+			const registration = registered.get(key.assistant);
+			if (registration === void 0) return yield* notRegistered(key.assistant);
+			return yield* make({
+				registration,
+				chatId: key.chatId,
+				keepAlive: (enabled) => keepAlive(key, enabled)
+			}).pipe(Effect.provide(context));
+		}),
+		idleTimeToLive: "5 minutes"
+	});
+	const keepAlive = Effect.fnUntraced(function* (key, enabled) {
+		if (enabled) {
+			const scope = yield* Scope.make();
+			yield* Effect.provideService(RcMap.get(chats, key), Scope.Scope, scope);
+			return MutableHashMap.set(held, key, scope);
+		}
+		const scope = MutableHashMap.get(held, key);
+		MutableHashMap.remove(held, key);
+		if (Option.isSome(scope)) yield* Scope.close(scope.value, Exit.void);
+	});
+	const withChat = Effect.fnUntraced(function* (assistant, chatId, f) {
+		return yield* f(yield* RcMap.get(chats, new ChatKey({
+			assistant,
+			chatId
+		})));
+	}, Effect.scoped);
+	const resumeAll = Effect.fnUntraced(function* (registration) {
+		const { name, app } = 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);
+		}
+	});
+	return AssistantEngine.of({
+		register: Effect.fn("AssistantEngine.register")(function* (registration) {
+			registered.set(registration.definition.name, registration);
+			yield* Effect.forkScoped(resumeAll(registration));
+		}),
+		submit: (assistant, chatId, input) => withChat(assistant, chatId, (chat) => chat.submitInBackground(input)),
+		delete: Effect.fn("AssistantEngine.delete")(function* (assistant, chatId) {
+			yield* withChat(assistant, chatId, (chat) => chat.delete);
+			yield* RcMap.invalidate(chats, new ChatKey({
+				assistant,
+				chatId
+			}));
+		}),
+		subscribe: (assistant, chatId, after) => Stream.unwrap(Effect.gen(function* () {
+			return (yield* RcMap.get(chats, new ChatKey({
+				assistant,
+				chatId
+			}))).stream(after);
+		}))
+	});
+}));
+const Submit = Rpc.make("Submit", { payload: { input: Schema.Union([Input, StoredAppEvent]) } }).annotate(ClusterSchema.Persisted, true);
+const Subscribe = Rpc.make("Subscribe", {
+	payload: { after: Schema.Int },
+	success: Entry,
+	stream: true
+});
+const Delete = Rpc.make("Delete");
+const chatEntity = (assistant) => Entity.make(`Assistant/${assistant}`, [
+	Submit,
+	Subscribe,
+	Delete
+]);
+/**
+* Layer that runs chats as cluster entities, one entity per chat, keyed by chat id.
+*
+* **Details**
+*
+* The layer requires `Sharding`. Use a `SingleRunner` for one process with SQL storage, a runner
+* of the app's cluster, or `TestRunner` in tests.
+*
+* **Example** (Running chats on a single runner with Postgres)
+*
+* ```ts
+* import * as NodeCrypto from "@effect/platform-node/NodeCrypto"
+* import * as PgClient from "@effect/sql-pg/PgClient"
+* import { Assistant, AssistantEngine, ChatLog } from "effect-assistant"
+* import type * as LanguageModel from "effect/ai/LanguageModel"
+* import * as SingleRunner from "effect/cluster/SingleRunner"
+* import * as Config from "effect/Config"
+* import * as Layer from "effect/Layer"
+*
+* declare const ModelLive: Layer.Layer<LanguageModel.LanguageModel>
+*
+* const MyAssistant = Assistant.make("my-assistant")
+*
+* const AppLive = MyAssistant.toLayer((turn) => turn.loop({ instructions: "Be brief." })).pipe(
+*   Layer.provide(ModelLive),
+*   Layer.provideMerge(AssistantEngine.layerCluster),
+*   Layer.provideMerge(
+*     Layer.merge(
+*       ChatLog.layerSql,
+*       SingleRunner.layer({ runnerStorage: "sql" }).pipe(Layer.provide(NodeCrypto.layer))
+*     )
+*   ),
+*   Layer.provide(PgClient.layerConfig({ url: Config.Redacted("DATABASE_URL") }))
+* )
+* ```
+*
+* @see {@link layerMemory} for running chats in one process
+*
+* @category layers
+* @since 0.1.0
+*/
+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* () {
+			const address = yield* Entity.CurrentAddress;
+			const chatId = yield* Schema.decodeUnknownEffect(ChatId)(address.entityId).pipe(Effect.orDie);
+			const entityContext = yield* Effect.context();
+			const keepAlive = (enabled) => Entity.keepAlive(enabled).pipe(Effect.provide(entityContext), Effect.catchCause((cause) => Effect.logWarning("assistant chat keep-alive failed", cause)));
+			yield* keepAlive(false);
+			const chat = yield* make({
+				registration,
+				chatId,
+				keepAlive
+			});
+			yield* chat.resume;
+			return ChatEntity.of({
+				Submit: (request) => chat.submit(request.payload.input),
+				Subscribe: (request) => chat.stream(request.payload.after),
+				Delete: () => chat.delete
+			});
+		});
+		yield* sharding.registerEntity(ChatEntity, handlers.pipe(Effect.provide(context)), {
+			maxIdleTime: "5 minutes",
+			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;
+	});
+	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);
+		})
+	});
+}));
+//#endregion
+export { AssistantEngine, AssistantEngine_exports, layerCluster, layerMemory };
+
+//# sourceMappingURL=AssistantEngine.js.map

package/dist/AssistantEngine.js.map

@@ -0,0 +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":"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"}