feat: support transport negotiation between client and server

Author: NathanFlurry

packages/actor-core/src/client/client.ts

@@ -19,7 +19,7 @@ import { importEventSource } from "@/common/eventsource";
  */
 export interface ClientOptions {
 	encoding?: Encoding;
-	transport?: Transport;
+	supportedTransports?: Transport[];
 }
 
 /**
@@ -135,7 +135,7 @@ export class Client {
 	#managerEndpointPromise: Promise<string>;
 	//#regionPromise: Promise<Region | undefined>;
 	#encodingKind: Encoding;
-	#transportKind: Transport;
+	#supportedTransports: Transport[];
 
 	// External imports
 	#dynamicImportsPromise: Promise<DynamicImports>;
@@ -164,7 +164,7 @@ export class Client {
 		//this.#regionPromise = this.#fetchRegion();
 
 		this.#encodingKind = opts?.encoding ?? "cbor";
-		this.#transportKind = opts?.transport ?? "websocket";
+		this.#supportedTransports = opts?.supportedTransports ?? ["websocket", "sse"];
 
 		// Import dynamic dependencies
 		this.#dynamicImportsPromise = (async () => {
@@ -198,10 +198,14 @@ export class Client {
 				getForId: {
 					actorId,
 				},
-			},
+			}
 		});
 
-		const handle = await this.#createHandle(resJson.endpoint, opts?.parameters);
+		const handle = await this.#createHandle(
+			resJson.endpoint,
+			opts?.parameters,
+			resJson.supportedTransports
+		);
 		return this.#createProxy(handle) as ActorHandle<A>;
 	}
 
@@ -259,10 +263,14 @@ export class Client {
 					tags,
 					create,
 				},
-			},
+			}
 		});
 
-		const handle = await this.#createHandle(resJson.endpoint, opts?.parameters);
+		const handle = await this.#createHandle(
+			resJson.endpoint,
+			opts?.parameters,
+			resJson.supportedTransports
+		);
 		return this.#createProxy(handle) as ActorHandle<A>;
 	}
 
@@ -307,24 +315,30 @@ export class Client {
 		>("POST", "/manager/actors", {
 			query: {
 				create,
-			},
+			}
 		});
 
-		const handle = await this.#createHandle(resJson.endpoint, opts?.parameters);
+		const handle = await this.#createHandle(
+			resJson.endpoint,
+			opts?.parameters,
+			resJson.supportedTransports
+		);
 		return this.#createProxy(handle) as ActorHandle<A>;
 	}
 
 	async #createHandle(
 		endpoint: string,
 		parameters: unknown,
+		serverTransports: Transport[],
 	): Promise<ActorHandleRaw> {
 		const imports = await this.#dynamicImportsPromise;
 
 		const handle = new ActorHandleRaw(
 			endpoint,
 			parameters,
 			this.#encodingKind,
-			this.#transportKind,
+			this.#supportedTransports,
+			serverTransports,
 			imports,
 		);
 		handle.__connect();

packages/actor-core/src/client/errors.ts

@@ -24,6 +24,12 @@ export class MalformedResponseMessage extends ActorClientError {
 	}
 }
 
+export class NoSupportedTransport extends ActorClientError {
+	constructor() {
+		super("No supported transport available between client and server");
+	}
+}
+
 export class RpcError extends ActorClientError {
 	constructor(
 		public readonly code: string,

packages/actor-core/src/client/handle.ts

@@ -93,7 +93,8 @@ export class ActorHandleRaw {
 		private readonly endpoint: string,
 		private readonly parameters: unknown,
 		private readonly encodingKind: Encoding,
-		private readonly transportKind: Transport,
+		private readonly supportedTransports: Transport[],
+		private readonly serverTransports: Transport[],
 		private readonly dynamicImports: DynamicImports,
 	) {
 		this.#keepNodeAliveInterval = setInterval(() => 60_000);
@@ -205,12 +206,13 @@ enc
 			this.#onOpenPromise = Promise.withResolvers();
 
 			// Connect transport
-			if (this.transportKind === "websocket") {
+			const transport = this.#pickTransport();
+			if (transport === "websocket") {
 				this.#connectWebSocket();
-			} else if (this.transportKind === "sse") {
+			} else if (transport === "sse") {
 				this.#connectSse();
 			} else {
-				assertUnreachable(this.transportKind);
+				assertUnreachable(transport);
 			}
 
 			// Wait for result
@@ -220,10 +222,23 @@ enc
 		}
 	}
 
+	#pickTransport(): Transport {
+		// Choose first supported transport from server's list that client also supports
+		const transport = this.serverTransports.find(t => 
+			this.supportedTransports.includes(t)
+		);
+		
+		if (!transport) {
+			throw new errors.NoSupportedTransport();
+		}
+
+		return transport;
+	}
+
 	#connectWebSocket() {
 		const { WebSocket } = this.dynamicImports;
 
-		const url = this.#buildConnectionUrl();
+		const url = this.#buildConnectionUrl("websocket");
 
 		const ws = new WebSocket(url);
 		if (this.encodingKind === "cbor") {
@@ -255,7 +270,7 @@ enc
 	#connectSse() {
 		const { EventSource } = this.dynamicImports;
 
-		const url = this.#buildConnectionUrl();
+		const url = this.#buildConnectionUrl("sse");
 
 		const eventSource = new EventSource(url);
 		this.#transport = { sse: eventSource };
@@ -391,8 +406,8 @@ enc
 		logger().warn("socket error", { event });
 	}
 
-	#buildConnectionUrl(): string {
-		let url = `${this.endpoint}/connect/${this.transportKind}?encoding=${this.encodingKind}`;
+	#buildConnectionUrl(transport: Transport): string {
+		let url = `${this.endpoint}/connect/${transport}?encoding=${this.encodingKind}`;
 
 		if (this.parameters !== undefined) {
 			const paramsStr = JSON.stringify(this.parameters);
@@ -593,7 +608,10 @@ enc
 			}
 			return JSON.parse(data);
 		} else if (this.encodingKind === "cbor") {
-			if (this.transportKind === "sse") {
+			if (!this.#transport) {
+				// Do thing
+				throw new Error("Cannot parse message when no transport defined");
+			} else if ("sse" in this.#transport) {
 				// Decode base64 since SSE sends raw strings
 				if (typeof data === "string") {
 					const binaryString = atob(data);
@@ -605,10 +623,10 @@ enc
 						`Expected data to be a string for SSE, got ${data}.`,
 					);
 				}
-			} else if (this.transportKind === "websocket") {
+			} else if ("websocket" in this.#transport) {
 				// Do nothing
 			} else {
-				assertUnreachable(this.transportKind);
+				assertUnreachable(this.#transport);
 			}
 
 			// Decode data

packages/actor-core/src/manager/protocol/mod.ts

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import { ActorQuerySchema } from "./query";
+import { TransportSchema } from "@/actor/protocol/message/mod";
 export * from "./query";
 
 export const ActorsRequestSchema = z.object({
@@ -8,6 +9,7 @@ export const ActorsRequestSchema = z.object({
 
 export const ActorsResponseSchema = z.object({
 	endpoint: z.string(),
+	supportedTransports: z.array(TransportSchema),
 });
 
 //export const RivetConfigResponseSchema = z.object({