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

package/dist/{durable-object-runtime-Dehm7PsO.d.ts → session-controller-BCsOxE22.d.ts}

@@ -4,22 +4,22 @@ 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 { CommittedCommandTerminalEvent, EDARuntime, EDARuntimeConfig } from "effect-durable-agent/services/runtime";
+import { CommittedDurableEvent } from "effect-durable-agent/services/session-store";
 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 { SessionEventObserver } from "effect-durable-agent/services/session-event-observer";
+import { EDAWebSocketClientFrame, EDAWebSocketServerFrameEncoder, EDAWebSocketServerFrameInput } from "effect-durable-agent/websocket";
 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 * as LanguageModel from "effect/unstable/ai/LanguageModel";
+import * as Tracer from "effect/Tracer";
 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. */
@@ -28,7 +28,11 @@ interface DurableObjectAlarmStorage {
   readonly setAlarm: (scheduledTimeMs: number) => void | Promise<void>;
   readonly deleteAlarm: () => void | Promise<void>;
 }
-/** Optional host hook for background alarm writes started from synchronous observers. */
+/**
+ * Optional host hook for background alarm writes started from synchronous observers.
+ * Durable Objects already track their own async work; this hook does not keep an
+ * accepted WebSocket active or prevent WebSocket hibernation.
+ */
 interface DurableObjectBackgroundWaiter {
   readonly waitUntil: (promise: Promise<unknown>) => void;
 }
@@ -96,10 +100,10 @@ declare class DurableObjectKeepAlive {
   private syncAlarm;
 }
 //#endregion
-//#region src/durable-object-runtime.d.ts
-/** Durable Object storage capabilities needed by the EDA session host. */
+//#region src/runtime/runtime-layer.d.ts
+/** Storage capabilities used by one EDA session Durable Object. */
 type EDASessionDurableObjectStorage = DurableObjectSessionStorage & DurableObjectAlarmStorage;
-/** Options for composing one EDA runtime inside a raw Durable Object. */
+/** Host adapters and application policy needed to build one session runtime. */
 interface EDADurableObjectRuntimeLayerOptions {
   readonly config: EDARuntimeConfig;
   readonly compactionExecutorLayer?: Layer.Layer<CompactionExecutor, never, LanguageModel.LanguageModel>;
@@ -107,7 +111,8 @@ interface EDADurableObjectRuntimeLayerOptions {
   readonly keepAlive?: DurableObjectKeepAlive;
   readonly modelLayer: Layer.Layer<LanguageModel.LanguageModel>;
   readonly promptProjectorLayer?: Layer.Layer<EDAPromptProjector>;
-  readonly reducers?: ReadonlyArray<EDAReducer<any>>;
+  readonly reducers?: ReadonlyArray<EDAReducer>;
+  readonly sessionEventObserverLayer?: Layer.Layer<SessionEventObserver>;
   readonly sessionId: SessionId;
   readonly sinks?: ReadonlyArray<EDASink>;
   readonly storage: EDASessionDurableObjectStorage;
@@ -115,8 +120,36 @@ interface EDADurableObjectRuntimeLayerOptions {
   readonly toolRegistry?: EDAToolRegistryShape;
   readonly tracer?: Tracer.Tracer;
 }
-/** Options for one live raw Durable Object host instance. */
-interface EDASessionDurableObjectHostOptions {
+/** Compose the platform-neutral runtime with Cloudflare persistence and lifecycle adapters. */
+declare const makeEDADurableObjectRuntimeLayer: ({
+  config,
+  compactionExecutorLayer,
+  compactionPolicyLayer,
+  keepAlive,
+  modelLayer,
+  promptProjectorLayer,
+  reducers,
+  sessionEventObserverLayer,
+  sessionId,
+  sinks,
+  storage,
+  toolkit,
+  toolRegistry,
+  tracer
+}: EDADurableObjectRuntimeLayerOptions) => Layer.Layer<EDARuntime, SessionCommandAdmissionError>;
+//#endregion
+//#region src/runtime/session-runtime.d.ts
+type EDAToolkitFactory = (input: {
+  readonly sessionId: SessionId;
+}) => EDAModelToolkit;
+type EDAToolRegistryFactory = (input: {
+  readonly sessionId: SessionId;
+}) => EDAToolRegistryShape;
+type EDATracerFactory = (input: {
+  readonly sessionId: SessionId;
+}) => Tracer.Tracer;
+/** Configuration owned by the lazy per-isolate Effect runtime. */
+interface EDASessionRuntimeOptions {
   readonly background?: DurableObjectBackgroundWaiter;
   readonly config: EDARuntimeConfig;
   readonly compactionExecutorLayer?: Layer.Layer<CompactionExecutor, never, LanguageModel.LanguageModel>;
@@ -124,142 +157,135 @@ interface EDASessionDurableObjectHostOptions {
   readonly keepAlive?: DurableObjectKeepAlive;
   readonly modelLayer: Layer.Layer<LanguageModel.LanguageModel>;
   readonly promptProjectorLayer?: Layer.Layer<EDAPromptProjector>;
-  readonly reducers?: ReadonlyArray<EDAReducer<any>>;
+  readonly reducers?: ReadonlyArray<EDAReducer>;
+  readonly sessionEventObserverLayer: Layer.Layer<SessionEventObserver>;
   readonly sinks?: ReadonlyArray<EDASink>;
   readonly storage: EDASessionDurableObjectStorage;
   readonly toolkit?: EDAModelToolkit | EDAToolkitFactory;
   readonly toolRegistry?: EDAToolRegistryShape | EDAToolRegistryFactory;
   readonly tracer?: Tracer.Tracer | EDATracerFactory;
+}
+//#endregion
+//#region src/websocket/projection.d.ts
+/** Stable non-empty identity persisted with an app WebSocket projection. */
+declare const EDAWebSocketProjectionId: Schema.brand<Schema.NonEmptyString, "EDAWebSocketProjectionId">;
+type EDAWebSocketProjectionId = typeof EDAWebSocketProjectionId.Type;
+/** Initial state and cursor selected when an app-projected WebSocket is accepted. */
+interface EDAWebSocketProjectionInitial<State extends object> {
+  readonly afterSeq: SequenceNumber;
+  readonly state: State;
+}
+/** App projection decision for one EDA delivery frame. */
+type EDAWebSocketProjectionResult<State extends object> = {
+  readonly _tag: "Send";
+  readonly frame: string;
+  readonly state: State;
+} | {
+  /** Suppress an internal-only events frame and advance its ACK in the host. */readonly _tag: "SuppressAndAck";
+  readonly state: State;
+};
+/**
+ * App-owned wire projection hosted directly by the EDA Durable Object.
+ *
+ * The host persists `State` beside EDA delivery state, so an app can retain a
+ * stable public protocol without placing a resident WebSocket bridge in front
+ * of the hibernating object.
+ */
+interface EDAWebSocketProjection<State extends object> {
+  /** Stable identifier persisted in WebSocket attachments. */
+  readonly id: EDAWebSocketProjectionId;
+  /** Decode one app-protocol client message into EDA's delivery ACK protocol. */
+  readonly decodeClientMessage: (message: string) => Effect.Effect<EDAWebSocketClientFrame, unknown>;
+  /** Restore app-owned connection state after isolate eviction. */
+  readonly decodeState: (encoded: unknown) => Effect.Effect<State, unknown>;
+  /** Encode app-owned connection state for Cloudflare's attachment boundary. */
+  readonly encodeState: (state: State) => unknown;
+  /** Project one EDA server frame while updating app-owned connection state. */
+  readonly encodeServerFrame: (frame: EDAWebSocketServerFrameInput, state: State) => EDAWebSocketProjectionResult<State>;
+  /** Seed the projection and select its default replay cursor from a durable snapshot. */
+  readonly initialize: (input: {
+    readonly requestedAfterSeq?: SequenceNumber;
+    readonly snapshot: EDASessionSnapshot;
+  }) => EDAWebSocketProjectionInitial<State>;
+}
+//#endregion
+//#region src/session-controller.d.ts
+/** Composition options for the session use cases and Cloudflare adapters. */
+interface EDASessionControllerOptions<ProjectionState extends object = never> extends Omit<EDASessionRuntimeOptions, "sessionEventObserverLayer"> {
+  readonly getWebSockets?: () => ReadonlyArray<WebSocket>;
+  readonly webSocketProjection?: EDAWebSocketProjection<ProjectionState>;
   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;
+  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;
+  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;
+  readonly trace?: EDATraceMetadata;
 }
-/** Typed host input for operations scoped only by session identity. */
 interface EDASessionScopedInput {
   readonly sessionId: SessionId;
-  readonly trace: EDATraceMetadata;
+  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;
+}
+/** Prepared acceptance state created before a Cloudflare socket is registered. */
+interface EDAPreparedEventWebSocket<ProjectionState extends object = never> {
+  readonly afterSeq: SequenceNumber;
+  readonly sessionId: SessionId;
   readonly trace: EDATraceMetadata;
+  readonly projectionState?: ProjectionState;
 }
 /**
- * Compose the full EDA service graph for one raw Durable Object session.
+ * Public application-facing use cases for one EDA 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.
+ * Runtime lifecycle belongs to EDASessionRuntime; WebSocket transport belongs
+ * to EDAWebSocketConnectionManager. This class only coordinates them.
  */
-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. */
+declare class EDASessionController<ProjectionState extends object = never> {
+  private readonly runtime;
+  private readonly webSockets;
+  constructor(options: EDASessionControllerOptions<ProjectionState>);
+  static readonly migrate: (storage: EDASessionDurableObjectStorage) => Effect.Effect<void, import("effect-durable-agent/services/session-store").EDASessionStoreError>;
   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 projectionId?: string;
+    readonly webSocket: WebSocket;
+  }): Promise<void>;
+  private acceptEventWebSocketUnhosted;
+  prepareEventWebSocket(input: EDASessionEventsInput & {
+    readonly projectionId?: string;
+  }): Promise<EDAPreparedEventWebSocket<ProjectionState>>;
+  acceptPreparedEventWebSocket(input: EDAPreparedEventWebSocket<ProjectionState> & {
     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. */
+  webSocketClose(webSocket: WebSocket): void;
+  webSocketError(webSocket: WebSocket): void;
   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;
+  private query;
+  private prepareSession;
+  private run;
 }
-/** 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
+export { EDASessionEventsInput as a, EDASessionSubmitInput as c, EDAWebSocketProjectionInitial as d, EDAWebSocketProjectionResult as f, makeEDADurableObjectRuntimeLayer as h, EDASessionControllerOptions as i, EDAWebSocketProjection as l, EDASessionDurableObjectStorage as m, EDASessionBlockOnCommandInput as n, EDASessionScopedInput as o, EDADurableObjectRuntimeLayerOptions as p, EDASessionController as r, EDASessionSubmitBatchInput as s, EDAPreparedEventWebSocket as t, EDAWebSocketProjectionId as u };
+//# sourceMappingURL=session-controller-BCsOxE22.d.ts.map