@effect-uai/core 0.15.0 → 0.17.0

package/dist/streaming/WebSocketSession.d.mts

@@ -0,0 +1,36 @@
+import { t as AiError } from "../AiError-DvhLIbmd.mjs";
+import { Cause, Duration, Effect, Queue, Schema, Scope } from "effect";
+import * as Socket from "effect/unstable/socket/Socket";
+declare namespace WebSocketSession_d_exports {
+  export { OpenOptions, WebSocketSession, open, redactUrl, toAiError };
+}
+type WebSocketSession<A> = {
+  /** Fails `Unavailable` once the socket is closed. */
+  readonly send: (frame: string) => Effect.Effect<void, AiError>;
+  /** Ends when the socket closes cleanly, fails when it does not. */
+  readonly frames: Queue.Dequeue<A, AiError | Cause.Done>;
+};
+type OpenOptions<A, I> = {
+  readonly url: string;
+  readonly provider: string;
+  /** Frames that do not decode are dropped, and logged at debug level. */
+  readonly schema: Schema.Codec<A, I>;
+  readonly openTimeout?: Duration.Input;
+  readonly capacity?: number;
+};
+/**
+ * Some wires authenticate with a key in the query string, and some runtimes
+ * name the socket URL in their open error (Bun does). Everything taken off a
+ * socket error goes through this.
+ */
+declare const redactUrl: (text: string) => string;
+declare const toAiError: (provider: string) => (error: Socket.SocketError) => AiError;
+/**
+ * Connect for the lifetime of the surrounding `Scope`. The reader runs in a
+ * forked fiber; a dirty close reaches the consumer as a failed queue rather
+ * than a clean end.
+ */
+declare const open: <A, I>(options: OpenOptions<A, I>) => Effect.Effect<WebSocketSession<A>, AiError, Scope.Scope | Socket.WebSocketConstructor>;
+//#endregion
+export { OpenOptions, WebSocketSession, open, redactUrl, WebSocketSession_d_exports as t, toAiError };
+//# sourceMappingURL=WebSocketSession.d.mts.map

package/dist/streaming/WebSocketSession.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebSocketSession.d.mts","names":[],"sources":["../../src/streaming/WebSocketSession.ts"],"mappings":";;;;;;KAuBY,iBAAiB;;WAElB,OAAO,kBAAkB,OAAO,aAAa;;WAE7C,QAAQ,MAAM,QAAQ,GAAG,UAAkB,MAAM;;KAGhD,YAAY,GAAG;WAChB;WACA;;WAEA,QAAQ,OAAO,MAAM,GAAG;WACxB,cAAc,SAAS;WACvB;;;;;;;cAiBE,YAAS;cAeT,YAAS,sBACH,OACT,OAAO,gBAAc;;;;;;cAsBlB,OAAQ,GAAG,GAAC,SACd,YAAY,GAAG,OACvB,OAAO,OAAO,iBAAiB,IAAI,SAAiB,MAAM,QAAQ,OAAO"}

package/dist/streaming/WebSocketSession.mjs

@@ -0,0 +1,89 @@
+import { n as __exportAll } from "../rolldown-runtime-EAsCxrDo.mjs";
+import { AuthFailed, Timeout, Unavailable } from "../domain/AiError.mjs";
+import { parseSafe } from "./JSONL.mjs";
+import { Cause, Effect, Match, Option, Predicate, Queue, Schema } from "effect";
+import * as Socket from "effect/unstable/socket/Socket";
+//#region src/streaming/WebSocketSession.ts
+/**
+* One JSON-over-WebSocket session: connect, read decoded frames off a queue,
+* write frames back.
+*
+* For duplex protocols where the caller drives the conversation frame by
+* frame. The stream-shaped adapters (realtime STT and TTS) still carry their
+* own copies of this.
+*/
+var WebSocketSession_exports = /* @__PURE__ */ __exportAll({
+	open: () => open,
+	redactUrl: () => redactUrl,
+	toAiError: () => toAiError
+});
+/**
+* The cause of a failed open is a DOM `ErrorEvent`, not an `Error`, and its
+* `message` is a prototype getter, so a structural decode does not see it.
+*/
+const describeCause = (cause) => Predicate.hasProperty(cause, "message") && Predicate.isString(cause.message) ? cause.message : String(cause);
+/**
+* Some wires authenticate with a key in the query string, and some runtimes
+* name the socket URL in their open error (Bun does). Everything taken off a
+* socket error goes through this.
+*/
+const redactUrl = (text) => text.replace(/(\b(?:wss?|https?):\/\/[^\s"']*?)\?[^\s"']*/gi, "$1?<redacted>");
+const detailOf = Match.type().pipe(Match.tag("SocketCloseError", (reason) => reason.message), Match.orElse((reason) => describeCause(reason.cause)));
+/** Never the `SocketError` itself: callers print `raw` with `Cause.pretty`. */
+const rawOf = (error) => redactUrl(`${error.reason._tag}: ${detailOf(error.reason)}`);
+/** A rejected WS upgrade surfaces only as prose, so the status is read from it. */
+const isAuthRejection = (text) => /\b40[13]\b/.test(text);
+const toAiError = (provider) => (error) => {
+	const raw = rawOf(error);
+	return Match.value(error.reason).pipe(Match.tag("SocketOpenError", (reason) => Match.value(reason.kind).pipe(Match.when("Timeout", () => new Timeout({
+		provider,
+		raw
+	})), Match.orElse(() => isAuthRejection(describeCause(reason.cause)) ? new AuthFailed({
+		provider,
+		subtype: "auth",
+		raw
+	}) : new Unavailable({
+		provider,
+		raw
+	})))), Match.orElse(() => new Unavailable({
+		provider,
+		raw
+	})));
+};
+/**
+* Connect for the lifetime of the surrounding `Scope`. The reader runs in a
+* forked fiber; a dirty close reaches the consumer as a failed queue rather
+* than a clean end.
+*/
+const open = (options) => Effect.gen(function* () {
+	const asAiError = toAiError(options.provider);
+	const decode = Schema.decodeUnknownEffect(options.schema);
+	const socket = yield* Socket.makeWebSocket(options.url, {
+		closeCodeIsError: (code) => code !== 1e3 && code !== 1001 && code !== 1005,
+		...options.openTimeout !== void 0 && { openTimeout: options.openTimeout }
+	});
+	const frames = yield* Queue.bounded(options.capacity ?? 64);
+	const write = yield* socket.writer;
+	const onFrame = (raw) => Effect.gen(function* () {
+		const json = yield* parseSafe(raw);
+		if (json === void 0) return;
+		const decoded = yield* decode(json).pipe(Effect.option);
+		if (Option.isNone(decoded)) {
+			yield* Effect.logDebug(`[${options.provider}] dropped frame`, { frame: json });
+			return;
+		}
+		yield* Queue.offer(frames, decoded.value);
+	});
+	yield* socket.runString(onFrame).pipe(Effect.mapError(asAiError), Effect.matchCauseEffect({
+		onFailure: (cause) => Cause.hasFails(cause) ? Queue.failCause(frames, cause) : Queue.end(frames),
+		onSuccess: () => Queue.end(frames)
+	}), Effect.forkScoped);
+	return {
+		send: (frame) => write(frame).pipe(Effect.mapError(asAiError)),
+		frames
+	};
+});
+//#endregion
+export { open, redactUrl, WebSocketSession_exports as t, toAiError };
+
+//# sourceMappingURL=WebSocketSession.mjs.map

package/dist/streaming/WebSocketSession.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebSocketSession.mjs","names":["AiError.Timeout","AiError.AuthFailed","AiError.Unavailable","JSONL.parseSafe"],"sources":["../../src/streaming/WebSocketSession.ts"],"sourcesContent":["/**\n * One JSON-over-WebSocket session: connect, read decoded frames off a queue,\n * write frames back.\n *\n * For duplex protocols where the caller drives the conversation frame by\n * frame. The stream-shaped adapters (realtime STT and TTS) still carry their\n * own copies of this.\n */\nimport {\n  Cause,\n  type Duration,\n  Effect,\n  Match,\n  Option,\n  Predicate,\n  Queue,\n  Schema,\n  type Scope,\n} from \"effect\"\nimport * as Socket from \"effect/unstable/socket/Socket\"\nimport * as AiError from \"../domain/AiError.js\"\nimport * as JSONL from \"./JSONL.js\"\n\nexport type WebSocketSession<A> = {\n  /** Fails `Unavailable` once the socket is closed. */\n  readonly send: (frame: string) => Effect.Effect<void, AiError.AiError>\n  /** Ends when the socket closes cleanly, fails when it does not. */\n  readonly frames: Queue.Dequeue<A, AiError.AiError | Cause.Done>\n}\n\nexport type OpenOptions<A, I> = {\n  readonly url: string\n  readonly provider: string\n  /** Frames that do not decode are dropped, and logged at debug level. */\n  readonly schema: Schema.Codec<A, I>\n  readonly openTimeout?: Duration.Input\n  readonly capacity?: number\n}\n\n/**\n * The cause of a failed open is a DOM `ErrorEvent`, not an `Error`, and its\n * `message` is a prototype getter, so a structural decode does not see it.\n */\nconst describeCause = (cause: unknown): string =>\n  Predicate.hasProperty(cause, \"message\") && Predicate.isString(cause.message)\n    ? cause.message\n    : String(cause)\n\n/**\n * Some wires authenticate with a key in the query string, and some runtimes\n * name the socket URL in their open error (Bun does). Everything taken off a\n * socket error goes through this.\n */\nexport const redactUrl = (text: string): string =>\n  text.replace(/(\\b(?:wss?|https?):\\/\\/[^\\s\"']*?)\\?[^\\s\"']*/gi, \"$1?<redacted>\")\n\nconst detailOf = Match.type<Socket.SocketError[\"reason\"]>().pipe(\n  Match.tag(\"SocketCloseError\", (reason) => reason.message),\n  Match.orElse((reason) => describeCause(reason.cause)),\n)\n\n/** Never the `SocketError` itself: callers print `raw` with `Cause.pretty`. */\nconst rawOf = (error: Socket.SocketError): string =>\n  redactUrl(`${error.reason._tag}: ${detailOf(error.reason)}`)\n\n/** A rejected WS upgrade surfaces only as prose, so the status is read from it. */\nconst isAuthRejection = (text: string): boolean => /\\b40[13]\\b/.test(text)\n\nexport const toAiError =\n  (provider: string) =>\n  (error: Socket.SocketError): AiError.AiError => {\n    const raw = rawOf(error)\n    return Match.value(error.reason).pipe(\n      Match.tag(\"SocketOpenError\", (reason) =>\n        Match.value(reason.kind).pipe(\n          Match.when(\"Timeout\", (): AiError.AiError => new AiError.Timeout({ provider, raw })),\n          Match.orElse((): AiError.AiError =>\n            isAuthRejection(describeCause(reason.cause))\n              ? new AiError.AuthFailed({ provider, subtype: \"auth\", raw })\n              : new AiError.Unavailable({ provider, raw }),\n          ),\n        ),\n      ),\n      Match.orElse((): AiError.AiError => new AiError.Unavailable({ provider, raw })),\n    )\n  }\n\n/**\n * Connect for the lifetime of the surrounding `Scope`. The reader runs in a\n * forked fiber; a dirty close reaches the consumer as a failed queue rather\n * than a clean end.\n */\nexport const open = <A, I>(\n  options: OpenOptions<A, I>,\n): Effect.Effect<WebSocketSession<A>, AiError.AiError, Scope.Scope | Socket.WebSocketConstructor> =>\n  Effect.gen(function* () {\n    const asAiError = toAiError(options.provider)\n    const decode = Schema.decodeUnknownEffect(options.schema)\n    const socket = yield* Socket.makeWebSocket(options.url, {\n      // Effect's Socket treats every close code as an error by default.\n      closeCodeIsError: (code) => code !== 1000 && code !== 1001 && code !== 1005,\n      ...(options.openTimeout !== undefined && { openTimeout: options.openTimeout }),\n    })\n    const frames = yield* Queue.bounded<A, AiError.AiError | Cause.Done>(options.capacity ?? 64)\n    const write = yield* socket.writer\n\n    const onFrame = (raw: string) =>\n      Effect.gen(function* () {\n        const json = yield* JSONL.parseSafe(raw)\n        if (json === undefined) return\n        const decoded = yield* decode(json).pipe(Effect.option)\n        if (Option.isNone(decoded)) {\n          yield* Effect.logDebug(`[${options.provider}] dropped frame`, { frame: json })\n          return\n        }\n        yield* Queue.offer(frames, decoded.value)\n      })\n\n    yield* socket.runString(onFrame).pipe(\n      Effect.mapError(asAiError),\n      // `Queue.end` on a clean close so the consumer drains what is queued;\n      // a failure must not arrive looking like the end of the conversation.\n      Effect.matchCauseEffect({\n        onFailure: (cause) =>\n          Cause.hasFails(cause) ? Queue.failCause(frames, cause) : Queue.end(frames),\n        onSuccess: () => Queue.end(frames),\n      }),\n      Effect.forkScoped,\n    )\n\n    return { send: (frame: string) => write(frame).pipe(Effect.mapError(asAiError)), frames }\n  })\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AA2CA,MAAM,iBAAiB,UACrB,UAAU,YAAY,OAAO,SAAS,KAAK,UAAU,SAAS,MAAM,OAAO,IACvE,MAAM,UACN,OAAO,KAAK;;;;;;AAOlB,MAAa,aAAa,SACxB,KAAK,QAAQ,iDAAiD,eAAe;AAE/E,MAAM,WAAW,MAAM,KAAmC,CAAC,CAAC,KAC1D,MAAM,IAAI,qBAAqB,WAAW,OAAO,OAAO,GACxD,MAAM,QAAQ,WAAW,cAAc,OAAO,KAAK,CAAC,CACtD;;AAGA,MAAM,SAAS,UACb,UAAU,GAAG,MAAM,OAAO,KAAK,IAAI,SAAS,MAAM,MAAM,GAAG;;AAG7D,MAAM,mBAAmB,SAA0B,aAAa,KAAK,IAAI;AAEzE,MAAa,aACV,cACA,UAA+C;CAC9C,MAAM,MAAM,MAAM,KAAK;CACvB,OAAO,MAAM,MAAM,MAAM,MAAM,CAAC,CAAC,KAC/B,MAAM,IAAI,oBAAoB,WAC5B,MAAM,MAAM,OAAO,IAAI,CAAC,CAAC,KACvB,MAAM,KAAK,iBAAkC,IAAIA,QAAgB;EAAE;EAAU;CAAI,CAAC,CAAC,GACnF,MAAM,aACJ,gBAAgB,cAAc,OAAO,KAAK,CAAC,IACvC,IAAIC,WAAmB;EAAE;EAAU,SAAS;EAAQ;CAAI,CAAC,IACzD,IAAIC,YAAoB;EAAE;EAAU;CAAI,CAAC,CAC/C,CACF,CACF,GACA,MAAM,aAA8B,IAAIA,YAAoB;EAAE;EAAU;CAAI,CAAC,CAAC,CAChF;AACF;;;;;;AAOF,MAAa,QACX,YAEA,OAAO,IAAI,aAAa;CACtB,MAAM,YAAY,UAAU,QAAQ,QAAQ;CAC5C,MAAM,SAAS,OAAO,oBAAoB,QAAQ,MAAM;CACxD,MAAM,SAAS,OAAO,OAAO,cAAc,QAAQ,KAAK;EAEtD,mBAAmB,SAAS,SAAS,OAAQ,SAAS,QAAQ,SAAS;EACvE,GAAI,QAAQ,gBAAgB,KAAA,KAAa,EAAE,aAAa,QAAQ,YAAY;CAC9E,CAAC;CACD,MAAM,SAAS,OAAO,MAAM,QAAyC,QAAQ,YAAY,EAAE;CAC3F,MAAM,QAAQ,OAAO,OAAO;CAE5B,MAAM,WAAW,QACf,OAAO,IAAI,aAAa;EACtB,MAAM,OAAO,OAAOC,UAAgB,GAAG;EACvC,IAAI,SAAS,KAAA,GAAW;EACxB,MAAM,UAAU,OAAO,OAAO,IAAI,CAAC,CAAC,KAAK,OAAO,MAAM;EACtD,IAAI,OAAO,OAAO,OAAO,GAAG;GAC1B,OAAO,OAAO,SAAS,IAAI,QAAQ,SAAS,kBAAkB,EAAE,OAAO,KAAK,CAAC;GAC7E;EACF;EACA,OAAO,MAAM,MAAM,QAAQ,QAAQ,KAAK;CAC1C,CAAC;CAEH,OAAO,OAAO,UAAU,OAAO,CAAC,CAAC,KAC/B,OAAO,SAAS,SAAS,GAGzB,OAAO,iBAAiB;EACtB,YAAY,UACV,MAAM,SAAS,KAAK,IAAI,MAAM,UAAU,QAAQ,KAAK,IAAI,MAAM,IAAI,MAAM;EAC3E,iBAAiB,MAAM,IAAI,MAAM;CACnC,CAAC,GACD,OAAO,UACT;CAEA,OAAO;EAAE,OAAO,UAAkB,MAAM,KAAK,CAAC,CAAC,KAAK,OAAO,SAAS,SAAS,CAAC;EAAG;CAAO;AAC1F,CAAC"}

package/dist/streaming/WebSocketSession.test.d.mts

@@ -0,0 +1 @@
+export {}

package/dist/streaming/WebSocketSession.test.mjs

@@ -0,0 +1,51 @@
+import { describe } from "../domain/AiError.mjs";
+import { toAiError } from "./WebSocketSession.mjs";
+import { o as describe$1 } from "../utils-CiH_DjFW.mjs";
+import { n as globalExpect } from "../test.DNmyFkvJ-YPzDR0Co.mjs";
+import { t as it } from "../dist-nohcnkD6.mjs";
+import * as Socket from "effect/unstable/socket/Socket";
+//#region src/streaming/WebSocketSession.test.ts
+const KEY = "AIzaSyEXAMPLEKEY";
+const URL = `wss://generativelanguage.googleapis.com/ws/BidiGenerateContent?key=${KEY}`;
+/**
+* What Bun hands the `error` listener when the upgrade is rejected: the whole
+* socket URL, in prose, on a prototype getter. Node and Deno say less, but the
+* adapter cannot know which runtime it is on.
+*/
+var BunErrorEvent = class {
+	get message() {
+		return `WebSocket connection to '${URL}' failed: Connection ended`;
+	}
+};
+/** Deno names the status but not the URL, also on a prototype getter. */
+var DenoErrorEvent = class {
+	detail;
+	constructor(detail) {
+		this.detail = detail;
+	}
+	get message() {
+		return `NetworkError: failed to connect to WebSocket: ${this.detail}`;
+	}
+};
+const openFailure = (cause) => new Socket.SocketError({ reason: new Socket.SocketOpenError({
+	kind: "Unknown",
+	cause
+}) });
+describe$1("WebSocketSession errors", () => {
+	it("keeps the key out of the error a rejected upgrade produces", () => {
+		const error = toAiError("google")(openFailure(new BunErrorEvent()));
+		globalExpect(JSON.stringify(error)).not.toContain(KEY);
+		globalExpect(describe(error)).not.toContain(KEY);
+		globalExpect(JSON.stringify(error)).toContain("generativelanguage.googleapis.com");
+	});
+	it("reads the rejected status out of the prose, wherever the runtime put it", () => {
+		const forbidden = toAiError("google")(openFailure(new DenoErrorEvent("Invalid status code: 403")));
+		const ended = toAiError("google")(openFailure(new BunErrorEvent()));
+		globalExpect(forbidden._tag).toBe("AuthFailed");
+		globalExpect(ended._tag).toBe("Unavailable");
+	});
+});
+//#endregion
+export {};
+
+//# sourceMappingURL=WebSocketSession.test.mjs.map

package/dist/streaming/WebSocketSession.test.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebSocketSession.test.mjs","names":["describe","AiError.describe"],"sources":["../../src/streaming/WebSocketSession.test.ts"],"sourcesContent":["import { describe, it } from \"@effect/vitest\"\nimport * as Socket from \"effect/unstable/socket/Socket\"\nimport { expect } from \"vitest\"\nimport * as AiError from \"../domain/AiError.js\"\nimport { toAiError } from \"./WebSocketSession.js\"\n\nconst KEY = \"AIzaSyEXAMPLEKEY\"\nconst URL = `wss://generativelanguage.googleapis.com/ws/BidiGenerateContent?key=${KEY}`\n\n/**\n * What Bun hands the `error` listener when the upgrade is rejected: the whole\n * socket URL, in prose, on a prototype getter. Node and Deno say less, but the\n * adapter cannot know which runtime it is on.\n */\nclass BunErrorEvent {\n  get message(): string {\n    return `WebSocket connection to '${URL}' failed: Connection ended`\n  }\n}\n\n/** Deno names the status but not the URL, also on a prototype getter. */\nclass DenoErrorEvent {\n  constructor(private readonly detail: string) {}\n  get message(): string {\n    return `NetworkError: failed to connect to WebSocket: ${this.detail}`\n  }\n}\n\nconst openFailure = (cause: unknown) =>\n  new Socket.SocketError({ reason: new Socket.SocketOpenError({ kind: \"Unknown\", cause }) })\n\ndescribe(\"WebSocketSession errors\", () => {\n  it(\"keeps the key out of the error a rejected upgrade produces\", () => {\n    const error = toAiError(\"google\")(openFailure(new BunErrorEvent()))\n\n    expect(JSON.stringify(error)).not.toContain(KEY)\n    expect(AiError.describe(error)).not.toContain(KEY)\n    // The host is still there: an error that says nothing is its own problem.\n    expect(JSON.stringify(error)).toContain(\"generativelanguage.googleapis.com\")\n  })\n\n  it(\"reads the rejected status out of the prose, wherever the runtime put it\", () => {\n    // Deno's wording. The status is the only hint a rejected upgrade gives.\n    const forbidden = toAiError(\"google\")(\n      openFailure(new DenoErrorEvent(\"Invalid status code: 403\")),\n    )\n    const ended = toAiError(\"google\")(openFailure(new BunErrorEvent()))\n\n    expect(forbidden._tag).toBe(\"AuthFailed\")\n    expect(ended._tag).toBe(\"Unavailable\")\n  })\n})\n"],"mappings":";;;;;;;AAMA,MAAM,MAAM;AACZ,MAAM,MAAM,sEAAsE;;;;;;AAOlF,IAAM,gBAAN,MAAoB;CAClB,IAAI,UAAkB;EACpB,OAAO,4BAA4B,IAAI;CACzC;AACF;;AAGA,IAAM,iBAAN,MAAqB;CACU;CAA7B,YAAY,QAAiC;EAAhB,KAAA,SAAA;CAAiB;CAC9C,IAAI,UAAkB;EACpB,OAAO,iDAAiD,KAAK;CAC/D;AACF;AAEA,MAAM,eAAe,UACnB,IAAI,OAAO,YAAY,EAAE,QAAQ,IAAI,OAAO,gBAAgB;CAAE,MAAM;CAAW;AAAM,CAAC,EAAE,CAAC;AAE3FA,WAAS,iCAAiC;CACxC,GAAG,oEAAoE;EACrE,MAAM,QAAQ,UAAU,QAAQ,CAAC,CAAC,YAAY,IAAI,cAAc,CAAC,CAAC;EAElE,aAAO,KAAK,UAAU,KAAK,CAAC,CAAC,CAAC,IAAI,UAAU,GAAG;EAC/C,aAAOC,SAAiB,KAAK,CAAC,CAAC,CAAC,IAAI,UAAU,GAAG;EAEjD,aAAO,KAAK,UAAU,KAAK,CAAC,CAAC,CAAC,UAAU,mCAAmC;CAC7E,CAAC;CAED,GAAG,iFAAiF;EAElF,MAAM,YAAY,UAAU,QAAQ,CAAC,CACnC,YAAY,IAAI,eAAe,0BAA0B,CAAC,CAC5D;EACA,MAAM,QAAQ,UAAU,QAAQ,CAAC,CAAC,YAAY,IAAI,cAAc,CAAC,CAAC;EAElE,aAAO,UAAU,IAAI,CAAC,CAAC,KAAK,YAAY;EACxC,aAAO,MAAM,IAAI,CAAC,CAAC,KAAK,aAAa;CACvC,CAAC;AACH,CAAC"}

package/dist/testing/FakeWebSocket.d.mts

@@ -0,0 +1,25 @@
+import { Effect, Layer, Scope } from "effect";
+import * as Socket from "effect/unstable/socket/Socket";
+//#region src/testing/FakeWebSocket.d.ts
+type FakeWebSocketServer = {
+  /** Every frame the client has sent, JSON-parsed, oldest first. */
+  readonly sent: Effect.Effect<ReadonlyArray<unknown>>;
+  /** Deliver one frame to the client. */
+  readonly push: (frame: unknown) => Effect.Effect<void>;
+  /** Close the socket. 1000, 1001 and 1005 are the clean codes. */
+  readonly close: (code?: number) => Effect.Effect<void>;
+  /** Hand this to an adapter that takes a socket constructor directly. */
+  readonly connect: Socket.WebSocketConstructor["Service"];
+  /** Provide this in place of the real constructor. */
+  readonly layer: Layer.Layer<Socket.WebSocketConstructor>;
+};
+type FakeWebSocketOptions = {
+  /** Pushed once the client subscribes, for a protocol whose server speaks first. */
+  readonly greeting?: ReadonlyArray<unknown>;
+  /** How the server answers each client frame. */
+  readonly reply?: (frame: unknown) => Effect.Effect<ReadonlyArray<unknown>>;
+};
+declare const make: (options?: FakeWebSocketOptions) => Effect.Effect<FakeWebSocketServer, never, Scope.Scope>;
+//#endregion
+export { FakeWebSocketOptions, FakeWebSocketServer, make };
+//# sourceMappingURL=FakeWebSocket.d.mts.map

package/dist/testing/FakeWebSocket.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FakeWebSocket.d.mts","names":[],"sources":["../../src/testing/FakeWebSocket.ts"],"mappings":";;;KAeY;;WAED,MAAM,OAAO,OAAO;;WAEpB,OAAO,mBAAmB,OAAO;;WAEjC,QAAQ,kBAAkB,OAAO;;WAEjC,SAAS,OAAO;;WAEhB,OAAO,MAAM,MAAM,OAAO;;KAGzB;;WAED,WAAW;;WAEX,SAAS,mBAAmB,OAAO,OAAO;;cAWxC,OAAI,UACL,yBACT,OAAO,OAAO,4BAA4B,MAAM"}

package/dist/testing/FakeWebSocket.mjs

@@ -0,0 +1,79 @@
+import { Effect, Layer, Queue, Ref, Stream } from "effect";
+import * as Socket from "effect/unstable/socket/Socket";
+//#region src/testing/FakeWebSocket.ts
+/**
+* An in-memory WebSocket for testing socket adapters without a server.
+*
+* Provide `layer` in place of the real `Socket.WebSocketConstructor` and the
+* adapter runs end to end: its own connect, handshake, decode and teardown.
+* The test plays the other end with `reply`, `push`, `close` and `sent`.
+*
+* Client frames land on a queue, so the scripted server is a forked fiber and
+* `reply` is a real Effect. What stays imperative is the listener table the
+* shim registers, since `Socket.makeWebSocket` drives it with plain callbacks.
+* The shim is a plain object, so nothing here touches a platform global.
+*/
+const OPEN = 1;
+const CLOSED = 3;
+/** Run after the current call unwinds, so the client is never re-entered. */
+const soon = (run) => void Promise.resolve().then(run);
+const make = (options) => Effect.gen(function* () {
+	const inbound = yield* Queue.unbounded();
+	const sent = yield* Ref.make([]);
+	const wiring = {
+		listeners: {},
+		readyState: OPEN,
+		greeted: false
+	};
+	const emit = (type, event) => (wiring.listeners[type] ?? []).forEach((listener) => listener(event));
+	const deliverSync = (frames) => frames.forEach((f) => emit("message", { data: JSON.stringify(f) }));
+	const deliver = (frames) => Effect.sync(() => deliverSync(frames));
+	const shutdown = (code) => {
+		if (wiring.readyState === CLOSED) return;
+		wiring.readyState = CLOSED;
+		emit("close", {
+			code,
+			reason: ""
+		});
+	};
+	yield* Stream.fromQueue(inbound).pipe(Stream.runForEach((frame) => Effect.gen(function* () {
+		yield* Ref.update(sent, (frames) => [...frames, frame]);
+		const answer = yield* options?.reply?.(frame) ?? Effect.succeed([]);
+		yield* deliver(answer);
+	})), Effect.forkScoped);
+	const socket = {
+		get readyState() {
+			return wiring.readyState;
+		},
+		addEventListener: (type, fn) => {
+			wiring.listeners = {
+				...wiring.listeners,
+				[type]: [...wiring.listeners[type] ?? [], fn]
+			};
+			if (type === "message" && !wiring.greeted) {
+				wiring.greeted = true;
+				soon(() => deliverSync(options?.greeting ?? []));
+			}
+		},
+		removeEventListener: (type, fn) => {
+			wiring.listeners = {
+				...wiring.listeners,
+				[type]: (wiring.listeners[type] ?? []).filter((l) => l !== fn)
+			};
+		},
+		send: (data) => void Queue.offerUnsafe(inbound, JSON.parse(data)),
+		close: (code = 1e3) => shutdown(code)
+	};
+	const connect = () => socket;
+	return {
+		sent: Ref.get(sent),
+		push: (frame) => deliver([frame]),
+		close: (code = 1e3) => Effect.sync(() => shutdown(code)),
+		connect,
+		layer: Layer.succeed(Socket.WebSocketConstructor, connect)
+	};
+});
+//#endregion
+export { make };
+
+//# sourceMappingURL=FakeWebSocket.mjs.map

package/dist/testing/FakeWebSocket.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"FakeWebSocket.mjs","names":[],"sources":["../../src/testing/FakeWebSocket.ts"],"sourcesContent":["/**\n * An in-memory WebSocket for testing socket adapters without a server.\n *\n * Provide `layer` in place of the real `Socket.WebSocketConstructor` and the\n * adapter runs end to end: its own connect, handshake, decode and teardown.\n * The test plays the other end with `reply`, `push`, `close` and `sent`.\n *\n * Client frames land on a queue, so the scripted server is a forked fiber and\n * `reply` is a real Effect. What stays imperative is the listener table the\n * shim registers, since `Socket.makeWebSocket` drives it with plain callbacks.\n * The shim is a plain object, so nothing here touches a platform global.\n */\nimport { Effect, Layer, Queue, Ref, type Scope, Stream } from \"effect\"\nimport * as Socket from \"effect/unstable/socket/Socket\"\n\nexport type FakeWebSocketServer = {\n  /** Every frame the client has sent, JSON-parsed, oldest first. */\n  readonly sent: Effect.Effect<ReadonlyArray<unknown>>\n  /** Deliver one frame to the client. */\n  readonly push: (frame: unknown) => Effect.Effect<void>\n  /** Close the socket. 1000, 1001 and 1005 are the clean codes. */\n  readonly close: (code?: number) => Effect.Effect<void>\n  /** Hand this to an adapter that takes a socket constructor directly. */\n  readonly connect: Socket.WebSocketConstructor[\"Service\"]\n  /** Provide this in place of the real constructor. */\n  readonly layer: Layer.Layer<Socket.WebSocketConstructor>\n}\n\nexport type FakeWebSocketOptions = {\n  /** Pushed once the client subscribes, for a protocol whose server speaks first. */\n  readonly greeting?: ReadonlyArray<unknown>\n  /** How the server answers each client frame. */\n  readonly reply?: (frame: unknown) => Effect.Effect<ReadonlyArray<unknown>>\n}\n\ntype Listener = (event: any) => void\n\nconst OPEN = 1\nconst CLOSED = 3\n\n/** Run after the current call unwinds, so the client is never re-entered. */\nconst soon = (run: () => void): void => void Promise.resolve().then(run)\n\nexport const make = (\n  options?: FakeWebSocketOptions,\n): Effect.Effect<FakeWebSocketServer, never, Scope.Scope> =>\n  Effect.gen(function* () {\n    const inbound = yield* Queue.unbounded<unknown>()\n    const sent = yield* Ref.make<ReadonlyArray<unknown>>([])\n\n    const wiring = {\n      listeners: {} as Record<string, ReadonlyArray<Listener>>,\n      readyState: OPEN,\n      greeted: false,\n    }\n\n    const emit = (type: string, event: unknown): void =>\n      (wiring.listeners[type] ?? []).forEach((listener) => listener(event))\n\n    const deliverSync = (frames: ReadonlyArray<unknown>): void =>\n      frames.forEach((f) => emit(\"message\", { data: JSON.stringify(f) }))\n\n    const deliver = (frames: ReadonlyArray<unknown>): Effect.Effect<void> =>\n      Effect.sync(() => deliverSync(frames))\n\n    const shutdown = (code: number): void => {\n      if (wiring.readyState === CLOSED) return\n      wiring.readyState = CLOSED\n      emit(\"close\", { code, reason: \"\" })\n    }\n\n    // The scripted server. Answers land on their own turn, like a real one.\n    yield* Stream.fromQueue(inbound).pipe(\n      Stream.runForEach((frame) =>\n        Effect.gen(function* () {\n          yield* Ref.update(sent, (frames) => [...frames, frame])\n          const answer = yield* options?.reply?.(frame) ?? Effect.succeed([])\n          yield* deliver(answer)\n        }),\n      ),\n      Effect.forkScoped,\n    )\n\n    const socket = {\n      get readyState() {\n        return wiring.readyState\n      },\n      addEventListener: (type: string, fn: Listener): void => {\n        wiring.listeners = {\n          ...wiring.listeners,\n          [type]: [...(wiring.listeners[type] ?? []), fn],\n        }\n        // The greeting waits for a subscriber before it lands.\n        if (type === \"message\" && !wiring.greeted) {\n          wiring.greeted = true\n          soon(() => deliverSync(options?.greeting ?? []))\n        }\n      },\n      removeEventListener: (type: string, fn: Listener): void => {\n        wiring.listeners = {\n          ...wiring.listeners,\n          [type]: (wiring.listeners[type] ?? []).filter((l) => l !== fn),\n        }\n      },\n      // Safe from a synchronous callback, and no runtime needed.\n      send: (data: string): void => void Queue.offerUnsafe(inbound, JSON.parse(data)),\n      close: (code = 1000): void => shutdown(code),\n    }\n\n    const connect: Socket.WebSocketConstructor[\"Service\"] = () =>\n      socket as unknown as globalThis.WebSocket\n\n    return {\n      sent: Ref.get(sent),\n      push: (frame) => deliver([frame]),\n      close: (code = 1000) => Effect.sync(() => shutdown(code)),\n      connect,\n      layer: Layer.succeed(Socket.WebSocketConstructor, connect),\n    }\n  })\n"],"mappings":";;;;;;;;;;;;;;;AAqCA,MAAM,OAAO;AACb,MAAM,SAAS;;AAGf,MAAM,QAAQ,QAA0B,KAAK,QAAQ,QAAQ,CAAC,CAAC,KAAK,GAAG;AAEvE,MAAa,QACX,YAEA,OAAO,IAAI,aAAa;CACtB,MAAM,UAAU,OAAO,MAAM,UAAmB;CAChD,MAAM,OAAO,OAAO,IAAI,KAA6B,CAAC,CAAC;CAEvD,MAAM,SAAS;EACb,WAAW,CAAC;EACZ,YAAY;EACZ,SAAS;CACX;CAEA,MAAM,QAAQ,MAAc,WACzB,OAAO,UAAU,SAAS,CAAC,EAAA,CAAG,SAAS,aAAa,SAAS,KAAK,CAAC;CAEtE,MAAM,eAAe,WACnB,OAAO,SAAS,MAAM,KAAK,WAAW,EAAE,MAAM,KAAK,UAAU,CAAC,EAAE,CAAC,CAAC;CAEpE,MAAM,WAAW,WACf,OAAO,WAAW,YAAY,MAAM,CAAC;CAEvC,MAAM,YAAY,SAAuB;EACvC,IAAI,OAAO,eAAe,QAAQ;EAClC,OAAO,aAAa;EACpB,KAAK,SAAS;GAAE;GAAM,QAAQ;EAAG,CAAC;CACpC;CAGA,OAAO,OAAO,UAAU,OAAO,CAAC,CAAC,KAC/B,OAAO,YAAY,UACjB,OAAO,IAAI,aAAa;EACtB,OAAO,IAAI,OAAO,OAAO,WAAW,CAAC,GAAG,QAAQ,KAAK,CAAC;EACtD,MAAM,SAAS,OAAO,SAAS,QAAQ,KAAK,KAAK,OAAO,QAAQ,CAAC,CAAC;EAClE,OAAO,QAAQ,MAAM;CACvB,CAAC,CACH,GACA,OAAO,UACT;CAEA,MAAM,SAAS;EACb,IAAI,aAAa;GACf,OAAO,OAAO;EAChB;EACA,mBAAmB,MAAc,OAAuB;GACtD,OAAO,YAAY;IACjB,GAAG,OAAO;KACT,OAAO,CAAC,GAAI,OAAO,UAAU,SAAS,CAAC,GAAI,EAAE;GAChD;GAEA,IAAI,SAAS,aAAa,CAAC,OAAO,SAAS;IACzC,OAAO,UAAU;IACjB,WAAW,YAAY,SAAS,YAAY,CAAC,CAAC,CAAC;GACjD;EACF;EACA,sBAAsB,MAAc,OAAuB;GACzD,OAAO,YAAY;IACjB,GAAG,OAAO;KACT,QAAQ,OAAO,UAAU,SAAS,CAAC,EAAA,CAAG,QAAQ,MAAM,MAAM,EAAE;GAC/D;EACF;EAEA,OAAO,SAAuB,KAAK,MAAM,YAAY,SAAS,KAAK,MAAM,IAAI,CAAC;EAC9E,QAAQ,OAAO,QAAe,SAAS,IAAI;CAC7C;CAEA,MAAM,gBACJ;CAEF,OAAO;EACL,MAAM,IAAI,IAAI,IAAI;EAClB,OAAO,UAAU,QAAQ,CAAC,KAAK,CAAC;EAChC,QAAQ,OAAO,QAAS,OAAO,WAAW,SAAS,IAAI,CAAC;EACxD;EACA,OAAO,MAAM,QAAQ,OAAO,sBAAsB,OAAO;CAC3D;AACF,CAAC"}

package/dist/testing/MockRealtimeSession.d.mts

@@ -0,0 +1,30 @@
+import { CommonSessionRequest, RealtimeEvent, RealtimeInput } from "../domain/Realtime.mjs";
+import { RealtimeSession, RealtimeVideoInput } from "../realtime/RealtimeSession.mjs";
+import { Effect, Layer } from "effect";
+//#region src/testing/MockRealtimeSession.d.ts
+type MockRealtimeSessionRecorder = {
+  readonly openCalls: ReadonlyArray<CommonSessionRequest>;
+  readonly sent: ReadonlyArray<RealtimeInput>;
+};
+type MockRealtimeSessionScript = {
+  /** Emitted as soon as the session opens. */
+  readonly initial?: ReadonlyArray<RealtimeEvent>;
+  /** The server's answer to each input. */
+  readonly onInput?: (input: RealtimeInput) => ReadonlyArray<RealtimeEvent>;
+};
+/** Scripted session that also ships the `RealtimeVideoInput` marker. */
+declare const layer: (script: MockRealtimeSessionScript) => {
+  readonly layer: Layer.Layer<RealtimeSession | RealtimeVideoInput>;
+  readonly recorder: Effect.Effect<MockRealtimeSessionRecorder>;
+};
+/**
+ * The same without the marker, to test that a caller sending video against an
+ * audio-only provider fails to compile.
+ */
+declare const layerAudioOnly: (script: MockRealtimeSessionScript) => {
+  readonly layer: Layer.Layer<RealtimeSession>;
+  readonly recorder: Effect.Effect<MockRealtimeSessionRecorder>;
+};
+//#endregion
+export { MockRealtimeSessionRecorder, MockRealtimeSessionScript, layer, layerAudioOnly };
+//# sourceMappingURL=MockRealtimeSession.d.mts.map

package/dist/testing/MockRealtimeSession.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MockRealtimeSession.d.mts","names":[],"sources":["../../src/testing/MockRealtimeSession.ts"],"mappings":";;;;KASY;WACD,WAAW,cAAc;WACzB,MAAM,cAAc;;KAGnB;;WAED,UAAU,cAAc;;WAExB,WAAW,OAAO,kBAAkB,cAAc;;;cAgDhD,QAAK,QACR;WAEC,OAAO,MAAM,MAAM,kBAAkB;WACrC,UAAU,OAAO,OAAO;;;;;;cAatB,iBAAc,QACjB;WAEC,OAAO,MAAM,MAAM;WACnB,UAAU,OAAO,OAAO"}

package/dist/testing/MockRealtimeSession.mjs

@@ -0,0 +1,52 @@
+import { RealtimeSession, RealtimeVideoInput } from "../realtime/RealtimeSession.mjs";
+import { Effect, Layer, Queue, Ref, Stream } from "effect";
+//#region src/testing/MockRealtimeSession.ts
+const makeService = (script, record) => ({ open: (request) => Effect.gen(function* () {
+	yield* record.open(request);
+	const queue = yield* Queue.unbounded();
+	yield* Effect.addFinalizer(() => Queue.end(queue));
+	yield* Queue.offerAll(queue, script.initial ?? []);
+	return {
+		send: (input) => Effect.andThen(record.send(input), Queue.offerAll(queue, script.onInput?.(input) ?? [])).pipe(Effect.asVoid),
+		events: Stream.fromQueue(queue)
+	};
+}) });
+const build = (script) => {
+	const openCalls = Ref.makeUnsafe([]);
+	const sent = Ref.makeUnsafe([]);
+	return {
+		sessionLayer: Layer.succeed(RealtimeSession, makeService(script, {
+			open: (request) => Ref.update(openCalls, (xs) => [...xs, request]),
+			send: (input) => Ref.update(sent, (xs) => [...xs, input])
+		})),
+		recorder: Effect.gen(function* () {
+			return {
+				openCalls: yield* Ref.get(openCalls),
+				sent: yield* Ref.get(sent)
+			};
+		})
+	};
+};
+/** Scripted session that also ships the `RealtimeVideoInput` marker. */
+const layer = (script) => {
+	const { sessionLayer, recorder } = build(script);
+	return {
+		layer: Layer.merge(sessionLayer, Layer.succeed(RealtimeVideoInput, void 0)),
+		recorder
+	};
+};
+/**
+* The same without the marker, to test that a caller sending video against an
+* audio-only provider fails to compile.
+*/
+const layerAudioOnly = (script) => {
+	const { sessionLayer, recorder } = build(script);
+	return {
+		layer: sessionLayer,
+		recorder
+	};
+};
+//#endregion
+export { layer, layerAudioOnly };
+
+//# sourceMappingURL=MockRealtimeSession.mjs.map

package/dist/testing/MockRealtimeSession.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"MockRealtimeSession.mjs","names":[],"sources":["../../src/testing/MockRealtimeSession.ts"],"sourcesContent":["import { Cause, Effect, Layer, Queue, Ref, Stream } from \"effect\"\nimport type { CommonSessionRequest, RealtimeEvent, RealtimeInput } from \"../domain/Realtime.js\"\nimport {\n  RealtimeSession,\n  RealtimeVideoInput,\n  type RealtimeSessionHandle,\n  type RealtimeSessionService,\n} from \"../realtime/RealtimeSession.js\"\n\nexport type MockRealtimeSessionRecorder = {\n  readonly openCalls: ReadonlyArray<CommonSessionRequest>\n  readonly sent: ReadonlyArray<RealtimeInput>\n}\n\nexport type MockRealtimeSessionScript = {\n  /** Emitted as soon as the session opens. */\n  readonly initial?: ReadonlyArray<RealtimeEvent>\n  /** The server's answer to each input. */\n  readonly onInput?: (input: RealtimeInput) => ReadonlyArray<RealtimeEvent>\n}\n\ntype Recorders = {\n  readonly open: (request: CommonSessionRequest) => Effect.Effect<void>\n  readonly send: (input: RealtimeInput) => Effect.Effect<void>\n}\n\nconst makeService = (\n  script: MockRealtimeSessionScript,\n  record: Recorders,\n): RealtimeSessionService => ({\n  open: (request) =>\n    Effect.gen(function* () {\n      yield* record.open(request)\n      const queue = yield* Queue.unbounded<RealtimeEvent, Cause.Done>()\n      // Closing the scope ends `events`, leaving anything already queued to drain.\n      yield* Effect.addFinalizer(() => Queue.end(queue))\n      yield* Queue.offerAll(queue, script.initial ?? [])\n      const handle: RealtimeSessionHandle = {\n        send: (input) =>\n          Effect.andThen(\n            record.send(input),\n            Queue.offerAll(queue, script.onInput?.(input) ?? []),\n          ).pipe(Effect.asVoid),\n        events: Stream.fromQueue(queue),\n      }\n      return handle\n    }),\n})\n\nconst build = (script: MockRealtimeSessionScript) => {\n  const openCalls = Ref.makeUnsafe<ReadonlyArray<CommonSessionRequest>>([])\n  const sent = Ref.makeUnsafe<ReadonlyArray<RealtimeInput>>([])\n  const sessionLayer = Layer.succeed(\n    RealtimeSession,\n    makeService(script, {\n      open: (request) => Ref.update(openCalls, (xs) => [...xs, request]),\n      send: (input) => Ref.update(sent, (xs) => [...xs, input]),\n    }),\n  )\n  const recorder: Effect.Effect<MockRealtimeSessionRecorder> = Effect.gen(function* () {\n    return { openCalls: yield* Ref.get(openCalls), sent: yield* Ref.get(sent) }\n  })\n  return { sessionLayer, recorder }\n}\n\n/** Scripted session that also ships the `RealtimeVideoInput` marker. */\nexport const layer = (\n  script: MockRealtimeSessionScript,\n): {\n  readonly layer: Layer.Layer<RealtimeSession | RealtimeVideoInput>\n  readonly recorder: Effect.Effect<MockRealtimeSessionRecorder>\n} => {\n  const { sessionLayer, recorder } = build(script)\n  return {\n    layer: Layer.merge(sessionLayer, Layer.succeed(RealtimeVideoInput, undefined)),\n    recorder,\n  }\n}\n\n/**\n * The same without the marker, to test that a caller sending video against an\n * audio-only provider fails to compile.\n */\nexport const layerAudioOnly = (\n  script: MockRealtimeSessionScript,\n): {\n  readonly layer: Layer.Layer<RealtimeSession>\n  readonly recorder: Effect.Effect<MockRealtimeSessionRecorder>\n} => {\n  const { sessionLayer, recorder } = build(script)\n  return { layer: sessionLayer, recorder }\n}\n"],"mappings":";;;AA0BA,MAAM,eACJ,QACA,YAC4B,EAC5B,OAAO,YACL,OAAO,IAAI,aAAa;CACtB,OAAO,OAAO,KAAK,OAAO;CAC1B,MAAM,QAAQ,OAAO,MAAM,UAAqC;CAEhE,OAAO,OAAO,mBAAmB,MAAM,IAAI,KAAK,CAAC;CACjD,OAAO,MAAM,SAAS,OAAO,OAAO,WAAW,CAAC,CAAC;CASjD,OAAO;EAPL,OAAO,UACL,OAAO,QACL,OAAO,KAAK,KAAK,GACjB,MAAM,SAAS,OAAO,OAAO,UAAU,KAAK,KAAK,CAAC,CAAC,CACrD,CAAC,CAAC,KAAK,OAAO,MAAM;EACtB,QAAQ,OAAO,UAAU,KAAK;CAEpB;AACd,CAAC,EACL;AAEA,MAAM,SAAS,WAAsC;CACnD,MAAM,YAAY,IAAI,WAAgD,CAAC,CAAC;CACxE,MAAM,OAAO,IAAI,WAAyC,CAAC,CAAC;CAW5D,OAAO;EAAE,cAVY,MAAM,QACzB,iBACA,YAAY,QAAQ;GAClB,OAAO,YAAY,IAAI,OAAO,YAAY,OAAO,CAAC,GAAG,IAAI,OAAO,CAAC;GACjE,OAAO,UAAU,IAAI,OAAO,OAAO,OAAO,CAAC,GAAG,IAAI,KAAK,CAAC;EAC1D,CAAC,CAKiB;EAAG,UAHsC,OAAO,IAAI,aAAa;GACnF,OAAO;IAAE,WAAW,OAAO,IAAI,IAAI,SAAS;IAAG,MAAM,OAAO,IAAI,IAAI,IAAI;GAAE;EAC5E,CAC8B;CAAE;AAClC;;AAGA,MAAa,SACX,WAIG;CACH,MAAM,EAAE,cAAc,aAAa,MAAM,MAAM;CAC/C,OAAO;EACL,OAAO,MAAM,MAAM,cAAc,MAAM,QAAQ,oBAAoB,KAAA,CAAS,CAAC;EAC7E;CACF;AACF;;;;;AAMA,MAAa,kBACX,WAIG;CACH,MAAM,EAAE,cAAc,aAAa,MAAM,MAAM;CAC/C,OAAO;EAAE,OAAO;EAAc;CAAS;AACzC"}

package/dist/tool/Toolkit.d.mts

@@ -1,2 +1,2 @@
-import { S as wrap, _ as fromArray, a as ToolMap, b as namespace, c as ToolkitR, d as appendToolResults, f as collectResults, g as descriptors, h as describeFailures, i as NoDuplicateNames, m as continueWithResults, n as ExecuteOptions, o as Toolkit, p as compose, r as Middleware, s as ToolkitE, t as DuplicateToolName, u as UniqueTools, v as make, x as run, y as makeNamespaced } from "../Toolkit-DAjJ9Tvl.mjs";
+import { S as wrap, _ as fromArray, a as ToolMap, b as namespace, c as ToolkitR, d as appendToolResults, f as collectResults, g as descriptors, h as describeFailures, i as NoDuplicateNames, m as continueWithResults, n as ExecuteOptions, o as Toolkit, p as compose, r as Middleware, s as ToolkitE, t as DuplicateToolName, u as UniqueTools, v as make, x as run, y as makeNamespaced } from "../Toolkit-tlL0F2YR.mjs";
 export { DuplicateToolName, ExecuteOptions, Middleware, NoDuplicateNames, ToolMap, Toolkit, ToolkitE, ToolkitR, UniqueTools, appendToolResults, collectResults, compose, continueWithResults, describeFailures, descriptors, fromArray, make, makeNamespaced, namespace, run, wrap };

package/dist/transcriber/Transcriber.d.mts

@@ -1,4 +1,4 @@
-import { t as AiError } from "../AiError-eLV9t1lU.mjs";
+import { t as AiError } from "../AiError-DvhLIbmd.mjs";
 import { a as AudioSource, r as AudioFormat } from "../Audio-_nGR4V0X.mjs";
 import { TranscriptEvent, TranscriptResult } from "../domain/Transcript.mjs";
 import { Context, Effect, Stream } from "effect";

package/dist/web-read/WebRead.d.mts

@@ -1,4 +1,4 @@
-import { t as AiError } from "../AiError-eLV9t1lU.mjs";
+import { t as AiError } from "../AiError-DvhLIbmd.mjs";
 import { Context, Duration, Effect } from "effect";
 declare namespace WebRead_d_exports {
   export { CommonReadRequest, ReadFormat, ReadResponse, WebRead, WebReadService, read };

package/dist/web-read/WebReadTool.d.mts

@@ -1,5 +1,5 @@
 import { l as Tool } from "../Tool-BF78QWtn.mjs";
-import { t as AiError } from "../AiError-eLV9t1lU.mjs";
+import { t as AiError } from "../AiError-DvhLIbmd.mjs";
 import { ReadFormat, ReadResponse, WebRead } from "./WebRead.mjs";
 import { Schema } from "effect";
 declare namespace WebReadTool_d_exports {

package/dist/web-search/WebSearch.d.mts

@@ -1,4 +1,4 @@
-import { t as AiError } from "../AiError-eLV9t1lU.mjs";
+import { t as AiError } from "../AiError-DvhLIbmd.mjs";
 import { Context, DateTime, Effect, Schema } from "effect";
 declare namespace WebSearch_d_exports {
   export { CommonSearchRequest, SearchRecency, SearchResponse, SearchResult, WebSearch, WebSearchService, search };

package/dist/web-search/WebSearchTool.d.mts

@@ -1,5 +1,5 @@
 import { l as Tool } from "../Tool-BF78QWtn.mjs";
-import { t as AiError } from "../AiError-eLV9t1lU.mjs";
+import { t as AiError } from "../AiError-DvhLIbmd.mjs";
 import { SearchResult, WebSearch } from "./WebSearch.mjs";
 import { Schema } from "effect";
 declare namespace WebSearchTool_d_exports {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect-uai/core",
-  "version": "0.15.0",
+  "version": "0.17.0",
   "description": "Low-level primitives (loop, conversation, items, tools, streaming codecs) for building AI agents with Effect.",
   "keywords": [
     "agents",
@@ -90,6 +90,14 @@
       "types": "./dist/domain/Music.d.mts",
       "import": "./dist/domain/Music.mjs"
     },
+    "./Realtime": {
+      "types": "./dist/domain/Realtime.d.mts",
+      "import": "./dist/domain/Realtime.mjs"
+    },
+    "./RealtimeSession": {
+      "types": "./dist/realtime/RealtimeSession.d.mts",
+      "import": "./dist/realtime/RealtimeSession.mjs"
+    },
     "./Transcript": {
       "types": "./dist/domain/Transcript.d.mts",
       "import": "./dist/domain/Transcript.mjs"
@@ -98,6 +106,14 @@
       "types": "./dist/domain/Turn.d.mts",
       "import": "./dist/domain/Turn.mjs"
     },
+    "./Decision": {
+      "types": "./dist/decision-model/Decision.d.mts",
+      "import": "./dist/decision-model/Decision.mjs"
+    },
+    "./DecisionModel": {
+      "types": "./dist/decision-model/DecisionModel.d.mts",
+      "import": "./dist/decision-model/DecisionModel.mjs"
+    },
     "./Embedding": {
       "types": "./dist/embedding-model/Embedding.d.mts",
       "import": "./dist/embedding-model/Embedding.mjs"
@@ -178,9 +194,13 @@
       "types": "./dist/web-search/WebSearchTool.d.mts",
       "import": "./dist/web-search/WebSearchTool.mjs"
     },
-    "./Inbox": {
-      "types": "./dist/inbox/Inbox.d.mts",
-      "import": "./dist/inbox/Inbox.mjs"
+    "./WebSocketSession": {
+      "types": "./dist/streaming/WebSocketSession.d.mts",
+      "import": "./dist/streaming/WebSocketSession.mjs"
+    },
+    "./Settle": {
+      "types": "./dist/streaming/Settle.d.mts",
+      "import": "./dist/streaming/Settle.mjs"
     },
     "./Loop": {
       "types": "./dist/loop/Loop.d.mts",
@@ -190,6 +210,10 @@
       "types": "./dist/retry/Retry.d.mts",
       "import": "./dist/retry/Retry.mjs"
     },
+    "./Probability": {
+      "types": "./dist/math/Probability.d.mts",
+      "import": "./dist/math/Probability.mjs"
+    },
     "./Vector": {
       "types": "./dist/math/Vector.d.mts",
       "import": "./dist/math/Vector.mjs"
@@ -270,6 +294,14 @@
       "types": "./dist/testing/MockSandbox.d.mts",
       "import": "./dist/testing/MockSandbox.mjs"
     },
+    "./testing/FakeWebSocket": {
+      "types": "./dist/testing/FakeWebSocket.d.mts",
+      "import": "./dist/testing/FakeWebSocket.mjs"
+    },
+    "./testing/MockRealtimeSession": {
+      "types": "./dist/testing/MockRealtimeSession.d.mts",
+      "import": "./dist/testing/MockRealtimeSession.mjs"
+    },
     "./testing/MockTranscriber": {
       "types": "./dist/testing/MockTranscriber.d.mts",
       "import": "./dist/testing/MockTranscriber.mjs"