rivetkit 2.3.0-rc.5 → 2.3.0-rc.6

package/src/common/client-protocol-versioned.ts

@@ -2,8 +2,9 @@ import { createVersionedDataHandler } from "vbare";
 import * as v1 from "./bare/generated/client-protocol/v1";
 import * as v2 from "./bare/generated/client-protocol/v2";
 import * as v3 from "./bare/generated/client-protocol/v3";
+import * as v4 from "./bare/generated/client-protocol/v4";
 
-export const CURRENT_VERSION = 3;
+export const CURRENT_VERSION = 4;
 
 // Converter from v1 to v2: Remove connectionToken from Init message
 const v1ToV2 = (v1Data: v1.ToClient): v2.ToClient => {
@@ -44,17 +45,45 @@ const v2ToV1 = (v2Data: v2.ToClient): v1.ToClient => {
 	return v2Data as unknown as v1.ToClient;
 };
 
-// Converter from v2 to v3: No changes needed for ToClient
+// Converter from v2 to v3: No changes needed for ToClient.
 const v2ToV3 = (v2Data: v2.ToClient): v3.ToClient => {
 	return v2Data as unknown as v3.ToClient;
 };
 
-// Converter from v3 to v2: No changes needed for ToClient
+const v3ToV4 = (v3Data: v3.ToClient): v4.ToClient => {
+	if (v3Data.body.tag === "Error") {
+		return {
+			body: {
+				tag: "Error",
+				val: {
+					...v3Data.body.val,
+					actor: null,
+				},
+			},
+		};
+	}
+	return v3Data as unknown as v4.ToClient;
+};
+
+const v4ToV3 = (v4Data: v4.ToClient): v3.ToClient => {
+	if (v4Data.body.tag === "Error") {
+		const { actor: _, ...val } = v4Data.body.val;
+		return {
+			body: {
+				tag: "Error",
+				val,
+			},
+		};
+	}
+	return v4Data as unknown as v3.ToClient;
+};
+
+// Converter from v3 to v2: No changes needed for ToClient.
 const v3ToV2 = (v3Data: v3.ToClient): v2.ToClient => {
 	return v3Data as unknown as v2.ToClient;
 };
 
-// ToServer identity converters (ToServer is identical across v1, v2, and v3)
+// ToServer identity converters.
 const v1ToServerV2 = (v1Data: v1.ToServer): v2.ToServer => {
 	return v1Data as unknown as v2.ToServer;
 };
@@ -63,6 +92,14 @@ const v2ToServerV3 = (v2Data: v2.ToServer): v3.ToServer => {
 	return v2Data as unknown as v3.ToServer;
 };
 
+const v3ToServerV4 = (v3Data: v3.ToServer): v4.ToServer => {
+	return v3Data as unknown as v4.ToServer;
+};
+
+const v4ToServerV3 = (v4Data: v4.ToServer): v3.ToServer => {
+	return v4Data as unknown as v3.ToServer;
+};
+
 const v3ToServerV2 = (v3Data: v3.ToServer): v2.ToServer => {
 	return v3Data as unknown as v2.ToServer;
 };
@@ -71,7 +108,21 @@ const v2ToServerV1 = (v2Data: v2.ToServer): v1.ToServer => {
 	return v2Data as unknown as v1.ToServer;
 };
 
-export const CLIENT_PROTOCOL_TO_SERVER = createVersionedDataHandler<v3.ToServer>({
+const v3HttpResponseErrorToV4 = (
+	v3Data: v3.HttpResponseError,
+): v4.HttpResponseError => ({
+	...v3Data,
+	actor: null,
+});
+
+const v4HttpResponseErrorToV3 = (
+	v4Data: v4.HttpResponseError,
+): v3.HttpResponseError => {
+	const { actor: _, ...rest } = v4Data;
+	return rest;
+};
+
+export const CLIENT_PROTOCOL_TO_SERVER = createVersionedDataHandler<v4.ToServer>({
 	deserializeVersion: (bytes, version) => {
 		switch (version) {
 			case 1:
@@ -80,6 +131,8 @@ export const CLIENT_PROTOCOL_TO_SERVER = createVersionedDataHandler<v3.ToServer>
 				return v2.decodeToServer(bytes);
 			case 3:
 				return v3.decodeToServer(bytes);
+			case 4:
+				return v4.decodeToServer(bytes);
 			default:
 				throw new Error(`Unknown version ${version}`);
 		}
@@ -92,15 +145,17 @@ export const CLIENT_PROTOCOL_TO_SERVER = createVersionedDataHandler<v3.ToServer>
 				return v2.encodeToServer(data as v2.ToServer);
 			case 3:
 				return v3.encodeToServer(data as v3.ToServer);
+			case 4:
+				return v4.encodeToServer(data as v4.ToServer);
 			default:
 				throw new Error(`Unknown version ${version}`);
 		}
 	},
-	deserializeConverters: () => [v1ToServerV2, v2ToServerV3],
-	serializeConverters: () => [v3ToServerV2, v2ToServerV1],
+	deserializeConverters: () => [v1ToServerV2, v2ToServerV3, v3ToServerV4],
+	serializeConverters: () => [v4ToServerV3, v3ToServerV2, v2ToServerV1],
 });
 
-export const CLIENT_PROTOCOL_TO_CLIENT = createVersionedDataHandler<v3.ToClient>({
+export const CLIENT_PROTOCOL_TO_CLIENT = createVersionedDataHandler<v4.ToClient>({
 	deserializeVersion: (bytes, version) => {
 		switch (version) {
 			case 1:
@@ -109,6 +164,8 @@ export const CLIENT_PROTOCOL_TO_CLIENT = createVersionedDataHandler<v3.ToClient>
 				return v2.decodeToClient(bytes);
 			case 3:
 				return v3.decodeToClient(bytes);
+			case 4:
+				return v4.decodeToClient(bytes);
 			default:
 				throw new Error(`Unknown version ${version}`);
 		}
@@ -121,16 +178,18 @@ export const CLIENT_PROTOCOL_TO_CLIENT = createVersionedDataHandler<v3.ToClient>
 				return v2.encodeToClient(data as v2.ToClient);
 			case 3:
 				return v3.encodeToClient(data as v3.ToClient);
+			case 4:
+				return v4.encodeToClient(data as v4.ToClient);
 			default:
 				throw new Error(`Unknown version ${version}`);
 		}
 	},
-	deserializeConverters: () => [v1ToV2, v2ToV3],
-	serializeConverters: () => [v3ToV2, v2ToV1],
+	deserializeConverters: () => [v1ToV2, v2ToV3, v3ToV4],
+	serializeConverters: () => [v4ToV3, v3ToV2, v2ToV1],
 });
 
 export const HTTP_ACTION_REQUEST_VERSIONED =
-	createVersionedDataHandler<v3.HttpActionRequest>({
+	createVersionedDataHandler<v4.HttpActionRequest>({
 		deserializeVersion: (bytes, version) => {
 			switch (version) {
 				case 1:
@@ -139,6 +198,8 @@ export const HTTP_ACTION_REQUEST_VERSIONED =
 					return v2.decodeHttpActionRequest(bytes);
 				case 3:
 					return v3.decodeHttpActionRequest(bytes);
+				case 4:
+					return v4.decodeHttpActionRequest(bytes);
 				default:
 					throw new Error(`Unknown version ${version}`);
 			}
@@ -157,6 +218,10 @@ export const HTTP_ACTION_REQUEST_VERSIONED =
 					return v3.encodeHttpActionRequest(
 						data as v3.HttpActionRequest,
 					);
+				case 4:
+					return v4.encodeHttpActionRequest(
+						data as v4.HttpActionRequest,
+					);
 				default:
 					throw new Error(`Unknown version ${version}`);
 			}
@@ -166,7 +231,7 @@ export const HTTP_ACTION_REQUEST_VERSIONED =
 	});
 
 export const HTTP_ACTION_RESPONSE_VERSIONED =
-	createVersionedDataHandler<v3.HttpActionResponse>({
+	createVersionedDataHandler<v4.HttpActionResponse>({
 		deserializeVersion: (bytes, version) => {
 			switch (version) {
 				case 1:
@@ -175,6 +240,8 @@ export const HTTP_ACTION_RESPONSE_VERSIONED =
 					return v2.decodeHttpActionResponse(bytes);
 				case 3:
 					return v3.decodeHttpActionResponse(bytes);
+				case 4:
+					return v4.decodeHttpActionResponse(bytes);
 				default:
 					throw new Error(`Unknown version ${version}`);
 			}
@@ -193,6 +260,10 @@ export const HTTP_ACTION_RESPONSE_VERSIONED =
 					return v3.encodeHttpActionResponse(
 						data as v3.HttpActionResponse,
 					);
+				case 4:
+					return v4.encodeHttpActionResponse(
+						data as v4.HttpActionResponse,
+					);
 				default:
 					throw new Error(`Unknown version ${version}`);
 			}
@@ -202,11 +273,13 @@ export const HTTP_ACTION_RESPONSE_VERSIONED =
 	});
 
 export const HTTP_QUEUE_SEND_REQUEST_VERSIONED =
-	createVersionedDataHandler<v3.HttpQueueSendRequest>({
+	createVersionedDataHandler<v4.HttpQueueSendRequest>({
 		deserializeVersion: (bytes, version) => {
 			switch (version) {
 				case 3:
 					return v3.decodeHttpQueueSendRequest(bytes);
+				case 4:
+					return v4.decodeHttpQueueSendRequest(bytes);
 				default:
 					throw new Error(
 						`HttpQueueSendRequest only exists in version 3+, got version ${version}`,
@@ -219,6 +292,10 @@ export const HTTP_QUEUE_SEND_REQUEST_VERSIONED =
 					return v3.encodeHttpQueueSendRequest(
 						data as v3.HttpQueueSendRequest,
 					);
+				case 4:
+					return v4.encodeHttpQueueSendRequest(
+						data as v4.HttpQueueSendRequest,
+					);
 				default:
 					throw new Error(
 						`HttpQueueSendRequest only exists in version 3+, got version ${version}`,
@@ -230,11 +307,13 @@ export const HTTP_QUEUE_SEND_REQUEST_VERSIONED =
 	});
 
 export const HTTP_QUEUE_SEND_RESPONSE_VERSIONED =
-	createVersionedDataHandler<v3.HttpQueueSendResponse>({
+	createVersionedDataHandler<v4.HttpQueueSendResponse>({
 		deserializeVersion: (bytes, version) => {
 			switch (version) {
 				case 3:
 					return v3.decodeHttpQueueSendResponse(bytes);
+				case 4:
+					return v4.decodeHttpQueueSendResponse(bytes);
 				default:
 					throw new Error(
 						`HttpQueueSendResponse only exists in version 3+, got version ${version}`,
@@ -247,6 +326,10 @@ export const HTTP_QUEUE_SEND_RESPONSE_VERSIONED =
 					return v3.encodeHttpQueueSendResponse(
 						data as v3.HttpQueueSendResponse,
 					);
+				case 4:
+					return v4.encodeHttpQueueSendResponse(
+						data as v4.HttpQueueSendResponse,
+					);
 				default:
 					throw new Error(
 						`HttpQueueSendResponse only exists in version 3+, got version ${version}`,
@@ -258,7 +341,7 @@ export const HTTP_QUEUE_SEND_RESPONSE_VERSIONED =
 	});
 
 export const HTTP_RESPONSE_ERROR_VERSIONED =
-	createVersionedDataHandler<v3.HttpResponseError>({
+	createVersionedDataHandler<v4.HttpResponseError>({
 		deserializeVersion: (bytes, version) => {
 			switch (version) {
 				case 1:
@@ -267,6 +350,8 @@ export const HTTP_RESPONSE_ERROR_VERSIONED =
 					return v2.decodeHttpResponseError(bytes);
 				case 3:
 					return v3.decodeHttpResponseError(bytes);
+				case 4:
+					return v4.decodeHttpResponseError(bytes);
 				default:
 					throw new Error(`Unknown version ${version}`);
 			}
@@ -285,16 +370,32 @@ export const HTTP_RESPONSE_ERROR_VERSIONED =
 					return v3.encodeHttpResponseError(
 						data as v3.HttpResponseError,
 					);
+				case 4:
+					return v4.encodeHttpResponseError(
+						data as v4.HttpResponseError,
+					);
 				default:
 					throw new Error(`Unknown version ${version}`);
 			}
 		},
-		deserializeConverters: () => [],
-		serializeConverters: () => [],
+		deserializeConverters: () => [
+			(data: v1.HttpResponseError) =>
+				data as unknown as v2.HttpResponseError,
+			(data: v2.HttpResponseError) =>
+				data as unknown as v3.HttpResponseError,
+			v3HttpResponseErrorToV4,
+		],
+		serializeConverters: () => [
+			v4HttpResponseErrorToV3,
+			(data: v3.HttpResponseError) =>
+				data as unknown as v2.HttpResponseError,
+			(data: v2.HttpResponseError) =>
+				data as unknown as v1.HttpResponseError,
+		],
 	});
 
 export const HTTP_RESOLVE_RESPONSE_VERSIONED =
-	createVersionedDataHandler<v3.HttpResolveResponse>({
+	createVersionedDataHandler<v4.HttpResolveResponse>({
 		deserializeVersion: (bytes, version) => {
 			switch (version) {
 				case 1:
@@ -303,6 +404,8 @@ export const HTTP_RESOLVE_RESPONSE_VERSIONED =
 					return v2.decodeHttpResolveResponse(bytes);
 				case 3:
 					return v3.decodeHttpResolveResponse(bytes);
+				case 4:
+					return v4.decodeHttpResolveResponse(bytes);
 				default:
 					throw new Error(`Unknown version ${version}`);
 			}
@@ -321,6 +424,10 @@ export const HTTP_RESOLVE_RESPONSE_VERSIONED =
 					return v3.encodeHttpResolveResponse(
 						data as v3.HttpResolveResponse,
 					);
+				case 4:
+					return v4.encodeHttpResolveResponse(
+						data as v4.HttpResolveResponse,
+					);
 				default:
 					throw new Error(`Unknown version ${version}`);
 			}

package/src/common/client-protocol-zod.ts

@@ -3,6 +3,11 @@ import { z } from "zod/v4";
 // Helper schemas
 const UintSchema = z.bigint();
 const OptionalUintSchema = UintSchema.nullable();
+const ActorSpecifierSchema = z.object({
+	actorId: z.string(),
+	generation: z.union([z.number(), z.bigint()]),
+	key: z.string().optional(),
+});
 
 // MARK: Message To Client
 export const InitSchema = z.object({
@@ -17,6 +22,7 @@ export const ErrorSchema = z.object({
 	message: z.string(),
 	metadata: z.unknown().optional(),
 	actionId: OptionalUintSchema,
+	actor: ActorSpecifierSchema.optional(),
 });
 export type Error = z.infer<typeof ErrorSchema>;
 
@@ -105,6 +111,7 @@ export const HttpResponseErrorSchema = z.object({
 	code: z.string(),
 	message: z.string(),
 	metadata: z.unknown().optional(),
+	actor: ActorSpecifierSchema.optional(),
 });
 export type HttpResponseError = z.infer<typeof HttpResponseErrorSchema>;
 

package/src/common/client-protocol.ts

@@ -1 +1 @@
-export * from "./bare/generated/client-protocol/v3";
+export * from "./bare/generated/client-protocol/v4";

package/src/common/database/native-database.test.ts

@@ -1,4 +1,5 @@
 import { describe, expect, test } from "vitest";
+import { BRIDGE_RIVET_ERROR_PREFIX } from "@/actor/errors";
 import {
 	type JsNativeDatabaseLike,
 	wrapJsNativeDatabase,
@@ -64,6 +65,14 @@ class FakeNativeDatabase implements JsNativeDatabaseLike {
 		});
 	}
 
+	rejectNext(error: unknown) {
+		const pending = this.#pending.shift();
+		if (!pending) {
+			throw new Error("no pending native execute call");
+		}
+		pending.reject(error);
+	}
+
 	async #startExecute(
 		sql: string,
 		params: NativeParams,
@@ -173,4 +182,30 @@ describe("wrapJsNativeDatabase", () => {
 			"Database is closed",
 		);
 	});
+
+	test("decodes sanitized native bridge errors without logging", async () => {
+		const native = new FakeNativeDatabase();
+		const db = wrapJsNativeDatabase(native);
+		const query = db.execute("SELECT broken", [1, "two"]);
+		const bridgeReason = `${BRIDGE_RIVET_ERROR_PREFIX}${JSON.stringify({
+			group: "rivetkit",
+			code: "internal_error",
+			message: "An internal error occurred",
+			statusCode: 500,
+		})}`;
+
+		native.rejectNext(new Error(bridgeReason));
+
+		await expect(query).rejects.toMatchObject({
+			name: "RivetError",
+			group: "rivetkit",
+			code: "internal_error",
+			message: "An internal error occurred",
+		});
+
+		await query.catch((error) => {
+			expect(error.stack).toContain("decodeBridgeRivetError");
+			expect(error.stack).toContain("enrichNativeDatabaseError");
+		});
+	});
 });

package/src/common/database/native-database.ts

@@ -92,12 +92,16 @@ function enrichNativeDatabaseError(
 	database: JsNativeDatabaseLike,
 	error: unknown,
 ): never {
-	const bridged =
+	const bridgeReason =
 		typeof error === "string"
-			? decodeBridgeRivetError(error)
+			? error
 			: error instanceof Error
-				? decodeBridgeRivetError(error.message)
-				: undefined;
+				? error.message
+			: undefined;
+	const bridged =
+		bridgeReason === undefined
+			? undefined
+			: decodeBridgeRivetError(bridgeReason);
 	if (bridged) {
 		throw bridged;
 	}

package/src/common/router.ts

@@ -1,5 +1,11 @@
 import type { Context as HonoContext, Next } from "hono";
 import * as envoyProtocol from "@rivetkit/engine-envoy-protocol";
+import type { ActorSpecifier } from "@/actor/errors";
+import {
+	HEADER_ACTOR_GENERATION,
+	HEADER_ACTOR_ID,
+	HEADER_ACTOR_KEY,
+} from "@/common/actor-router-consts";
 import type { Encoding } from "@/common/encoding";
 import {
 	getRequestEncoding,
@@ -61,16 +67,22 @@ export function handleRouteNotFound(c: HonoContext) {
 export function handleRouteError(error: unknown, c: HonoContext) {
 	const exposeInternalError = getRequestExposeInternalError(c.req.raw);
 
-	const { statusCode, group, code, message, metadata } = deconstructError(
+	const { statusCode, group, code, message, metadata, actor } = deconstructError(
 		error,
-		logger(),
-		{
-			method: c.req.method,
-			path: c.req.path,
-		},
 		exposeInternalError,
 	);
 
+	if (actor) {
+		logger().warn({
+			msg: "actor http error response",
+			actorId: actor.actorId,
+			generation: actor.generation,
+			actorKey: actor.key,
+			group,
+			code,
+		});
+	}
+
 	let encoding: Encoding;
 	try {
 		encoding = getRequestEncoding(c.req);
@@ -78,7 +90,7 @@ export function handleRouteError(error: unknown, c: HonoContext) {
 		encoding = "json";
 	}
 
-	const errorData = { group, code, message, metadata };
+	const errorData = { group, code, message, metadata, actor };
 	const output = serializeWithEncoding(
 		encoding,
 		errorData,
@@ -91,6 +103,7 @@ export function handleRouteError(error: unknown, c: HonoContext) {
 			code: value.code,
 			message: value.message,
 			metadata: value.metadata,
+			actor: value.actor,
 		}),
 		// BARE/CBOR: metadata needs to be CBOR-encoded to ArrayBuffer
 		(value): protocol.HttpResponseError => ({
@@ -100,11 +113,28 @@ export function handleRouteError(error: unknown, c: HonoContext) {
 			metadata: value.metadata
 				? bufferToArrayBuffer(encodeCborCompat(value.metadata))
 				: null,
+			actor: value.actor
+				? {
+						actorId: value.actor.actorId,
+						generation: BigInt(value.actor.generation),
+						key: value.actor.key ?? null,
+					}
+				: null,
 		}),
 	);
 
+	const headers = actor ? actorResponseHeaders(actor) : undefined;
+
 	// TODO: Remove any
-	return c.body(output as any, { status: statusCode });
+	return c.body(output as any, { status: statusCode, headers });
+}
+
+function actorResponseHeaders(actor: ActorSpecifier): Record<string, string> {
+	return {
+		[HEADER_ACTOR_ID]: actor.actorId,
+		[HEADER_ACTOR_GENERATION]: String(actor.generation),
+		...(actor.key ? { [HEADER_ACTOR_KEY]: actor.key } : {}),
+	};
 }
 
 export type MetadataEnvoyKind =

package/src/common/utils.ts

@@ -1,9 +1,7 @@
 import type { Next } from "hono";
 import type { ContentfulStatusCode } from "hono/utils/http-status";
 import * as errors from "@/actor/errors";
-import { EXTRA_ERROR_LOG } from "@/utils";
 import { getLogErrorStack } from "@/utils/env-vars";
-import type { Logger } from "./log";
 
 export function assertUnreachable(x: never): never {
 	throw new Error(`Unreachable case: ${x}`);
@@ -195,6 +193,7 @@ export interface DeconstructedError {
 	code: string;
 	message: string;
 	metadata?: unknown;
+	actor?: errors.ActorSpecifier;
 }
 
 function isCanonicalStructuredRivetError(
@@ -221,19 +220,16 @@ function isCanonicalStructuredRivetError(
  */
 export function deconstructError(
 	error: unknown,
-	logger: Logger,
-	extraLog: Record<string, unknown>,
 	exposeInternalError = false,
 ): DeconstructedError {
 	// Build response error information. Only return errors if flagged as public in order to prevent leaking internal behavior.
-	//
-	// We log the error here instead of after generating the code & message because we need to log the original error, not the masked internal error.
 	let statusCode: ContentfulStatusCode;
 	let public_: boolean;
 	let group: string;
 	let code: string;
 	let message: string;
 	let metadata: unknown;
+	let actor: errors.ActorSpecifier | undefined;
 	// Structured errors from core or from pre-built `RivetError` instances are canonical.
 	// Only unstructured errors go through the classifier below.
 	if (isCanonicalStructuredRivetError(error)) {
@@ -249,15 +245,7 @@ export function deconstructError(
 		code = error.code;
 		message = error.message;
 		metadata = error.metadata;
-
-		logger.info({
-			msg: "structured error passthrough",
-			group,
-			code,
-			message,
-			...EXTRA_ERROR_LOG,
-			...extraLog,
-		});
+		actor = error.actor;
 	} else if (errors.ActorError.isActorError(error) && error.public) {
 		// Check if error has statusCode (could be ActorError instance or DeconstructedError)
 		statusCode = (
@@ -268,15 +256,7 @@ export function deconstructError(
 		code = error.code;
 		message = getErrorMessage(error);
 		metadata = error.metadata;
-
-		logger.info({
-			msg: "public error",
-			group,
-			code,
-			message,
-			...EXTRA_ERROR_LOG,
-			...extraLog,
-		});
+		actor = error.actor;
 	} else if (exposeInternalError) {
 		if (errors.ActorError.isActorError(error)) {
 			statusCode = 500;
@@ -285,32 +265,13 @@ export function deconstructError(
 			code = error.code;
 			message = getErrorMessage(error);
 			metadata = error.metadata;
-
-			logger.info({
-				msg: "internal error",
-				group,
-				code,
-				message,
-				stack: (error as Error)?.stack,
-				...EXTRA_ERROR_LOG,
-				...extraLog,
-			});
+			actor = error.actor;
 		} else {
 			statusCode = 500;
 			public_ = false;
 			group = "rivetkit";
 			code = errors.INTERNAL_ERROR_CODE;
 			message = getErrorMessage(error);
-
-			logger.info({
-				msg: "internal error",
-				group,
-				code,
-				message,
-				stack: (error as Error)?.stack,
-				...EXTRA_ERROR_LOG,
-				...extraLog,
-			});
 		}
 	} else {
 		statusCode = 500;
@@ -318,17 +279,12 @@ export function deconstructError(
 		group = "rivetkit";
 		code = errors.INTERNAL_ERROR_CODE;
 		message = errors.INTERNAL_ERROR_DESCRIPTION;
+		if (errors.ActorError.isActorError(error)) {
+			actor = error.actor;
+		}
 		metadata = {
 			//url: `https://hub.rivet.dev/projects/${actorMetadata.project.slug}/environments/${actorMetadata.environment.slug}/actors?actorId=${actorMetadata.actor.id}`,
 		} satisfies errors.InternalErrorMetadata;
-
-		logger.warn({
-			msg: "internal error",
-			error: getErrorMessage(error),
-			stack: (error as Error)?.stack,
-			...EXTRA_ERROR_LOG,
-			...extraLog,
-		});
 	}
 
 	return {
@@ -339,6 +295,7 @@ export function deconstructError(
 		code,
 		message,
 		metadata,
+		actor,
 	};
 }