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

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

@@ -1,25 +1,24 @@
 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 { 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 { EDAWebSocketServerFrameEncoder } 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 +27,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 +99,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 +110,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 +119,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 +156,76 @@ 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/session-controller.d.ts
+/** Composition options for the session use cases and Cloudflare adapters. */
+interface EDASessionControllerOptions extends Omit<EDASessionRuntimeOptions, "sessionEventObserverLayer"> {
+  readonly getWebSockets?: () => ReadonlyArray<WebSocket>;
   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;
+  readonly trace?: EDATraceMetadata;
 }
 /**
- * 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 {
+  private readonly runtime;
+  private readonly webSockets;
+  constructor(options: EDASessionControllerOptions);
+  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 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 { EDASessionScopedInput as a, EDADurableObjectRuntimeLayerOptions as c, EDASessionEventsInput as i, EDASessionDurableObjectStorage as l, EDASessionController as n, EDASessionSubmitBatchInput as o, EDASessionControllerOptions as r, EDASessionSubmitInput as s, EDASessionBlockOnCommandInput as t, makeEDADurableObjectRuntimeLayer as u };
+//# sourceMappingURL=session-controller-BSMHhS_l.d.ts.map