rivetkit 2.0.6 → 2.0.7-rc.1

package/src/client/actor-conn.ts

@@ -32,7 +32,12 @@ import {
 	encodingIsBinary,
 	serializeWithEncoding,
 } from "@/serde";
-import { bufferToArrayBuffer, getEnvUniversal, httpUserAgent } from "@/utils";
+import {
+	bufferToArrayBuffer,
+	getEnvUniversal,
+	httpUserAgent,
+	promiseWithResolvers,
+} from "@/utils";
 import type { ActorDefinitionActions } from "./actor-common";
 import { queryActor } from "./actor-query";
 import { ACTOR_CONNS_SYMBOL, type ClientRaw, TRANSPORT_SYMBOL } from "./client";
@@ -94,7 +99,7 @@ export class ActorConnRaw {
 	/** If attempting to connect. Helpful for knowing if in a retry loop when reconnecting. */
 	#connecting = false;
 
-	// These will only be set on SSE driver
+	// Connection info, used for reconnection and HTTP requests
 	#actorId?: string;
 	#connectionId?: string;
 	#connectionToken?: string;
@@ -119,7 +124,7 @@ export class ActorConnRaw {
 	#keepNodeAliveInterval: NodeJS.Timeout;
 
 	/** Promise used to indicate the socket has connected successfully. This will be rejected if the connection fails. */
-	#onOpenPromise?: PromiseWithResolvers<undefined>;
+	#onOpenPromise?: ReturnType<typeof promiseWithResolvers<undefined>>;
 
 	#client: ClientRaw;
 	#driver: ManagerDriver;
@@ -177,7 +182,7 @@ export class ActorConnRaw {
 		this.#actionIdCounter += 1;
 
 		const { promise, resolve, reject } =
-			Promise.withResolvers<protocol.ActionResponse>();
+			promiseWithResolvers<protocol.ActionResponse>();
 		this.#actionsInFlight.set(actionId, { name: opts.name, resolve, reject });
 
 		this.#sendMessage({
@@ -253,7 +258,7 @@ enc
 			// Create promise for open
 			if (this.#onOpenPromise)
 				throw new Error("#onOpenPromise already defined");
-			this.#onOpenPromise = Promise.withResolvers();
+			this.#onOpenPromise = promiseWithResolvers();
 
 			// Connect transport
 			if (this.#client[TRANSPORT_SYMBOL] === "websocket") {
@@ -277,15 +282,37 @@ enc
 			this.#actorQuery,
 			this.#driver,
 		);
+
+		// Check if we have connection info for reconnection
+		const isReconnection = this.#connectionId && this.#connectionToken;
+		if (isReconnection) {
+			logger().debug({
+				msg: "attempting websocket reconnection",
+				connectionId: this.#connectionId,
+			});
+		}
+
 		const ws = await this.#driver.openWebSocket(
 			PATH_CONNECT_WEBSOCKET,
 			actorId,
 			this.#encoding,
 			this.#params,
+			// Pass connection ID and token for reconnection if available
+			isReconnection ? this.#connectionId : undefined,
+			isReconnection ? this.#connectionToken : undefined,
 		);
+		logger().debug({
+			msg: "transport set to new websocket",
+			connectionId: this.#connectionId,
+			readyState: ws.readyState,
+			messageQueueLength: this.#messageQueue.length,
+		});
 		this.#transport = { websocket: ws };
 		ws.addEventListener("open", () => {
-			logger().debug({ msg: "websocket open" });
+			logger().debug({
+				msg: "client websocket open",
+				connectionId: this.#connectionId,
+			});
 		});
 		ws.addEventListener("message", async (ev) => {
 			this.#handleOnMessage(ev.data);
@@ -316,6 +343,8 @@ enc
 			encoding: this.#encoding,
 		});
 
+		const isReconnection = this.#connectionId && this.#connectionToken;
+
 		const eventSource = new EventSource("http://actor/connect/sse", {
 			fetch: (input, init) => {
 				return this.#driver.sendRequest(
@@ -329,6 +358,12 @@ enc
 							...(this.#params !== undefined
 								? { [HEADER_CONN_PARAMS]: JSON.stringify(this.#params) }
 								: {}),
+							...(isReconnection
+								? {
+										[HEADER_CONN_ID]: this.#connectionId,
+										[HEADER_CONN_TOKEN]: this.#connectionToken,
+									}
+								: {}),
 						},
 					}),
 				);
@@ -338,6 +373,9 @@ enc
 		this.#transport = { sse: eventSource };
 
 		eventSource.addEventListener("message", (ev: UniversalMessageEvent) => {
+			// Ignore pings
+			if (ev.type === "ping") return;
+
 			this.#handleOnMessage(ev.data);
 		});
 
@@ -351,6 +389,7 @@ enc
 		logger().debug({
 			msg: "socket open",
 			messageQueueLength: this.#messageQueue.length,
+			connectionId: this.#connectionId,
 		});
 
 		// Resolve open promise
@@ -370,6 +409,10 @@ enc
 		// If the message fails to send, the message will be re-queued
 		const queue = this.#messageQueue;
 		this.#messageQueue = [];
+		logger().debug({
+			msg: "flushing message queue",
+			queueLength: queue.length,
+		});
 		for (const msg of queue) {
 			this.#sendMessage(msg);
 		}
@@ -395,7 +438,7 @@ enc
 		);
 
 		if (response.body.tag === "Init") {
-			// This is only called for SSE
+			// Store connection info for reconnection
 			this.#actorId = response.body.val.actorId;
 			this.#connectionId = response.body.val.connectionId;
 			this.#connectionToken = response.body.val.connectionToken;
@@ -491,26 +534,46 @@ enc
 		//
 		// These properties will be undefined
 		const closeEvent = event as CloseEvent;
-		if (closeEvent.wasClean) {
-			logger().info({
-				msg: "socket closed",
-				code: closeEvent.code,
-				reason: closeEvent.reason,
-				wasClean: closeEvent.wasClean,
-			});
-		} else {
-			logger().warn({
-				msg: "socket closed",
-				code: closeEvent.code,
-				reason: closeEvent.reason,
-				wasClean: closeEvent.wasClean,
+		const wasClean = closeEvent.wasClean;
+
+		logger().info({
+			msg: "socket closed",
+			code: closeEvent.code,
+			reason: closeEvent.reason,
+			wasClean: wasClean,
+			connectionId: this.#connectionId,
+			messageQueueLength: this.#messageQueue.length,
+			actionsInFlight: this.#actionsInFlight.size,
+		});
+
+		// Reject all in-flight actions
+		if (this.#actionsInFlight.size > 0) {
+			logger().debug({
+				msg: "rejecting in-flight actions after disconnect",
+				count: this.#actionsInFlight.size,
+				connectionId: this.#connectionId,
+				wasClean,
 			});
+
+			const disconnectError = new Error(
+				wasClean ? "Connection closed" : "Connection lost",
+			);
+
+			for (const actionInfo of this.#actionsInFlight.values()) {
+				actionInfo.reject(disconnectError);
+			}
+			this.#actionsInFlight.clear();
 		}
 
 		this.#transport = undefined;
 
 		// Automatically reconnect. Skip if already attempting to connect.
 		if (!this.#disposed && !this.#connecting) {
+			logger().debug({
+				msg: "triggering reconnect",
+				connectionId: this.#connectionId,
+				messageQueueLength: this.#messageQueue.length,
+			});
 			// TODO: Fetch actor to check if it's destroyed
 			// TODO: Add backoff for reconnect
 			// TODO: Add a way of preserving connection ID for connection state
@@ -660,9 +723,26 @@ enc
 		let queueMessage = false;
 		if (!this.#transport) {
 			// No transport connected yet
+			logger().debug({ msg: "no transport, queueing message" });
 			queueMessage = true;
 		} else if ("websocket" in this.#transport) {
-			if (this.#transport.websocket.readyState === 1) {
+			const readyState = this.#transport.websocket.readyState;
+			logger().debug({
+				msg: "websocket send attempt",
+				readyState,
+				readyStateString:
+					readyState === 0
+						? "CONNECTING"
+						: readyState === 1
+							? "OPEN"
+							: readyState === 2
+								? "CLOSING"
+								: "CLOSED",
+				connectionId: this.#connectionId,
+				messageType: (message.body as any).tag,
+				actionName: (message.body as any).val?.name,
+			});
+			if (readyState === 1) {
 				try {
 					const messageSerialized = serializeWithEncoding(
 						this.#encoding,
@@ -678,12 +758,17 @@ enc
 					logger().warn({
 						msg: "failed to send message, added to queue",
 						error,
+						connectionId: this.#connectionId,
 					});
 
 					// Assuming the socket is disconnected and will be reconnected soon
 					queueMessage = true;
 				}
 			} else {
+				logger().debug({
+					msg: "websocket not open, queueing message",
+					readyState,
+				});
 				queueMessage = true;
 			}
 		} else if ("sse" in this.#transport) {
@@ -699,7 +784,13 @@ enc
 
 		if (!opts?.ephemeral && queueMessage) {
 			this.#messageQueue.push(message);
-			logger().debug({ msg: "queued connection message" });
+			logger().debug({
+				msg: "queued connection message",
+				queueLength: this.#messageQueue.length,
+				connectionId: this.#connectionId,
+				messageType: (message.body as any).tag,
+				actionName: (message.body as any).val?.name,
+			});
 		}
 	}
 
@@ -778,6 +869,22 @@ enc
 		return deserializeWithEncoding(this.#encoding, buffer, TO_CLIENT_VERSIONED);
 	}
 
+	/**
+	 * Get the actor ID (for testing purposes).
+	 * @internal
+	 */
+	get actorId(): string | undefined {
+		return this.#actorId;
+	}
+
+	/**
+	 * Get the connection ID (for testing purposes).
+	 * @internal
+	 */
+	get connectionId(): string | undefined {
+		return this.#connectionId;
+	}
+
 	/**
 	 * Disconnects from the actor.
 	 *
@@ -815,7 +922,7 @@ enc
 			) {
 				logger().debug({ msg: "ws already closed or closing" });
 			} else {
-				const { promise, resolve } = Promise.withResolvers();
+				const { promise, resolve } = promiseWithResolvers();
 				ws.addEventListener("close", () => {
 					logger().debug({ msg: "ws closed" });
 					resolve(undefined);
@@ -824,6 +931,30 @@ enc
 				await promise;
 			}
 		} else if ("sse" in this.#transport) {
+			// Send close request to server for SSE connections
+			if (this.#connectionId && this.#connectionToken) {
+				try {
+					await sendHttpRequest({
+						url: "http://actor/connections/close",
+						method: "POST",
+						headers: {
+							[HEADER_CONN_ID]: this.#connectionId,
+							[HEADER_CONN_TOKEN]: this.#connectionToken,
+						},
+						encoding: this.#encoding,
+						skipParseResponse: true,
+						customFetch: this.#driver.sendRequest.bind(
+							this.#driver,
+							this.#actorId!,
+						),
+						requestVersionedDataHandler: TO_SERVER_VERSIONED,
+						responseVersionedDataHandler: TO_CLIENT_VERSIONED,
+					});
+				} catch (error) {
+					// Ignore errors when closing - connection may already be closed
+					logger().warn({ msg: "failed to send close request", error });
+				}
+			}
 			this.#transport.sse.close();
 		} else {
 			assertUnreachable(this.#transport);

package/src/client/client.ts

@@ -491,7 +491,7 @@ function createActorProxy<AD extends AnyActorDefinition>(
 
 			// Handle built-in Promise methods and existing properties
 			if (prop === "constructor" || prop in target) {
-				const value = Reflect.get(target, prop, receiver);
+				const value = Reflect.get(target, prop, target);
 				// Preserve method binding
 				if (typeof value === "function") {
 					return value.bind(target);

package/src/client/config.ts

@@ -14,6 +14,13 @@ export const ClientConfigSchema = z.object({
 		})
 		.default({}),
 
+	token: z
+		.string()
+		.optional()
+		.transform((x) => x ?? getEnvUniversal("RIVET_TOKEN")),
+
+	headers: z.record(z.string()).optional().default({}),
+
 	/** Endpoint to connect to the Rivet engine. Can be configured via RIVET_ENGINE env var. */
 	endpoint: z
 		.string()

package/src/common/actor-router-consts.ts

@@ -5,21 +5,39 @@ export const PATH_CONNECT_WEBSOCKET = "/connect/websocket";
 export const PATH_RAW_WEBSOCKET_PREFIX = "/raw/websocket/";
 
 // MARK: Headers
-export const HEADER_ACTOR_QUERY = "X-RivetKit-Query";
+export const HEADER_ACTOR_QUERY = "x-rivet-query";
 
-export const HEADER_ENCODING = "X-RivetKit-Encoding";
+export const HEADER_ENCODING = "x-rivet-encoding";
 
 // IMPORTANT: Params must be in headers or in an E2EE part of the request (i.e. NOT the URL or query string) in order to ensure that tokens can be securely passed in params.
-export const HEADER_CONN_PARAMS = "X-RivetKit-Conn-Params";
+export const HEADER_CONN_PARAMS = "x-rivet-conn-params";
 
-// Internal header
-export const HEADER_AUTH_DATA = "X-RivetKit-Auth-Data";
+export const HEADER_ACTOR_ID = "x-rivet-actor";
 
-export const HEADER_ACTOR_ID = "X-RivetKit-Actor";
+export const HEADER_CONN_ID = "x-rivet-conn";
 
-export const HEADER_CONN_ID = "X-RivetKit-Conn";
+export const HEADER_CONN_TOKEN = "x-rivet-conn-token";
 
-export const HEADER_CONN_TOKEN = "X-RivetKit-Conn-Token";
+export const HEADER_RIVET_TOKEN = "x-rivet-token";
+
+// MARK: Manager Gateway Headers
+export const HEADER_RIVET_TARGET = "x-rivet-target";
+export const HEADER_RIVET_ACTOR = "x-rivet-actor";
+
+// MARK: WebSocket Protocol Prefixes
+/** Some servers (such as node-ws & Cloudflare) require explicitly match a certain WebSocket protocol. This gives us a static protocol to match against. */
+export const WS_PROTOCOL_STANDARD = "rivet";
+export const WS_PROTOCOL_TARGET = "rivet_target.";
+export const WS_PROTOCOL_ACTOR = "rivet_actor.";
+export const WS_PROTOCOL_ENCODING = "rivet_encoding.";
+export const WS_PROTOCOL_CONN_PARAMS = "rivet_conn_params.";
+export const WS_PROTOCOL_CONN_ID = "rivet_conn.";
+export const WS_PROTOCOL_CONN_TOKEN = "rivet_conn_token.";
+export const WS_PROTOCOL_TOKEN = "rivet_token.";
+
+// MARK: WebSocket Inline Test Protocol Prefixes
+export const WS_PROTOCOL_TRANSPORT = "test_transport.";
+export const WS_PROTOCOL_PATH = "test_path.";
 
 /**
  * Headers that publics can send from public clients.
@@ -35,4 +53,7 @@ export const ALLOWED_PUBLIC_HEADERS = [
 	HEADER_ACTOR_ID,
 	HEADER_CONN_ID,
 	HEADER_CONN_TOKEN,
+	HEADER_RIVET_TARGET,
+	HEADER_RIVET_ACTOR,
+	HEADER_RIVET_TOKEN,
 ];

package/src/common/router.ts

@@ -76,5 +76,6 @@ export function handleRouteError(error: unknown, c: HonoContext) {
 		HTTP_RESPONSE_ERROR_VERSIONED,
 	);
 
-	return c.body(output, { status: statusCode });
+	// TODO: Remove any
+	return c.body(output as any, { status: statusCode });
 }

package/src/common/versioned-data.ts

@@ -63,8 +63,8 @@ export class VersionedDataHandler<T> {
 	}
 
 	private embedVersion(data: VersionedData<Uint8Array>): Uint8Array {
-		const versionBytes = new Uint8Array(4);
-		new DataView(versionBytes.buffer).setUint32(0, data.version, true);
+		const versionBytes = new Uint8Array(2);
+		new DataView(versionBytes.buffer).setUint16(0, data.version, true);
 
 		const result = new Uint8Array(versionBytes.length + data.data.length);
 		result.set(versionBytes);
@@ -74,15 +74,15 @@ export class VersionedDataHandler<T> {
 	}
 
 	private extractVersion(bytes: Uint8Array): VersionedData<Uint8Array> {
-		if (bytes.length < 4) {
+		if (bytes.length < 2) {
 			throw new Error("Invalid versioned data: too short");
 		}
 
-		const version = new DataView(bytes.buffer, bytes.byteOffset).getUint32(
+		const version = new DataView(bytes.buffer, bytes.byteOffset).getUint16(
 			0,
 			true,
 		);
-		const data = bytes.slice(4);
+		const data = bytes.slice(2);
 
 		return { version, data };
 	}

package/src/driver-helpers/mod.ts

@@ -1,13 +1,26 @@
 export type { ActorDriver } from "@/actor/driver";
 export type { ActorInstance, AnyActorInstance } from "@/actor/instance";
 export {
+	ALLOWED_PUBLIC_HEADERS,
 	HEADER_ACTOR_ID,
 	HEADER_ACTOR_QUERY,
-	HEADER_AUTH_DATA,
 	HEADER_CONN_ID,
 	HEADER_CONN_PARAMS,
 	HEADER_CONN_TOKEN,
 	HEADER_ENCODING,
+	HEADER_RIVET_ACTOR,
+	HEADER_RIVET_TARGET,
+	PATH_CONNECT_WEBSOCKET,
+	PATH_RAW_WEBSOCKET_PREFIX,
+	WS_PROTOCOL_ACTOR,
+	WS_PROTOCOL_CONN_ID,
+	WS_PROTOCOL_CONN_PARAMS,
+	WS_PROTOCOL_CONN_TOKEN,
+	WS_PROTOCOL_ENCODING,
+	WS_PROTOCOL_PATH,
+	WS_PROTOCOL_STANDARD,
+	WS_PROTOCOL_TARGET,
+	WS_PROTOCOL_TRANSPORT,
 } from "@/common/actor-router-consts";
 export type {
 	ActorOutput,

package/src/driver-test-suite/mod.ts

@@ -4,6 +4,7 @@ import { bundleRequire } from "bundle-require";
 import invariant from "invariant";
 import { describe } from "vitest";
 import type { Transport } from "@/client/mod";
+import { configureInspectorAccessToken } from "@/inspector/utils";
 import { createManagerRouter } from "@/manager/router";
 import type { DriverConfig, Registry, RunConfig } from "@/mod";
 import { RunConfigSchema } from "@/registry/run-config";
@@ -22,6 +23,7 @@ import { runActorInlineClientTests } from "./tests/actor-inline-client";
 import { runActorInspectorTests } from "./tests/actor-inspector";
 import { runActorMetadataTests } from "./tests/actor-metadata";
 import { runActorOnStateChangeTests } from "./tests/actor-onstatechange";
+import { runActorReconnectTests } from "./tests/actor-reconnect";
 import { runActorVarsTests } from "./tests/actor-vars";
 import { runManagerDriverTests } from "./tests/manager-driver";
 import { runRawHttpTests } from "./tests/raw-http";
@@ -32,6 +34,7 @@ import { runRequestAccessTests } from "./tests/request-access";
 export interface SkipTests {
 	schedule?: boolean;
 	sleep?: boolean;
+	sse?: boolean;
 }
 
 export interface DriverTestConfig {
@@ -86,7 +89,10 @@ export function runDriverTests(
 			runActorDriverTests(driverTestConfig);
 			runManagerDriverTests(driverTestConfig);
 
-			for (const transport of ["websocket", "sse"] as Transport[]) {
+			const transports: Transport[] = driverTestConfig.skip?.sse
+				? ["websocket"]
+				: ["websocket", "sse"];
+			for (const transport of transports) {
 				describe(`transport (${transport})`, () => {
 					runActorConnTests({
 						...driverTestConfig,
@@ -95,6 +101,8 @@ export function runDriverTests(
 
 					runActorConnStateTests({ ...driverTestConfig, transport });
 
+					runActorReconnectTests({ ...driverTestConfig, transport });
+
 					runRequestAccessTests({ ...driverTestConfig, transport });
 
 					runActorDriverTestsWithTransport({ ...driverTestConfig, transport });
@@ -193,11 +201,12 @@ export async function createTestRuntime(
 
 		// Create router
 		const managerDriver = driver.manager(registry.config, config);
+		configureInspectorAccessToken(config, managerDriver);
 		const { router } = createManagerRouter(
 			registry.config,
 			config,
 			managerDriver,
-			false,
+			undefined,
 		);
 
 		// Inject WebSocket

package/src/driver-test-suite/test-inline-client-driver.ts

@@ -10,6 +10,12 @@ import {
 	HEADER_ACTOR_QUERY,
 	HEADER_CONN_PARAMS,
 	HEADER_ENCODING,
+	WS_PROTOCOL_ACTOR,
+	WS_PROTOCOL_CONN_PARAMS,
+	WS_PROTOCOL_ENCODING,
+	WS_PROTOCOL_PATH,
+	WS_PROTOCOL_TARGET,
+	WS_PROTOCOL_TRANSPORT,
 } from "@/common/actor-router-consts";
 import type { UniversalEventSource } from "@/common/eventsource-interface";
 import type { DeconstructedError } from "@/common/utils";
@@ -111,7 +117,8 @@ export function createTestInlineClientDriver(
 					headers,
 					body: actorRequest.body,
 					signal: actorRequest.signal,
-				}),
+					duplex: "half",
+				} as RequestInit),
 			);
 
 			// Check if it's an error response from our handler
@@ -153,39 +160,48 @@ export function createTestInlineClientDriver(
 			actorId: string,
 			encoding: Encoding,
 			params: unknown,
+			connId?: string,
+			connToken?: string,
 		): Promise<UniversalWebSocket> {
 			const WebSocket = await importWebSocket();
 
 			// Normalize path to match other drivers
 			const normalizedPath = path.startsWith("/") ? path.slice(1) : path;
 
-			logger().debug({
-				msg: "creating websocket connection via test inline driver",
-			});
-
 			// Create WebSocket connection to the test endpoint
-			// Use a placeholder path and pass the actual path as a query param to avoid mixing user query params with internal ones
 			const wsUrl = new URL(
 				`${endpoint}/.test/inline-driver/connect-websocket/ws`,
 			);
-			wsUrl.searchParams.set("path", normalizedPath);
-			wsUrl.searchParams.set("actorId", actorId);
-			if (params !== undefined)
-				wsUrl.searchParams.set("params", JSON.stringify(params));
-			wsUrl.searchParams.set("encodingKind", encoding);
+
+			logger().debug({
+				msg: "creating websocket connection via test inline driver",
+				url: wsUrl.toString(),
+			});
 
 			// Convert http/https to ws/wss
 			const wsProtocol = wsUrl.protocol === "https:" ? "wss:" : "ws:";
-			const finalWsUrl = `${wsProtocol}//${wsUrl.host}${wsUrl.pathname}${wsUrl.search}`;
+			const finalWsUrl = `${wsProtocol}//${wsUrl.host}${wsUrl.pathname}`;
 
 			logger().debug({ msg: "connecting to websocket", url: finalWsUrl });
 
+			// Build protocols for the connection
+			const protocols: string[] = [];
+			protocols.push(`${WS_PROTOCOL_TARGET}actor`);
+			protocols.push(`${WS_PROTOCOL_ACTOR}${actorId}`);
+			protocols.push(`${WS_PROTOCOL_ENCODING}${encoding}`);
+			protocols.push(`${WS_PROTOCOL_TRANSPORT}${transport}`);
+			protocols.push(
+				`${WS_PROTOCOL_PATH}${encodeURIComponent(normalizedPath)}`,
+			);
+			if (params !== undefined) {
+				protocols.push(
+					`${WS_PROTOCOL_CONN_PARAMS}${encodeURIComponent(JSON.stringify(params))}`,
+				);
+			}
+
 			// Create and return the WebSocket
 			// Node & browser WebSocket types are incompatible
-			const ws = new WebSocket(finalWsUrl, [
-				// HACK: See packages/drivers/cloudflare-workers/src/websocket.ts
-				"rivetkit",
-			]) as any;
+			const ws = new WebSocket(finalWsUrl, protocols) as any;
 
 			return ws;
 		},
@@ -202,7 +218,6 @@ export function createTestInlineClientDriver(
 			_actorId: string,
 			_encoding: Encoding,
 			_params: unknown,
-			_authData: unknown,
 		): Promise<Response> {
 			throw "UNIMPLEMENTED";
 			// const upgradeWebSocket = this.#runConfig.getUpgradeWebSocket?.();
@@ -214,6 +229,8 @@ export function createTestInlineClientDriver(
 		displayInformation(): ManagerDisplayInformation {
 			return { name: "Test Inline", properties: {} };
 		},
+		// TODO:
+		getOrCreateInspectorAccessToken: () => "",
 
 		// action: async <Args extends Array<unknown> = unknown[], Response = unknown>(
 		// 	_c: HonoContext | undefined,
@@ -560,7 +577,8 @@ async function makeInlineRequest<T>(
 			method,
 			args,
 		} satisfies TestInlineDriverCallRequest),
-	});
+		duplex: "half",
+	} as RequestInit);
 
 	if (!response.ok) {
 		throw new Error(`Failed to call inline ${method}: ${response.statusText}`);