effect-durable-agent-cloudflare 0.1.0-alpha.4

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Advait Shinde
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,28 @@
+# effect-durable-agent-cloudflare
+
+Cloudflare Durable Objects host for [`effect-durable-agent`](../../README.md).
+
+```sh
+pnpm add effect-durable-agent@alpha effect-durable-agent-cloudflare@alpha
+```
+
+```ts
+import { EDASessionDurableObject } from "effect-durable-agent-cloudflare";
+
+export class AgentSession extends EDASessionDurableObject<Env> {
+  constructor(ctx: DurableObjectState, env: Env) {
+    super(ctx, env, makeAgentOptions(env));
+  }
+}
+```
+
+The host maps one session to one SQLite-backed Durable Object and owns alarms,
+hibernatable WebSockets, RPC decoding, recovery, and sink checkpoints. Register
+only the concrete application subclass in `wrangler.jsonc`.
+
+Durable Object RPC uses structured clone. Encode Schema class instances before
+passing commands or batches across the Worker-to-object boundary with
+`encodeEdaRpcCommand` or `encodeEdaRpcSubmittables`.
+
+The core and host packages are published in lockstep and must use the same
+version.

package/dist/chunk-BBjsoOtd.js

@@ -0,0 +1,27 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+//#endregion
+export { __reExport as n, __exportAll as t };

package/dist/durable-object-CjWWNyek.js

@@ -0,0 +1,194 @@
+import { i as decodeEdaRpcSubmittables, n as decodeEdaRpcCommand, t as EDASessionDurableObjectHost } from "./durable-object-runtime-LgOJbsVm.js";
+import { DurableObject } from "cloudflare:workers";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import { DurableEventEnvelope, EDADurableEvent, effectDurableAgentNamespace } from "effect-durable-agent/types/events";
+import { EDACommand } from "effect-durable-agent/types/commands";
+import { CommandId, SequenceNumber, SessionId } from "effect-durable-agent/types/core";
+import { EDATraceMetadata, makeEDATraceMetadataFromParent, makeRootEDATraceMetadata, parseEDATraceparent } from "effect-durable-agent/types/tracing";
+//#region src/rpc-codec.ts
+/** Encode one durable event into a structured-clone-safe Durable Object RPC value. */
+const encodeEdaRpcDurableEvent = (event) => {
+	const encoded = event.namespace === effectDurableAgentNamespace ? Schema.encodeSync(EDADurableEvent)(Schema.decodeUnknownSync(EDADurableEvent)(event)) : Schema.encodeSync(DurableEventEnvelope)(event);
+	return Schema.decodeUnknownSync(DurableEventEnvelope)(encoded);
+};
+//#endregion
+//#region src/durable-object.ts
+/** Resolve a concrete EDA session Durable Object binding by domain session id. */
+const getEDASessionDurableObjectByName = (namespace, sessionId) => namespace.getByName(sessionId);
+/**
+* Base class for raw Cloudflare Durable Object hosts of one EDA session.
+*
+* Concrete products should extend this class, pass provider/tool layers from
+* their own constructor, and register only that subclass in Wrangler. The base
+* class is deliberately not exported from `workers/app.ts` and owns no binding
+* name or routing convention.
+*/
+var EDASessionDurableObject = class extends DurableObject {
+	#host;
+	constructor(ctx, env, options) {
+		super(ctx, env);
+		const storage = toEDASessionStorage(this.ctx.storage);
+		this.#host = new EDASessionDurableObjectHost({
+			...options,
+			background: this.ctx,
+			storage
+		});
+		this.ctx.blockConcurrencyWhile(async () => {
+			await Effect.runPromise(EDASessionDurableObjectHost.migrate(storage));
+		});
+	}
+	async fetch(request) {
+		if (request.headers.get("Upgrade")?.toLowerCase() !== "websocket") return new Response("Expected WebSocket upgrade.", { status: 426 });
+		const url = new URL(request.url);
+		const sessionIdRaw = url.searchParams.get("sessionId");
+		if (sessionIdRaw === null) return new Response("Missing sessionId.", { status: 400 });
+		const afterSeq = Number(url.searchParams.get("afterSeq") ?? "0");
+		if (!Number.isInteger(afterSeq) || afterSeq < 0) return new Response("Invalid afterSeq.", { status: 400 });
+		const pair = new WebSocketPair();
+		const client = pair[0];
+		const server = pair[1];
+		this.ctx.acceptWebSocket(server);
+		await this.#host.acceptEventWebSocket({
+			afterSeq: SequenceNumber.make(afterSeq),
+			sessionId: this.parseSessionId(sessionIdRaw),
+			trace: traceMetadataFromRequest(request),
+			webSocket: server
+		});
+		return new Response(null, {
+			status: 101,
+			webSocket: client
+		});
+	}
+	async submit(input) {
+		await this.restoreAcceptedEventWebSockets();
+		return encodeEdaRpcCommittedDurableEvent(await this.#host.submit({
+			command: await decodeCommand(input.command),
+			sessionId: this.parseSessionId(input.sessionId),
+			trace: decodeTraceMetadata(input.trace)
+		}));
+	}
+	async submitBatch(input) {
+		await this.restoreAcceptedEventWebSockets();
+		return (await this.#host.submitBatch({
+			items: await decodeSubmittables(input.items),
+			sessionId: this.parseSessionId(input.sessionId),
+			trace: decodeTraceMetadata(input.trace)
+		})).map(encodeEdaRpcCommittedDurableEvent);
+	}
+	async submitAndBlock(input) {
+		await this.restoreAcceptedEventWebSockets();
+		return encodeEdaRpcCommittedDurableEvent(await this.#host.submitAndBlock({
+			command: await decodeCommand(input.command),
+			sessionId: this.parseSessionId(input.sessionId),
+			trace: decodeTraceMetadata(input.trace)
+		}));
+	}
+	async blockOnCommand(input) {
+		await this.restoreAcceptedEventWebSockets();
+		return encodeEdaRpcCommittedDurableEvent(await this.#host.blockOnCommand({
+			...input.afterSeq === void 0 ? {} : { afterSeq: SequenceNumber.make(input.afterSeq) },
+			commandId: CommandId.make(input.commandId),
+			sessionId: this.parseSessionId(input.sessionId),
+			trace: decodeTraceMetadata(input.trace)
+		}));
+	}
+	async snapshot(input) {
+		await this.restoreAcceptedEventWebSockets();
+		return encodeEdaRpcSessionSnapshot(await this.#host.snapshot({
+			sessionId: this.parseSessionId(input.sessionId),
+			trace: decodeTraceMetadata(input.trace)
+		}));
+	}
+	async messages(input) {
+		await this.restoreAcceptedEventWebSockets();
+		return await this.#host.messages({
+			sessionId: this.parseSessionId(input.sessionId),
+			trace: decodeTraceMetadata(input.trace)
+		});
+	}
+	async webSocketMessage(webSocket, message) {
+		await this.#host.webSocketMessage(webSocket, message);
+	}
+	async webSocketClose(webSocket, _code, _reason, _wasClean) {
+		await this.#host.webSocketClose(webSocket);
+	}
+	async webSocketError(webSocket, _error) {
+		await this.#host.webSocketError(webSocket);
+	}
+	async destroySession(input) {
+		await this.#host.destroy({
+			sessionId: this.parseSessionId(input.sessionId),
+			trace: decodeTraceMetadata(input.trace)
+		});
+		await this.ctx.storage.deleteAlarm();
+		await this.ctx.storage.deleteAll();
+	}
+	async alarm() {
+		await this.restoreAcceptedEventWebSockets();
+		const sessionId = this.sessionIdFromObjectName();
+		await this.#host.alarm(sessionId === void 0 ? void 0 : {
+			sessionId,
+			trace: makeRootEDATraceMetadata()
+		});
+	}
+	parseSessionId(input) {
+		const sessionId = SessionId.make(input);
+		const objectName = this.ctx.id.name;
+		if (objectName !== void 0 && objectName !== sessionId) throw new Error(`EDA Durable Object name ${objectName} cannot serve session ${sessionId}`);
+		return sessionId;
+	}
+	sessionIdFromObjectName() {
+		return this.ctx.id.name === void 0 ? void 0 : SessionId.make(this.ctx.id.name);
+	}
+	async restoreAcceptedEventWebSockets() {
+		await this.#host.restoreEventWebSockets(this.ctx.getWebSockets());
+	}
+};
+const toEDASessionStorage = (storage) => {
+	return storage;
+};
+const decodeTraceMetadata = (input) => Schema.decodeUnknownSync(EDATraceMetadata)(input);
+const traceMetadataFromRequest = (request) => {
+	const parent = parseEDATraceparent(request.headers.get("traceparent"), request.headers.get("tracestate"));
+	return parent === null ? makeRootEDATraceMetadata() : makeEDATraceMetadataFromParent(parent);
+};
+/** Convenience config constructor for subclasses that need only provider/model ids. */
+const edaRuntimeConfig = (input) => ({
+	modelSelection: {
+		modelId: input.modelId,
+		provider: input.provider
+	},
+	...input.maxToolCallsPerRun === void 0 ? {} : { maxToolCallsPerRun: input.maxToolCallsPerRun },
+	...input.systemPrompt === void 0 ? {} : { systemPrompt: input.systemPrompt }
+});
+/** Encode committed events into structured-clone-safe Durable Object RPC payloads. */
+const encodeEdaRpcCommittedDurableEvent = (event) => ({
+	position: event.position,
+	event: encodeEdaRpcDurableEvent(event.event)
+});
+/** Encode runtime snapshots into structured-clone-safe Durable Object RPC payloads. */
+const encodeEdaRpcSessionSnapshot = (snapshot) => ({
+	...snapshot,
+	reducerStates: new Map(snapshot.reducerStates),
+	state: {
+		...snapshot.state,
+		commands: new Map(Array.from(snapshot.state.commands, ([commandId, record]) => [commandId, encodeCommandCarrierForRpc(record)])),
+		commandQueues: {
+			...snapshot.state.commandQueues,
+			activeControlCommands: snapshot.state.commandQueues.activeControlCommands.map(encodeCommandCarrierForRpc),
+			pendingCommands: snapshot.state.commandQueues.pendingCommands.map(encodeCommandCarrierForRpc),
+			queuedCommands: snapshot.state.commandQueues.queuedCommands.map(encodeCommandCarrierForRpc)
+		}
+	}
+});
+const encodeCommandCarrierForRpc = (value) => value.command === void 0 ? value : {
+	...value,
+	command: Schema.encodeSync(EDACommand)(value.command)
+};
+const decodeCommand = (input) => Effect.runPromise(decodeEdaRpcCommand(input));
+const decodeSubmittables = (input) => Effect.runPromise(decodeEdaRpcSubmittables(input));
+//#endregion
+export { getEDASessionDurableObjectByName as a, encodeEdaRpcSessionSnapshot as i, edaRuntimeConfig as n, encodeEdaRpcCommittedDurableEvent as r, EDASessionDurableObject as t };
+
+//# sourceMappingURL=durable-object-CjWWNyek.js.map

package/dist/durable-object-CjWWNyek.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"durable-object-CjWWNyek.js","names":["#host"],"sources":["../src/rpc-codec.ts","../src/durable-object.ts"],"sourcesContent":["import * as Schema from \"effect/Schema\";\n\nimport {\n  DurableEventEnvelope,\n  EDADurableEvent,\n  effectDurableAgentNamespace,\n} from \"effect-durable-agent/types/events\";\n\n/** Encode one durable event into a structured-clone-safe Durable Object RPC value. */\nexport const encodeEdaRpcDurableEvent = (event: DurableEventEnvelope): DurableEventEnvelope => {\n  const encoded =\n    event.namespace === effectDurableAgentNamespace\n      ? Schema.encodeSync(EDADurableEvent)(Schema.decodeUnknownSync(EDADurableEvent)(event))\n      : Schema.encodeSync(DurableEventEnvelope)(event);\n  return Schema.decodeUnknownSync(DurableEventEnvelope)(encoded);\n};\n","import { DurableObject } from \"cloudflare:workers\";\nimport * as Effect from \"effect/Effect\";\nimport * as Schema from \"effect/Schema\";\n\nimport type { DurableTranscriptMessage } from \"effect-durable-agent/domain/message-transcript\";\nimport { encodeEdaRpcDurableEvent } from \"./rpc-codec\";\nimport type { EDASessionSnapshot } from \"effect-durable-agent/services/session-query\";\nimport type { CommittedDurableEvent as CommittedDurableEventValue } from \"effect-durable-agent/services/session-store\";\nimport type {\n  CommittedCommandTerminalEvent,\n  EDARuntimeConfig,\n} from \"effect-durable-agent/services/runtime\";\nimport {\n  EDACommand,\n  type EDACommand as EDACommandValue,\n} from \"effect-durable-agent/types/commands\";\nimport type { EDASubmittable } from \"effect-durable-agent/services/session-state\";\nimport { CommandId, SequenceNumber, SessionId } from \"effect-durable-agent/types/core\";\nimport {\n  EDATraceMetadata,\n  makeEDATraceMetadataFromParent,\n  makeRootEDATraceMetadata,\n  parseEDATraceparent,\n} from \"effect-durable-agent/types/tracing\";\nimport {\n  decodeEdaRpcCommand,\n  decodeEdaRpcSubmittables,\n  EDASessionDurableObjectHost,\n  type EDASessionDurableObjectHostOptions,\n  type EDASessionDurableObjectStorage,\n} from \"./durable-object-runtime\";\n\n/** Raw RPC shape decoded before admitting one session command. */\nexport interface EDASessionCommandRpcInput {\n  readonly command: unknown;\n  readonly sessionId: string;\n  readonly trace: unknown;\n}\n\n/** Raw RPC shape decoded before admitting a durable command/app-event batch. */\nexport interface EDASessionSubmitBatchRpcInput {\n  readonly items: ReadonlyArray<unknown>;\n  readonly sessionId: string;\n  readonly trace: unknown;\n}\n\n/** Raw RPC shape for read/destroy operations that only need a session id. */\nexport interface EDASessionScopedRpcInput {\n  readonly sessionId: string;\n  readonly trace: unknown;\n}\n\n/** Raw RPC shape for WebSocket event-stream upgrades with a resume cursor. */\nexport interface EDASessionEventsRpcInput {\n  readonly afterSeq?: number;\n  readonly sessionId: string;\n  readonly trace: unknown;\n}\n\n/** Raw RPC shape decoded before blocking on one command terminal event. */\nexport interface EDASessionBlockOnCommandRpcInput {\n  readonly afterSeq?: number;\n  readonly commandId: string;\n  readonly sessionId: string;\n  readonly trace: unknown;\n}\n\n/** Constructor options for concrete app subclasses of the EDA Durable Object base. */\nexport type EDASessionDurableObjectOptions = Omit<\n  EDASessionDurableObjectHostOptions,\n  \"background\" | \"storage\"\n>;\n\n/** Resolve a concrete EDA session Durable Object binding by domain session id. */\nexport const getEDASessionDurableObjectByName = <T extends EDASessionDurableObject<object>>(\n  namespace: DurableObjectNamespace<T>,\n  sessionId: string,\n): DurableObjectStub<T> => namespace.getByName(sessionId);\n\n/**\n * Base class for raw Cloudflare Durable Object hosts of one EDA session.\n *\n * Concrete products should extend this class, pass provider/tool layers from\n * their own constructor, and register only that subclass in Wrangler. The base\n * class is deliberately not exported from `workers/app.ts` and owns no binding\n * name or routing convention.\n */\nexport abstract class EDASessionDurableObject<\n  EnvType extends object = object,\n> extends DurableObject<EnvType> {\n  readonly #host: EDASessionDurableObjectHost;\n\n  protected constructor(\n    ctx: DurableObjectState,\n    env: EnvType,\n    options: EDASessionDurableObjectOptions,\n  ) {\n    super(ctx, env);\n    const storage = toEDASessionStorage(this.ctx.storage);\n    this.#host = new EDASessionDurableObjectHost({\n      ...options,\n      background: this.ctx,\n      storage,\n    });\n\n    this.ctx.blockConcurrencyWhile(async () => {\n      await Effect.runPromise(EDASessionDurableObjectHost.migrate(storage));\n    });\n  }\n\n  async fetch(request: Request): Promise<Response> {\n    const upgrade = request.headers.get(\"Upgrade\");\n    if (upgrade?.toLowerCase() !== \"websocket\") {\n      return new Response(\"Expected WebSocket upgrade.\", { status: 426 });\n    }\n\n    const url = new URL(request.url);\n    const sessionIdRaw = url.searchParams.get(\"sessionId\");\n    if (sessionIdRaw === null) {\n      return new Response(\"Missing sessionId.\", { status: 400 });\n    }\n    const afterSeq = Number(url.searchParams.get(\"afterSeq\") ?? \"0\");\n    if (!Number.isInteger(afterSeq) || afterSeq < 0) {\n      return new Response(\"Invalid afterSeq.\", { status: 400 });\n    }\n\n    const pair = new WebSocketPair();\n    const client = pair[0];\n    const server = pair[1];\n    this.ctx.acceptWebSocket(server);\n    await this.#host.acceptEventWebSocket({\n      afterSeq: SequenceNumber.make(afterSeq),\n      sessionId: this.parseSessionId(sessionIdRaw),\n      trace: traceMetadataFromRequest(request),\n      webSocket: server,\n    });\n    return new Response(null, { status: 101, webSocket: client });\n  }\n\n  async submit(input: EDASessionCommandRpcInput): Promise<CommittedDurableEventValue> {\n    await this.restoreAcceptedEventWebSockets();\n    const committed = await this.#host.submit({\n      command: await decodeCommand(input.command),\n      sessionId: this.parseSessionId(input.sessionId),\n      trace: decodeTraceMetadata(input.trace),\n    });\n    return encodeEdaRpcCommittedDurableEvent(committed);\n  }\n\n  async submitBatch(\n    input: EDASessionSubmitBatchRpcInput,\n  ): Promise<ReadonlyArray<CommittedDurableEventValue>> {\n    await this.restoreAcceptedEventWebSockets();\n    const committed = await this.#host.submitBatch({\n      items: await decodeSubmittables(input.items),\n      sessionId: this.parseSessionId(input.sessionId),\n      trace: decodeTraceMetadata(input.trace),\n    });\n    return committed.map(encodeEdaRpcCommittedDurableEvent);\n  }\n\n  async submitAndBlock(input: EDASessionCommandRpcInput): Promise<CommittedCommandTerminalEvent> {\n    await this.restoreAcceptedEventWebSockets();\n    const committed = await this.#host.submitAndBlock({\n      command: await decodeCommand(input.command),\n      sessionId: this.parseSessionId(input.sessionId),\n      trace: decodeTraceMetadata(input.trace),\n    });\n    return encodeEdaRpcCommittedDurableEvent(committed) as CommittedCommandTerminalEvent;\n  }\n\n  async blockOnCommand(\n    input: EDASessionBlockOnCommandRpcInput,\n  ): Promise<CommittedCommandTerminalEvent> {\n    await this.restoreAcceptedEventWebSockets();\n    const committed = await this.#host.blockOnCommand({\n      ...(input.afterSeq === undefined ? {} : { afterSeq: SequenceNumber.make(input.afterSeq) }),\n      commandId: CommandId.make(input.commandId),\n      sessionId: this.parseSessionId(input.sessionId),\n      trace: decodeTraceMetadata(input.trace),\n    });\n    return encodeEdaRpcCommittedDurableEvent(committed) as CommittedCommandTerminalEvent;\n  }\n\n  async snapshot(input: EDASessionScopedRpcInput): Promise<EDASessionSnapshot> {\n    await this.restoreAcceptedEventWebSockets();\n    const snapshot = await this.#host.snapshot({\n      sessionId: this.parseSessionId(input.sessionId),\n      trace: decodeTraceMetadata(input.trace),\n    });\n    return encodeEdaRpcSessionSnapshot(snapshot);\n  }\n\n  async messages(\n    input: EDASessionScopedRpcInput,\n  ): Promise<ReadonlyArray<DurableTranscriptMessage>> {\n    await this.restoreAcceptedEventWebSockets();\n    return await this.#host.messages({\n      sessionId: this.parseSessionId(input.sessionId),\n      trace: decodeTraceMetadata(input.trace),\n    });\n  }\n\n  async webSocketMessage(webSocket: WebSocket, message: string | ArrayBuffer): Promise<void> {\n    await this.#host.webSocketMessage(webSocket, message);\n  }\n\n  async webSocketClose(\n    webSocket: WebSocket,\n    _code: number,\n    _reason: string,\n    _wasClean: boolean,\n  ): Promise<void> {\n    await this.#host.webSocketClose(webSocket);\n  }\n\n  async webSocketError(webSocket: WebSocket, _error: unknown): Promise<void> {\n    await this.#host.webSocketError(webSocket);\n  }\n\n  async destroySession(input: EDASessionScopedRpcInput): Promise<void> {\n    await this.#host.destroy({\n      sessionId: this.parseSessionId(input.sessionId),\n      trace: decodeTraceMetadata(input.trace),\n    });\n    await this.ctx.storage.deleteAlarm();\n    await this.ctx.storage.deleteAll();\n  }\n\n  async alarm(): Promise<void> {\n    await this.restoreAcceptedEventWebSockets();\n    const sessionId = this.sessionIdFromObjectName();\n    await this.#host.alarm(\n      sessionId === undefined ? undefined : { sessionId, trace: makeRootEDATraceMetadata() },\n    );\n  }\n\n  private parseSessionId(input: string): SessionId {\n    const sessionId = SessionId.make(input);\n    const objectName = this.ctx.id.name;\n    if (objectName !== undefined && objectName !== sessionId) {\n      throw new Error(`EDA Durable Object name ${objectName} cannot serve session ${sessionId}`);\n    }\n    return sessionId;\n  }\n\n  private sessionIdFromObjectName(): SessionId | undefined {\n    return this.ctx.id.name === undefined ? undefined : SessionId.make(this.ctx.id.name);\n  }\n\n  private async restoreAcceptedEventWebSockets(): Promise<void> {\n    await this.#host.restoreEventWebSockets(this.ctx.getWebSockets());\n  }\n}\n\nconst toEDASessionStorage = (storage: DurableObjectStorage): EDASessionDurableObjectStorage => {\n  // SAFETY: the adapter interface is the exact SQL, transaction, and alarm subset\n  // of DurableObjectStorage; its looser row generic also supports test implementations.\n  return storage as EDASessionDurableObjectStorage;\n};\n\nconst decodeTraceMetadata = (input: unknown): EDATraceMetadata =>\n  Schema.decodeUnknownSync(EDATraceMetadata)(input);\n\nconst traceMetadataFromRequest = (request: Request): EDATraceMetadata => {\n  const parent = parseEDATraceparent(\n    request.headers.get(\"traceparent\"),\n    request.headers.get(\"tracestate\"),\n  );\n  return parent === null ? makeRootEDATraceMetadata() : makeEDATraceMetadataFromParent(parent);\n};\n\n/** Convenience config constructor for subclasses that need only provider/model ids. */\nexport const edaRuntimeConfig = (input: {\n  readonly maxToolCallsPerRun?: number;\n  readonly modelId: string;\n  readonly provider: string;\n  readonly systemPrompt?: string;\n}): EDARuntimeConfig => ({\n  modelSelection: { modelId: input.modelId, provider: input.provider },\n  ...(input.maxToolCallsPerRun === undefined\n    ? {}\n    : { maxToolCallsPerRun: input.maxToolCallsPerRun }),\n  ...(input.systemPrompt === undefined ? {} : { systemPrompt: input.systemPrompt }),\n});\n\n/** Encode committed events into structured-clone-safe Durable Object RPC payloads. */\nexport const encodeEdaRpcCommittedDurableEvent = (\n  event: CommittedDurableEventValue,\n): CommittedDurableEventValue => ({\n  position: event.position,\n  event: encodeEdaRpcDurableEvent(event.event),\n});\n\n/** Encode runtime snapshots into structured-clone-safe Durable Object RPC payloads. */\nexport const encodeEdaRpcSessionSnapshot = (snapshot: EDASessionSnapshot): EDASessionSnapshot => ({\n  ...snapshot,\n  reducerStates: new Map(snapshot.reducerStates),\n  state: {\n    ...snapshot.state,\n    commands: new Map(\n      Array.from(snapshot.state.commands, ([commandId, record]) => [\n        commandId,\n        encodeCommandCarrierForRpc(record),\n      ]),\n    ),\n    commandQueues: {\n      ...snapshot.state.commandQueues,\n      activeControlCommands: snapshot.state.commandQueues.activeControlCommands.map(\n        encodeCommandCarrierForRpc,\n      ),\n      pendingCommands: snapshot.state.commandQueues.pendingCommands.map(encodeCommandCarrierForRpc),\n      queuedCommands: snapshot.state.commandQueues.queuedCommands.map(encodeCommandCarrierForRpc),\n    },\n  },\n});\n\nconst encodeCommandCarrierForRpc = <A extends { readonly command?: EDACommandValue }>(\n  value: A,\n): A =>\n  value.command === undefined\n    ? value\n    : {\n        ...value,\n        command: Schema.encodeSync(EDACommand)(value.command) as EDACommandValue,\n      };\n\nconst decodeCommand = (input: unknown): Promise<EDACommandValue> =>\n  Effect.runPromise(decodeEdaRpcCommand(input));\n\nconst decodeSubmittables = (\n  input: ReadonlyArray<unknown>,\n): Promise<ReadonlyArray<EDASubmittable>> => Effect.runPromise(decodeEdaRpcSubmittables(input));\n"],"mappings":"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"}

package/dist/durable-object-runtime-Dehm7PsO.d.ts

@@ -0,0 +1,265 @@
+import { t as DurableObjectSessionStorage } from "./durable-object-storage-DCL2IyUe.js";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import { EDACommand } from "effect-durable-agent/types/commands";
+import { CommandId, SequenceNumber, SessionId } from "effect-durable-agent/types/core";
+import { EDATraceMetadata } from "effect-durable-agent/types/tracing";
+import { OpenAiLanguageModel } from "@effect/ai-openai";
+import * as Layer from "effect/Layer";
+import * as Tracer from "effect/Tracer";
+import { CompactionExecutor, CompactionPolicy } from "effect-durable-agent/services/compaction";
+import { EDAPromptProjector } from "effect-durable-agent/services/prompt-projector";
+import { EDAReducer } from "effect-durable-agent/services/reducer-registry";
+import { CommittedCommandTerminalEvent, EDARuntime, EDARuntimeConfig } from "effect-durable-agent/services/runtime";
+import { CommittedDurableEvent, EDASessionStoreError } from "effect-durable-agent/services/session-store";
+import * as LanguageModel from "effect/unstable/ai/LanguageModel";
+import { DurableTranscriptMessage } from "effect-durable-agent/domain/message-transcript";
+import { EDASessionSnapshot } from "effect-durable-agent/services/session-query";
+import { EDASubmittable, SessionCommandAdmissionError } from "effect-durable-agent/services/session-state";
+import { EDASink } from "effect-durable-agent/services/sink-registry";
+import { EDAModelToolkit, EDAToolRegistryShape } from "effect-durable-agent/services/tool-registry";
+import * as Fiber from "effect/Fiber";
+import { EDAWebSocketServerFrameEncoder } from "effect-durable-agent/host/websocket-wire";
+
+//#region src/durable-object-keepalive.d.ts
+/** Minimal Durable Object storage alarm surface needed by the EDA host keepalive. */
+interface DurableObjectAlarmStorage {
+  readonly getAlarm: () => number | null | Promise<number | null>;
+  readonly setAlarm: (scheduledTimeMs: number) => void | Promise<void>;
+  readonly deleteAlarm: () => void | Promise<void>;
+}
+/** Optional host hook for background alarm writes started from synchronous observers. */
+interface DurableObjectBackgroundWaiter {
+  readonly waitUntil: (promise: Promise<unknown>) => void;
+}
+/** Configuration for the in-memory active-work heartbeat. */
+interface DurableObjectKeepAliveOptions {
+  /** Alarm interval while at least one host-tracked fiber is still unsettled. */
+  readonly intervalMs?: number;
+  /** Clock used for scheduling; tests can inject a deterministic clock. */
+  readonly now?: () => number;
+  /** Receives best-effort release/reschedule failures that cannot be awaited by the caller. */
+  readonly onBackgroundError?: (error: unknown) => void;
+}
+/** Idempotent lease for one host-tracked active Effect fiber/root. */
+interface DurableObjectKeepAliveLease {
+  readonly release: () => Promise<void>;
+}
+/**
+ * Alarm-backed in-memory keepalive for a raw Durable Object host.
+ *
+ * The active lease count is intentionally not durable: if the object is evicted
+ * or crashes, the fibers the leases represented are gone too, and normal EDA
+ * durable recovery must explain any escaped lifecycle boundaries.
+ */
+declare class DurableObjectKeepAlive {
+  private readonly storage;
+  private readonly background;
+  private readonly intervalMs;
+  private readonly now;
+  private readonly onBackgroundError;
+  private activeLeases;
+  private generation;
+  private scheduleTail;
+  private shutdownRequested;
+  constructor(storage: DurableObjectAlarmStorage, background?: DurableObjectBackgroundWaiter | undefined, options?: DurableObjectKeepAliveOptions);
+  /** Number of active unsettled host roots currently holding the heartbeat. */
+  get activeLeaseCount(): number;
+  /** Acquire one active-work lease and arm the heartbeat if this is the first lease. */
+  acquire(): Promise<DurableObjectKeepAliveLease>;
+  /** Run a promise while holding a lease. Intended for host adapters, not EDA internals. */
+  runWhileActive<A>(fn: () => Promise<A>): Promise<A>;
+  /**
+   * Track an already-forked Effect fiber as active host work until it settles.
+   *
+   * Use this with `ManagedRuntime.runFork(...)` when the fiber needs an already
+   * built runtime context. The returned lease can be released manually, but it
+   * is normally released by the fiber observer.
+   */
+  trackFiber<A, E>(fiber: Fiber.Fiber<A, E>): Promise<DurableObjectKeepAliveLease>;
+  /**
+   * Fork an Effect as host-tracked active work.
+   *
+   * This mirrors Effect's host-runner pattern: observe the root fiber and release
+   * the alarm lease when it settles. It deliberately does not patch Effect
+   * internals or try to classify runnable vs suspended fibers.
+   */
+  fork<A, E>(effect: Effect.Effect<A, E>): Promise<Fiber.Fiber<A, E>>;
+  /** Handle the Durable Object `alarm()` callback and re-arm while work remains. */
+  alarm(): Promise<void>;
+  /** Permanently stop the heartbeat and prevent later lease releases from re-arming it. */
+  shutdown(): Promise<void>;
+  /** Start a fresh lease generation after the host intentionally resets its durable state. */
+  restart(): void;
+  private waitUntil;
+  private reschedule;
+  private syncAlarm;
+}
+//#endregion
+//#region src/durable-object-runtime.d.ts
+/** Durable Object storage capabilities needed by the EDA session host. */
+type EDASessionDurableObjectStorage = DurableObjectSessionStorage & DurableObjectAlarmStorage;
+/** Options for composing one EDA runtime inside a raw Durable Object. */
+interface EDADurableObjectRuntimeLayerOptions {
+  readonly config: EDARuntimeConfig;
+  readonly compactionExecutorLayer?: Layer.Layer<CompactionExecutor, never, LanguageModel.LanguageModel>;
+  readonly compactionPolicyLayer?: Layer.Layer<CompactionPolicy>;
+  readonly keepAlive?: DurableObjectKeepAlive;
+  readonly modelLayer: Layer.Layer<LanguageModel.LanguageModel>;
+  readonly promptProjectorLayer?: Layer.Layer<EDAPromptProjector>;
+  readonly reducers?: ReadonlyArray<EDAReducer<any>>;
+  readonly sessionId: SessionId;
+  readonly sinks?: ReadonlyArray<EDASink>;
+  readonly storage: EDASessionDurableObjectStorage;
+  readonly toolkit?: EDAModelToolkit;
+  readonly toolRegistry?: EDAToolRegistryShape;
+  readonly tracer?: Tracer.Tracer;
+}
+/** Options for one live raw Durable Object host instance. */
+interface EDASessionDurableObjectHostOptions {
+  readonly background?: DurableObjectBackgroundWaiter;
+  readonly config: EDARuntimeConfig;
+  readonly compactionExecutorLayer?: Layer.Layer<CompactionExecutor, never, LanguageModel.LanguageModel>;
+  readonly compactionPolicyLayer?: Layer.Layer<CompactionPolicy>;
+  readonly keepAlive?: DurableObjectKeepAlive;
+  readonly modelLayer: Layer.Layer<LanguageModel.LanguageModel>;
+  readonly promptProjectorLayer?: Layer.Layer<EDAPromptProjector>;
+  readonly reducers?: ReadonlyArray<EDAReducer<any>>;
+  readonly sinks?: ReadonlyArray<EDASink>;
+  readonly storage: EDASessionDurableObjectStorage;
+  readonly toolkit?: EDAModelToolkit | EDAToolkitFactory;
+  readonly toolRegistry?: EDAToolRegistryShape | EDAToolRegistryFactory;
+  readonly tracer?: Tracer.Tracer | EDATracerFactory;
+  readonly webSocketProtocol?: EDAWebSocketServerFrameEncoder;
+}
+/** Per-session factory for provider-visible model toolkit definitions. */
+type EDAToolkitFactory = (input: {
+  readonly sessionId: SessionId;
+}) => EDAModelToolkit;
+/** Per-session factory for custom tool registry implementations. */
+type EDAToolRegistryFactory = (input: {
+  readonly sessionId: SessionId;
+}) => EDAToolRegistryShape;
+type EDATracerFactory = (input: {
+  readonly sessionId: SessionId;
+}) => Tracer.Tracer;
+/** Typed host input for admitting one command through RPC or route code. */
+interface EDASessionSubmitInput {
+  readonly command: EDACommand;
+  readonly sessionId: SessionId;
+  readonly trace: EDATraceMetadata;
+}
+/** Typed host input for admitting commands and app events as one durable batch. */
+interface EDASessionSubmitBatchInput {
+  readonly items: ReadonlyArray<EDASubmittable>;
+  readonly sessionId: SessionId;
+  readonly trace: EDATraceMetadata;
+}
+/** Typed host input for waiting on a command terminal boundary. */
+interface EDASessionBlockOnCommandInput {
+  readonly afterSeq?: SequenceNumber;
+  readonly commandId: CommandId;
+  readonly sessionId: SessionId;
+  readonly trace: EDATraceMetadata;
+}
+/** Typed host input for operations scoped only by session identity. */
+interface EDASessionScopedInput {
+  readonly sessionId: SessionId;
+  readonly trace: EDATraceMetadata;
+}
+/** Typed host input for opening a live event stream from a durable cursor. */
+interface EDASessionEventsInput {
+  readonly afterSeq?: SequenceNumber;
+  readonly sessionId: SessionId;
+  readonly trace: EDATraceMetadata;
+}
+/**
+ * Compose the full EDA service graph for one raw Durable Object session.
+ *
+ * The layer is intentionally host-owned: tests can pass a fake model layer,
+ * while the Worker host can pass a provider-backed layer from Env.
+ */
+declare const makeEDADurableObjectRuntimeLayer: ({
+  config,
+  compactionExecutorLayer,
+  compactionPolicyLayer,
+  keepAlive,
+  modelLayer,
+  promptProjectorLayer,
+  reducers,
+  sessionId,
+  sinks,
+  storage,
+  toolkit,
+  toolRegistry,
+  tracer
+}: EDADurableObjectRuntimeLayerOptions) => Layer.Layer<EDARuntime, SessionCommandAdmissionError>;
+/** Provider request defaults accepted by EDA's OpenAI Responses model adapter. */
+type EDAOpenAiModelConfig = Omit<typeof OpenAiLanguageModel.Config.Service, "model">;
+/** OpenAI-backed Effect AI model layer for the default Worker host. */
+declare const makeEDADurableObjectOpenAiModelLayer: (options: {
+  readonly aiGateway?: AiGateway;
+  readonly apiKey?: string;
+  readonly apiUrl?: string;
+  readonly config?: EDAOpenAiModelConfig;
+  readonly modelId: string;
+}) => Layer.Layer<LanguageModel.LanguageModel>;
+/** Raw Durable Object host controller for one EDA session object. */
+declare class EDASessionDurableObjectHost {
+  private readonly options;
+  private readonly keepAlive;
+  private readonly eventSockets;
+  private runtimeState;
+  private runtimePromise;
+  constructor(options: EDASessionDurableObjectHostOptions);
+  /** Run idempotent host and event-store migrations. Safe from `blockConcurrencyWhile`. */
+  static readonly migrate: (storage: EDASessionDurableObjectStorage) => Effect.Effect<void, EDASessionStoreError>;
+  /** Admit one command durably. Active runtime work holds EDA keep-alive leases internally. */
+  submit(input: EDASessionSubmitInput): Promise<CommittedDurableEvent>;
+  /** Submit an ordered durable batch of commands and app events. */
+  submitBatch(input: EDASessionSubmitBatchInput): Promise<ReadonlyArray<CommittedDurableEvent>>;
+  /** Admit one command and wait for its terminal command boundary. */
+  submitAndBlock(input: EDASessionSubmitInput): Promise<CommittedCommandTerminalEvent>;
+  /** Wait for an existing command to reach its terminal command boundary. */
+  blockOnCommand(input: EDASessionBlockOnCommandInput): Promise<CommittedCommandTerminalEvent>;
+  /** Read the authoritative live session snapshot. */
+  snapshot(input: EDASessionScopedInput): Promise<EDASessionSnapshot>;
+  /** Read durable transcript messages in committed order. */
+  messages(input: EDASessionScopedInput): Promise<ReadonlyArray<DurableTranscriptMessage>>;
+  /** Accept one WebSocket as the live event stream for this session. */
+  acceptEventWebSocket(input: EDASessionEventsInput & {
+    readonly webSocket: WebSocket;
+  }): Promise<void>;
+  /** Restore hibernated event WebSockets whose in-memory subscriber fibers disappeared. */
+  restoreEventWebSockets(webSockets: ReadonlyArray<WebSocket>): Promise<void>;
+  /** Route one inbound WebSocket message into the subscriber ACK queue. */
+  webSocketMessage(webSocket: WebSocket, message: string | ArrayBuffer): Promise<void>;
+  /** Interrupt subscriber work after the client closes the WebSocket. */
+  webSocketClose(webSocket: WebSocket): Promise<void>;
+  /** Interrupt subscriber work after a host WebSocket error. */
+  webSocketError(webSocket: WebSocket): Promise<void>;
+  /** Dispose any live runtime before the host deletes its Durable Object storage. */
+  destroy(_input: EDASessionScopedInput): Promise<void>;
+  /** Durable Object alarm hook: wake/recover the runtime and re-arm while EDA has active work. */
+  alarm(input?: EDASessionScopedInput): Promise<void>;
+  /** Dispose the Effect runtime if the host wrapper is torn down by tests. */
+  dispose(): Promise<void>;
+  private withRuntime;
+  private ensureEventWebSocket;
+  private startEventWebSocket;
+  private getRuntime;
+  private buildRuntime;
+}
+/** Decode a raw RPC command payload at the Durable Object boundary. */
+declare const encodeEdaRpcCommand: (input: EDACommand) => unknown;
+/** Encode a command/app-event batch into structured-clone-safe RPC values. */
+declare const encodeEdaRpcSubmittables: (input: ReadonlyArray<EDASubmittable>) => ReadonlyArray<unknown>;
+/** Decode a raw RPC command payload at the Durable Object boundary. */
+declare const decodeEdaRpcCommand: (input: unknown) => Effect.Effect<EDACommand, Schema.SchemaError>;
+/** Decode a raw RPC batch item at the Durable Object boundary. */
+declare const decodeEdaRpcSubmittable: (input: unknown) => Effect.Effect<EDASubmittable, Schema.SchemaError>;
+/** Decode raw RPC batch items at the Durable Object boundary. */
+declare const decodeEdaRpcSubmittables: (input: ReadonlyArray<unknown>) => Effect.Effect<ReadonlyArray<EDASubmittable>, Schema.SchemaError>;
+//#endregion
+export { encodeEdaRpcCommand as _, EDASessionDurableObjectHostOptions as a, makeEDADurableObjectRuntimeLayer as b, EDASessionScopedInput as c, EDAToolRegistryFactory as d, EDAToolkitFactory as f, decodeEdaRpcSubmittables as g, decodeEdaRpcSubmittable as h, EDASessionDurableObjectHost as i, EDASessionSubmitBatchInput as l, decodeEdaRpcCommand as m, EDAOpenAiModelConfig as n, EDASessionDurableObjectStorage as o, EDATracerFactory as p, EDASessionBlockOnCommandInput as r, EDASessionEventsInput as s, EDADurableObjectRuntimeLayerOptions as t, EDASessionSubmitInput as u, encodeEdaRpcSubmittables as v, makeEDADurableObjectOpenAiModelLayer as y };
+//# sourceMappingURL=durable-object-runtime-Dehm7PsO.d.ts.map