rivetkit 2.0.20 → 2.0.22-rc.1

package/src/actor/router.ts

@@ -71,7 +71,9 @@ export function createActorRouter(
 	actorDriver: ActorDriver,
 	isTest: boolean,
 ): ActorRouter {
-	const router = new Hono<{ Bindings: ActorRouterBindings }>({ strict: false });
+	const router = new Hono<{ Bindings: ActorRouterBindings }>({
+		strict: false,
+	});
 
 	router.use("*", loggerMiddleware(loggerWithoutContext()));
 
@@ -131,18 +133,32 @@ export function createActorRouter(
 				let connTokenRaw: string | undefined;
 
 				if (protocols) {
-					const protocolList = protocols.split(",").map((p) => p.trim());
+					const protocolList = protocols
+						.split(",")
+						.map((p) => p.trim());
 					for (const protocol of protocolList) {
 						if (protocol.startsWith(WS_PROTOCOL_ENCODING)) {
-							encodingRaw = protocol.substring(WS_PROTOCOL_ENCODING.length);
-						} else if (protocol.startsWith(WS_PROTOCOL_CONN_PARAMS)) {
+							encodingRaw = protocol.substring(
+								WS_PROTOCOL_ENCODING.length,
+							);
+						} else if (
+							protocol.startsWith(WS_PROTOCOL_CONN_PARAMS)
+						) {
 							connParamsRaw = decodeURIComponent(
-								protocol.substring(WS_PROTOCOL_CONN_PARAMS.length),
+								protocol.substring(
+									WS_PROTOCOL_CONN_PARAMS.length,
+								),
 							);
 						} else if (protocol.startsWith(WS_PROTOCOL_CONN_ID)) {
-							connIdRaw = protocol.substring(WS_PROTOCOL_CONN_ID.length);
-						} else if (protocol.startsWith(WS_PROTOCOL_CONN_TOKEN)) {
-							connTokenRaw = protocol.substring(WS_PROTOCOL_CONN_TOKEN.length);
+							connIdRaw = protocol.substring(
+								WS_PROTOCOL_CONN_ID.length,
+							);
+						} else if (
+							protocol.startsWith(WS_PROTOCOL_CONN_TOKEN)
+						) {
+							connTokenRaw = protocol.substring(
+								WS_PROTOCOL_CONN_TOKEN.length,
+							);
 						}
 					}
 				}
@@ -178,7 +194,13 @@ export function createActorRouter(
 	router.post("/action/:action", async (c) => {
 		const actionName = c.req.param("action");
 
-		return handleAction(c, runConfig, actorDriver, actionName, c.env.actorId);
+		return handleAction(
+			c,
+			runConfig,
+			actorDriver,
+			actionName,
+			c.env.actorId,
+		);
 	});
 
 	router.post("/connections/message", async (c) => {
@@ -282,14 +304,20 @@ export function createActorRouter(
 	if (isInspectorEnabled(runConfig, "actor")) {
 		router.route(
 			"/inspect",
-			new Hono<ActorInspectorRouterEnv & { Bindings: ActorRouterBindings }>()
+			new Hono<
+				ActorInspectorRouterEnv & { Bindings: ActorRouterBindings }
+			>()
 				.use(
 					cors(runConfig.inspector.cors),
 					secureInspector(runConfig),
 					async (c, next) => {
-						const inspector = (await actorDriver.loadActor(c.env.actorId))
-							.inspector;
-						invariant(inspector, "inspector not supported on this platform");
+						const inspector = (
+							await actorDriver.loadActor(c.env.actorId)
+						).inspector;
+						invariant(
+							inspector,
+							"inspector not supported on this platform",
+						);
 
 						c.set("inspector", inspector);
 						return next();

package/src/actor/unstable-react.ts

@@ -1,4 +1,4 @@
-//// @ts-ignore we do not have types for this lib
+//// @ts-expect-error we do not have types for this lib
 //import { renderToPipeableStream } from "@jogit/tmp-react-server-dom-nodeless";
 //import getStream from "get-stream";
 //import { isValidElement } from "react";

package/src/client/actor-common.ts

@@ -23,7 +23,9 @@ export type ActorDefinitionActions<AD extends AnyActorDefinition> =
 	// biome-ignore lint/suspicious/noExplicitAny: safe to use any here
 	AD extends ActorDefinition<any, any, any, any, any, any, infer R>
 		? {
-				[K in keyof R]: R[K] extends (...args: infer Args) => infer Return
+				[K in keyof R]: R[K] extends (
+					...args: infer Args
+				) => infer Return
 					? ActorActionFunction<Args, Return>
 					: never;
 			}

package/src/client/actor-conn.ts

@@ -183,7 +183,11 @@ export class ActorConnRaw {
 
 		const { promise, resolve, reject } =
 			promiseWithResolvers<protocol.ActionResponse>();
-		this.#actionsInFlight.set(actionId, { name: opts.name, resolve, reject });
+		this.#actionsInFlight.set(actionId, {
+			name: opts.name,
+			resolve,
+			reject,
+		});
 
 		this.#sendMessage({
 			body: {
@@ -377,12 +381,17 @@ enc
 							"User-Agent": httpUserAgent(),
 							[HEADER_ENCODING]: this.#encoding,
 							...(this.#params !== undefined
-								? { [HEADER_CONN_PARAMS]: JSON.stringify(this.#params) }
+								? {
+										[HEADER_CONN_PARAMS]: JSON.stringify(
+											this.#params,
+										),
+									}
 								: {}),
 							...(isReconnection
 								? {
 										[HEADER_CONN_ID]: this.#connectionId,
-										[HEADER_CONN_TOKEN]: this.#connectionToken,
+										[HEADER_CONN_TOKEN]:
+											this.#connectionToken,
 									}
 								: {}),
 						},
@@ -453,7 +462,9 @@ enc
 			getEnvUniversal("_RIVETKIT_LOG_MESSAGE")
 				? {
 						msg: "parsed message",
-						message: jsonStringifyCompat(response).substring(0, 100) + "...",
+						message:
+							jsonStringifyCompat(response).substring(0, 100) +
+							"...",
 					}
 				: { msg: "parsed message" },
 		);
@@ -471,7 +482,8 @@ enc
 			this.#handleOnOpen();
 		} else if (response.body.tag === "Error") {
 			// Connection error
-			const { group, code, message, metadata, actionId } = response.body.val;
+			const { group, code, message, metadata, actionId } =
+				response.body.val;
 
 			if (actionId) {
 				const inFlight = this.#takeActionInFlight(Number(actionId));
@@ -486,7 +498,9 @@ enc
 					metadata,
 				});
 
-				inFlight.reject(new errors.ActorError(group, code, message, metadata));
+				inFlight.reject(
+					new errors.ActorError(group, code, message, metadata),
+				);
 			} else {
 				logger().warn({
 					msg: "connection error",
@@ -534,7 +548,10 @@ enc
 			});
 			inFlight.resolve(response.body.val);
 		} else if (response.body.tag === "Event") {
-			logger().trace({ msg: "received event", name: response.body.val.name });
+			logger().trace({
+				msg: "received event",
+				name: response.body.val.name,
+			});
 			this.#dispatchEvent(response.body.val);
 		} else {
 			assertUnreachable(response.body);
@@ -821,7 +838,9 @@ enc
 	) {
 		try {
 			if (!this.#actorId || !this.#connectionId || !this.#connectionToken)
-				throw new errors.InternalError("Missing connection ID or token.");
+				throw new errors.InternalError(
+					"Missing connection ID or token.",
+				);
 
 			logger().trace(
 				getEnvUniversal("_RIVETKIT_LOG_MESSAGE")
@@ -850,14 +869,20 @@ enc
 				body: message,
 				encoding: this.#encoding,
 				skipParseResponse: true,
-				customFetch: this.#driver.sendRequest.bind(this.#driver, this.#actorId),
+				customFetch: this.#driver.sendRequest.bind(
+					this.#driver,
+					this.#actorId,
+				),
 				requestVersionedDataHandler: TO_SERVER_VERSIONED,
 				responseVersionedDataHandler: TO_CLIENT_VERSIONED,
 			});
 		} catch (error) {
 			// TODO: This will not automatically trigger a re-broadcast of HTTP events since SSE is separate from the HTTP action
 
-			logger().warn({ msg: "failed to send message, added to queue", error });
+			logger().warn({
+				msg: "failed to send message, added to queue",
+				error,
+			});
 
 			// Assuming the socket is disconnected and will be reconnected soon
 			//
@@ -887,7 +912,11 @@ enc
 
 		const buffer = await inputDataToBuffer(data);
 
-		return deserializeWithEncoding(this.#encoding, buffer, TO_CLIENT_VERSIONED);
+		return deserializeWithEncoding(
+			this.#encoding,
+			buffer,
+			TO_CLIENT_VERSIONED,
+		);
 	}
 
 	/**
@@ -977,7 +1006,10 @@ enc
 					});
 				} catch (error) {
 					// Ignore errors when closing - connection may already be closed
-					logger().warn({ msg: "failed to send close request", error });
+					logger().warn({
+						msg: "failed to send close request",
+						error,
+					});
 				}
 			}
 			this.#transport.sse.close();

package/src/client/actor-handle.ts

@@ -115,7 +115,10 @@ export class ActorHandleRaw {
 					args: bufferToArrayBuffer(cbor.encode(opts.args)),
 				} satisfies protocol.HttpActionRequest,
 				encoding: this.#encoding,
-				customFetch: this.#driver.sendRequest.bind(this.#driver, actorId),
+				customFetch: this.#driver.sendRequest.bind(
+					this.#driver,
+					actorId,
+				),
 				signal: opts?.signal,
 				requestVersionedDataHandler: HTTP_ACTION_REQUEST_VERSIONED,
 				responseVersionedDataHandler: HTTP_ACTION_RESPONSE_VERSIONED,

package/src/client/client.ts

@@ -317,7 +317,11 @@ export class ClientRaw {
 		});
 
 		// Create the actor
-		const { actorId } = await queryActor(undefined, createQuery, this.#driver);
+		const { actorId } = await queryActor(
+			undefined,
+			createQuery,
+			this.#driver,
+		);
 		logger().debug({
 			msg: "created actor with ID",
 			name,
@@ -427,17 +431,19 @@ export function createClientWithDriver<A extends Registry<any>>(
 					get: (
 						key?: string | string[],
 						opts?: GetWithIdOptions,
-					): ActorHandle<ExtractActorsFromRegistry<A>[typeof prop]> => {
-						return target.get<ExtractActorsFromRegistry<A>[typeof prop]>(
-							prop,
-							key,
-							opts,
-						);
+					): ActorHandle<
+						ExtractActorsFromRegistry<A>[typeof prop]
+					> => {
+						return target.get<
+							ExtractActorsFromRegistry<A>[typeof prop]
+						>(prop, key, opts);
 					},
 					getOrCreate: (
 						key?: string | string[],
 						opts?: GetOptions,
-					): ActorHandle<ExtractActorsFromRegistry<A>[typeof prop]> => {
+					): ActorHandle<
+						ExtractActorsFromRegistry<A>[typeof prop]
+					> => {
 						return target.getOrCreate<
 							ExtractActorsFromRegistry<A>[typeof prop]
 						>(prop, key, opts);
@@ -445,12 +451,12 @@ export function createClientWithDriver<A extends Registry<any>>(
 					getForId: (
 						actorId: string,
 						opts?: GetWithIdOptions,
-					): ActorHandle<ExtractActorsFromRegistry<A>[typeof prop]> => {
-						return target.getForId<ExtractActorsFromRegistry<A>[typeof prop]>(
-							prop,
-							actorId,
-							opts,
-						);
+					): ActorHandle<
+						ExtractActorsFromRegistry<A>[typeof prop]
+					> => {
+						return target.getForId<
+							ExtractActorsFromRegistry<A>[typeof prop]
+						>(prop, actorId, opts);
 					},
 					create: async (
 						key: string | string[],
@@ -502,7 +508,8 @@ function createActorProxy<AD extends AnyActorDefinition>(
 
 				let method = methodCache.get(prop);
 				if (!method) {
-					method = (...args: unknown[]) => target.action({ name: prop, args });
+					method = (...args: unknown[]) =>
+						target.action({ name: prop, args });
 					methodCache.set(prop, method);
 				}
 				return method;
@@ -530,8 +537,14 @@ function createActorProxy<AD extends AnyActorDefinition>(
 		},
 
 		// Support proper property descriptors
-		getOwnPropertyDescriptor(target: ActorHandleRaw, prop: string | symbol) {
-			const targetDescriptor = Reflect.getOwnPropertyDescriptor(target, prop);
+		getOwnPropertyDescriptor(
+			target: ActorHandleRaw,
+			prop: string | symbol,
+		) {
+			const targetDescriptor = Reflect.getOwnPropertyDescriptor(
+				target,
+				prop,
+			);
 			if (targetDescriptor) {
 				return targetDescriptor;
 			}
@@ -541,7 +554,8 @@ function createActorProxy<AD extends AnyActorDefinition>(
 					configurable: true,
 					enumerable: false,
 					writable: false,
-					value: (...args: unknown[]) => target.action({ name: prop, args }),
+					value: (...args: unknown[]) =>
+						target.action({ name: prop, args }),
 				};
 			}
 			return undefined;

package/src/client/utils.ts

@@ -43,7 +43,9 @@ export interface HttpRequestOpts<RequestBody, ResponseBody> {
 	signal?: AbortSignal;
 	customFetch?: (req: Request) => Promise<Response>;
 	requestVersionedDataHandler: VersionedDataHandler<RequestBody> | undefined;
-	responseVersionedDataHandler: VersionedDataHandler<ResponseBody> | undefined;
+	responseVersionedDataHandler:
+		| VersionedDataHandler<ResponseBody>
+		| undefined;
 }
 
 export async function sendHttpRequest<
@@ -113,18 +115,29 @@ export async function sendHttpRequest<
 			//});
 
 			// Error is not structured
-			const textResponse = new TextDecoder("utf-8", { fatal: false }).decode(
-				bufferResponse,
-			);
-			throw new HttpRequestError(
-				`${response.statusText} (${response.status}):\n${textResponse}`,
-			);
+			const textResponse = new TextDecoder("utf-8", {
+				fatal: false,
+			}).decode(bufferResponse);
+
+			const rayId = response.headers.get("x-rivet-ray-id");
+
+			if (rayId) {
+				throw new HttpRequestError(
+					`${response.statusText} (${response.status}) (Ray ID: ${rayId}):\n${textResponse}`,
+				);
+			} else {
+				throw new HttpRequestError(
+					`${response.statusText} (${response.status}):\n${textResponse}`,
+				);
+			}
 		}
 
 		// Decode metadata based on encoding - only binary encodings have CBOR-encoded metadata
 		let decodedMetadata: unknown;
 		if (responseData.metadata && encodingIsBinary(opts.encoding)) {
-			decodedMetadata = cbor.decode(new Uint8Array(responseData.metadata));
+			decodedMetadata = cbor.decode(
+				new Uint8Array(responseData.metadata),
+			);
 		}
 
 		// Throw structured error

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

@@ -23,6 +23,7 @@ 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";
+export const HEADER_RIVET_NAMESPACE = "x-rivet-namespace";
 
 // 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. */
@@ -55,5 +56,6 @@ export const ALLOWED_PUBLIC_HEADERS = [
 	HEADER_CONN_TOKEN,
 	HEADER_RIVET_TARGET,
 	HEADER_RIVET_ACTOR,
+	HEADER_RIVET_NAMESPACE,
 	HEADER_RIVET_TOKEN,
 ];

package/src/common/inline-websocket-adapter2.ts

@@ -119,7 +119,10 @@ export class InlineWebSocketAdapter2 implements UniversalWebSocket {
 	 * Closes the connection
 	 */
 	close(code = 1000, reason = ""): void {
-		if (this.readyState === this.CLOSED || this.readyState === this.CLOSING) {
+		if (
+			this.readyState === this.CLOSED ||
+			this.readyState === this.CLOSING
+		) {
 			return;
 		}
 
@@ -129,7 +132,10 @@ export class InlineWebSocketAdapter2 implements UniversalWebSocket {
 
 		// Call the handler's onClose method
 		try {
-			this.#handler.onClose({ code, reason, wasClean: true }, this.#wsContext);
+			this.#handler.onClose(
+				{ code, reason, wasClean: true },
+				this.#wsContext,
+			);
 		} catch (err) {
 			logger().error({ msg: "error closing websocket", error: err });
 		} finally {
@@ -323,7 +329,10 @@ export class InlineWebSocketAdapter2 implements UniversalWebSocket {
 					try {
 						this.#onopen(event);
 					} catch (error) {
-						logger().error({ msg: "error in onopen handler", error });
+						logger().error({
+							msg: "error in onopen handler",
+							error,
+						});
 					}
 				}
 				break;
@@ -332,7 +341,10 @@ export class InlineWebSocketAdapter2 implements UniversalWebSocket {
 					try {
 						this.#onclose(event);
 					} catch (error) {
-						logger().error({ msg: "error in onclose handler", error });
+						logger().error({
+							msg: "error in onclose handler",
+							error,
+						});
 					}
 				}
 				break;
@@ -341,7 +353,10 @@ export class InlineWebSocketAdapter2 implements UniversalWebSocket {
 					try {
 						this.#onerror(event);
 					} catch (error) {
-						logger().error({ msg: "error in onerror handler", error });
+						logger().error({
+							msg: "error in onerror handler",
+							error,
+						});
 					}
 				}
 				break;
@@ -350,7 +365,10 @@ export class InlineWebSocketAdapter2 implements UniversalWebSocket {
 					try {
 						this.#onmessage(event);
 					} catch (error) {
-						logger().error({ msg: "error in onmessage handler", error });
+						logger().error({
+							msg: "error in onmessage handler",
+							error,
+						});
 					}
 				}
 				break;

package/src/common/log.ts

@@ -43,7 +43,9 @@ export function getPinoLevel(logLevel?: LogLevel): LevelWithSilent {
 		return configuredLogLevel;
 	}
 
-	const raw = (getEnvUniversal("LOG_LEVEL") || "warn").toString().toLowerCase();
+	const raw = (getEnvUniversal("LOG_LEVEL") || "warn")
+		.toString()
+		.toLowerCase();
 
 	const parsed = LogLevelSchema.safeParse(raw);
 	if (parsed.success) {
@@ -157,7 +159,9 @@ export async function configureDefaultLogger(
 				};
 				const levelName = levelMap[level] || "info";
 				const time =
-					getEnvUniversal("LOG_TIMESTAMP") === "1" ? Date.now() : undefined;
+					getEnvUniversal("LOG_TIMESTAMP") === "1"
+						? Date.now()
+						: undefined;
 				// TODO: This can be simplified in logfmt.ts
 				if (inputArgs.length >= 2) {
 					const [objOrMsg, msg] = inputArgs;

package/src/common/logfmt.ts

@@ -172,7 +172,9 @@ export function errorToLogEntries(base: string, error: unknown): any {
 			...(LOGGER_CONFIG.enableErrorStack && error.stack
 				? { [`${base}.stack`]: formatStackTrace(error.stack) }
 				: {}),
-			...(error.cause ? errorToLogEntries(`${base}.cause`, error.cause) : {}),
+			...(error.cause
+				? errorToLogEntries(`${base}.cause`, error.cause)
+				: {}),
 		};
 	}
 	return { [base]: `${error}` };

package/src/common/router.ts

@@ -128,7 +128,9 @@ export function handleMetadataRequest(
 		// Do not return client endpoint if default server disabled
 		clientEndpoint:
 			runConfig.overrideServerAddress ??
-			(runConfig.disableDefaultServer ? undefined : getEndpoint(runConfig)),
+			(runConfig.disableDefaultServer
+				? undefined
+				: getEndpoint(runConfig)),
 	};
 
 	return c.json(response);

package/src/common/utils.ts

@@ -20,11 +20,15 @@ export function safeStringify(obj: unknown, maxSize: number) {
 	function replacer(key: string, value: unknown) {
 		if (value === null || value === undefined) return value;
 		const valueSize =
-			typeof value === "string" ? value.length : JSON.stringify(value).length;
+			typeof value === "string"
+				? value.length
+				: JSON.stringify(value).length;
 		size += key.length + valueSize;
 
 		if (size > maxSize) {
-			throw new Error(`JSON object exceeds size limit of ${maxSize} bytes.`);
+			throw new Error(
+				`JSON object exceeds size limit of ${maxSize} bytes.`,
+			);
 		}
 
 		return value;

package/src/driver-helpers/utils.ts

@@ -7,7 +7,10 @@ export function serializeEmptyPersistData(
 	input: unknown | undefined,
 ): Uint8Array {
 	const persistData: schema.PersistedActor = {
-		input: input !== undefined ? bufferToArrayBuffer(cbor.encode(input)) : null,
+		input:
+			input !== undefined
+				? bufferToArrayBuffer(cbor.encode(input))
+				: null,
 		hasInitialized: false,
 		state: bufferToArrayBuffer(cbor.encode(undefined)),
 		connections: [],

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

@@ -119,11 +119,20 @@ export function runDriverTests(
 								transport,
 							});
 
-							runActorConnStateTests({ ...driverTestConfig, transport });
+							runActorConnStateTests({
+								...driverTestConfig,
+								transport,
+							});
 
-							runActorReconnectTests({ ...driverTestConfig, transport });
+							runActorReconnectTests({
+								...driverTestConfig,
+								transport,
+							});
 
-							runRequestAccessTests({ ...driverTestConfig, transport });
+							runRequestAccessTests({
+								...driverTestConfig,
+								transport,
+							});
 
 							runActorDriverTestsWithTransport({
 								...driverTestConfig,
@@ -267,7 +276,9 @@ export async function createTestRuntime(
 		// Cleanup
 		const cleanup = async () => {
 			// Stop server
-			await new Promise((resolve) => server.close(() => resolve(undefined)));
+			await new Promise((resolve) =>
+				server.close(() => resolve(undefined)),
+			);
 
 			// Extra cleanup
 			await driverCleanup?.();

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

@@ -60,16 +60,26 @@ export function createTestInlineClientDriver(
 ): ManagerDriver {
 	return {
 		getForId(input: GetForIdInput): Promise<ActorOutput | undefined> {
-			return makeInlineRequest(endpoint, encoding, transport, "getForId", [
-				input,
-			]);
+			return makeInlineRequest(
+				endpoint,
+				encoding,
+				transport,
+				"getForId",
+				[input],
+			);
 		},
 		getWithKey(input: GetWithKeyInput): Promise<ActorOutput | undefined> {
-			return makeInlineRequest(endpoint, encoding, transport, "getWithKey", [
-				input,
-			]);
+			return makeInlineRequest(
+				endpoint,
+				encoding,
+				transport,
+				"getWithKey",
+				[input],
+			);
 		},
-		getOrCreateWithKey(input: GetOrCreateWithKeyInput): Promise<ActorOutput> {
+		getOrCreateWithKey(
+			input: GetOrCreateWithKeyInput,
+		): Promise<ActorOutput> {
 			return makeInlineRequest(
 				endpoint,
 				encoding,
@@ -79,9 +89,13 @@ export function createTestInlineClientDriver(
 			);
 		},
 		createActor(input: CreateInput): Promise<ActorOutput> {
-			return makeInlineRequest(endpoint, encoding, transport, "createActor", [
-				input,
-			]);
+			return makeInlineRequest(
+				endpoint,
+				encoding,
+				transport,
+				"createActor",
+				[input],
+			);
 		},
 		async sendRequest(
 			actorId: string,
@@ -104,7 +118,11 @@ export function createTestInlineClientDriver(
 			// Use the dedicated raw HTTP endpoint
 			const url = `${endpoint}/.test/inline-driver/send-request/${pathWithQuery}`;
 
-			logger().debug({ msg: "rewriting http url", from: oldUrl, to: url });
+			logger().debug({
+				msg: "rewriting http url",
+				from: oldUrl,
+				to: url,
+			});
 
 			// Merge headers with our metadata
 			const headers = new Headers(actorRequest.headers);
@@ -124,7 +142,9 @@ export function createTestInlineClientDriver(
 			// Check if it's an error response from our handler
 			if (
 				!response.ok &&
-				response.headers.get("content-type")?.includes("application/json")
+				response.headers
+					.get("content-type")
+					?.includes("application/json")
 			) {
 				try {
 					// Clone the response to avoid consuming the body
@@ -581,7 +601,9 @@ async function makeInlineRequest<T>(
 	} as RequestInit);
 
 	if (!response.ok) {
-		throw new Error(`Failed to call inline ${method}: ${response.statusText}`);
+		throw new Error(
+			`Failed to call inline ${method}: ${response.statusText}`,
+		);
 	}
 
 	// Parse response