@electric-ax/agents-server 0.4.9 → 0.4.11

package/dist/index.cjs

@@ -451,7 +451,7 @@ const ErrCodeForkInProgress = `FORK_IN_PROGRESS`;
 const ErrCodeForkWaitTimeout = `FORK_WAIT_TIMEOUT`;
 const ErrCodeEntityPersistFailed = `ENTITY_PERSIST_FAILED`;
 const ErrCodeSubscriptionNotFound = `SUBSCRIPTION_NOT_FOUND`;
-const ErrCodeCallbackNotFound = `CALLBACK_NOT_FOUND`;
+const ErrCodeWakeCallbackNotFound = `WAKE_CALLBACK_NOT_FOUND`;
 
 //#endregion
 //#region src/tenant.ts
@@ -2532,7 +2532,7 @@ async function linkStreamToTargetSubscription(ctx, target, entity, subscriptionI
 	}
 	const webhookUrl = rewriteLoopbackWebhookUrl(target.url);
 	if (!webhookUrl) throw new ElectricAgentsError(ErrCodeInvalidRequest, `Webhook dispatch target must include a valid URL`, 400);
-	const forwardUrl = (0, __electric_ax_agents_runtime.appendPathToUrl)(ctx.publicUrl, `/_electric/webhook-forward/${encodeURIComponent(subscriptionId)}`);
+	const forwardUrl = (0, __electric_ax_agents_runtime.appendPathToUrl)(ctx.publicUrl, `/_electric/subscription-webhooks/${encodeURIComponent(subscriptionId)}`);
 	await ensureSubscriptionIncludesStream(ctx, subscriptionId, streamPath, {
 		type: `webhook`,
 		streams: [streamPath],
@@ -3617,7 +3617,7 @@ var EntityManager = class {
 		};
 	}
 	/**
-	* Deliver a message to an entity's main stream, with optional input schema
+	* Deliver a message to an entity's main stream, with optional inbox schema
 	* validation.
 	*/
 	async send(entityUrl, req, opts) {
@@ -3705,7 +3705,7 @@ var EntityManager = class {
 		if (result.changed && this.entityBridgeManager) await this.entityBridgeManager.onEntityChanged(entityUrl);
 		return updated;
 	}
-	async removeTag(entityUrl, key, token) {
+	async deleteTag(entityUrl, key, token) {
 		const entity = await this.registry.getEntity(entityUrl);
 		if (!entity) throw new ElectricAgentsError(ErrCodeNotFound, `Entity not found`, 404);
 		if (!this.isValidWriteToken(entity, token)) throw new ElectricAgentsError(ErrCodeUnauthorized, `Invalid write token`, 401);
@@ -3716,7 +3716,7 @@ var EntityManager = class {
 		if (result.changed && this.entityBridgeManager) await this.entityBridgeManager.onEntityChanged(entityUrl);
 		return updated;
 	}
-	async registerEntitiesSource(tags) {
+	async ensureEntitiesMembershipStream(tags) {
 		if (!this.entityBridgeManager) throw new Error(`Entity bridge manager not configured`);
 		return this.entityBridgeManager.register(this.validateTags(tags));
 	}
@@ -4145,7 +4145,7 @@ var EntityManager = class {
 		return null;
 	}
 	/**
-	* Add new input/output schema keys to an entity type directly in Postgres.
+	* Add new inbox/state schema keys to an entity type directly in Postgres.
 	*/
 	async amendSchemas(typeName, schemas) {
 		if (typeName === `principal`) throw new ElectricAgentsError(ErrCodeInvalidRequest, `Entity type "principal" is built in and cannot be amended`, 400);
@@ -4185,7 +4185,7 @@ var EntityManager = class {
 	}
 	/**
 	* Enrich webhook payload with entity context.
-	* Called by ElectricAgentsServer during webhook forwarding to inject entity context.
+	* Called by ElectricAgentsServer during subscription webhook dispatch to inject entity context.
 	*/
 	async enrichPayload(payload, consumer) {
 		const entity = await this.registry.getEntityByStream(consumer.primary_stream);
@@ -5444,7 +5444,7 @@ var WakeRegistry = class {
 				try {
 					for (const message of messages) {
 						await this.applyShapeMessage(message);
-						if (!settled && `control` in message.headers && message.headers.control === `up-to-date`) {
+						if (!settled && (0, __electric_sql_client.isControlMessage)(message) && message.headers.control === `up-to-date`) {
 							settled = true;
 							resolve$1();
 						}
@@ -6231,7 +6231,7 @@ function validateParsedBody(schema, parsed) {
 //#region src/routing/durable-streams-routing-adapter.ts
 function appendSearch(target, source) {
 	source.searchParams.forEach((value, key) => {
-		if (key !== `service`) target.searchParams.append(key, value);
+		target.searchParams.append(key, value);
 	});
 	return target;
 }
@@ -6551,7 +6551,7 @@ async function rewriteSubscriptionRequestBody(request, ctx, subscriptionId, rout
 	let targetWebhookUrl = null;
 	if (payload.webhook?.url !== void 0) {
 		targetWebhookUrl = rewriteLoopbackWebhookUrl(payload.webhook.url) ?? null;
-		payload.webhook.url = (0, __electric_ax_agents_runtime.appendPathToUrl)(ctx.publicUrl, `/_electric/webhook-forward/${encodeURIComponent(subscriptionId)}`);
+		payload.webhook.url = (0, __electric_ax_agents_runtime.appendPathToUrl)(ctx.publicUrl, `/_electric/subscription-webhooks/${encodeURIComponent(subscriptionId)}`);
 	}
 	rewriteSubscriptionBodyForBackend(payload, ctx.service, routingAdapter);
 	return {
@@ -6674,20 +6674,6 @@ async function proxyPassThrough(request, ctx) {
 	}
 }
 
-//#endregion
-//#region src/routing/cron-router.ts
-const cronRegisterBodySchema = __sinclair_typebox.Type.Object({
-	expression: __sinclair_typebox.Type.String(),
-	timezone: __sinclair_typebox.Type.Optional(__sinclair_typebox.Type.String())
-});
-const cronRouter = (0, itty_router.Router)({ base: `/_electric/cron` });
-cronRouter.post(`/register`, withSchema(cronRegisterBodySchema), registerCron);
-async function registerCron(request, ctx) {
-	const parsed = routeBody(request);
-	const streamPath = await ctx.entityManager.getOrCreateCronStream(parsed.expression, parsed.timezone);
-	return (0, itty_router.json)({ streamUrl: streamPath });
-}
-
 //#endregion
 //#region src/routing/electric-proxy-router.ts
 const electricProxyRouter = (0, itty_router.Router)({ base: `/_electric/electric` });
@@ -6721,7 +6707,7 @@ async function proxyElectric(request, ctx) {
 
 //#endregion
 //#region src/routing/entities-router.ts
-const stringRecordSchema = __sinclair_typebox.Type.Record(__sinclair_typebox.Type.String(), __sinclair_typebox.Type.String());
+const stringRecordSchema$1 = __sinclair_typebox.Type.Record(__sinclair_typebox.Type.String(), __sinclair_typebox.Type.String());
 function writeTokenFromRequest(request) {
 	const electricClaimToken = request.headers.get(`electric-claim-token`)?.trim();
 	if (electricClaimToken) return electricClaimToken;
@@ -6738,7 +6724,7 @@ const wakeConditionSchema = __sinclair_typebox.Type.Union([__sinclair_typebox.Ty
 })]);
 const spawnBodySchema = __sinclair_typebox.Type.Object({
 	args: __sinclair_typebox.Type.Optional(__sinclair_typebox.Type.Record(__sinclair_typebox.Type.String(), __sinclair_typebox.Type.Unknown())),
-	tags: __sinclair_typebox.Type.Optional(stringRecordSchema),
+	tags: __sinclair_typebox.Type.Optional(stringRecordSchema$1),
 	parent: __sinclair_typebox.Type.Optional(__sinclair_typebox.Type.String()),
 	dispatch_policy: __sinclair_typebox.Type.Optional(dispatchPolicySchema),
 	initialMessage: __sinclair_typebox.Type.Optional(__sinclair_typebox.Type.Unknown()),
@@ -6830,10 +6816,8 @@ const eventSourceSubscriptionBodySchema = __sinclair_typebox.Type.Object({
 	lifetime: __sinclair_typebox.Type.Optional(subscriptionLifetimeSchema),
 	reason: __sinclair_typebox.Type.Optional(__sinclair_typebox.Type.String())
 });
-const entitiesRegisterBodySchema = __sinclair_typebox.Type.Object({ tags: __sinclair_typebox.Type.Optional(stringRecordSchema) });
 const entitiesRouter = (0, itty_router.Router)({ base: `/_electric/entities` });
 entitiesRouter.get(`/`, listEntities);
-entitiesRouter.post(`/register`, withSchema(entitiesRegisterBodySchema), registerEntitiesSource);
 entitiesRouter.put(`/:type/:instanceId`, withSpawnableEntityType, withSchema(spawnBodySchema), spawnEntity);
 entitiesRouter.get(`/:type/:instanceId`, withExistingEntity, getEntity);
 entitiesRouter.head(`/:type/:instanceId`, withExistingEntity, headEntity);
@@ -6844,7 +6828,7 @@ entitiesRouter.patch(`/:type/:instanceId/inbox/:messageKey`, withExistingEntity,
 entitiesRouter.delete(`/:type/:instanceId/inbox/:messageKey`, withExistingEntity, deleteInboxMessage);
 entitiesRouter.post(`/:type/:instanceId/fork`, withExistingEntity, withSchema(forkBodySchema), forkEntity);
 entitiesRouter.post(`/:type/:instanceId/tags/:tagKey`, withExistingEntity, withSchema(setTagBodySchema), setTag);
-entitiesRouter.delete(`/:type/:instanceId/tags/:tagKey`, withExistingEntity, removeTag);
+entitiesRouter.delete(`/:type/:instanceId/tags/:tagKey`, withExistingEntity, deleteTag);
 entitiesRouter.put(`/:type/:instanceId/schedules/:scheduleId`, withExistingEntity, withSchema(scheduleBodySchema), upsertSchedule);
 entitiesRouter.delete(`/:type/:instanceId/schedules/:scheduleId`, withExistingEntity, deleteSchedule);
 entitiesRouter.put(`/:type/:instanceId/event-source-subscriptions/:subscriptionId`, withExistingEntity, withSchema(eventSourceSubscriptionBodySchema), upsertEventSourceSubscription);
@@ -6912,11 +6896,6 @@ async function listEntities({ query }, ctx) {
 	});
 	return (0, itty_router.json)(entities$1.map((entity) => toPublicEntity(entity)));
 }
-async function registerEntitiesSource(request, ctx) {
-	const parsed = routeBody(request);
-	const result = await ctx.entityManager.registerEntitiesSource(parsed.tags ?? {});
-	return (0, itty_router.json)(result);
-}
 async function upsertSchedule(request, ctx) {
 	const principalMutationError = rejectPrincipalEntityMutation(request, `scheduled`);
 	if (principalMutationError) return principalMutationError;
@@ -6997,7 +6976,7 @@ async function deleteEventSourceSubscription(request, ctx) {
 	return (0, itty_router.json)(result);
 }
 async function setTag(request, ctx) {
-	const principalMutationError = rejectPrincipalEntityMutation(request, `tagged`);
+	const principalMutationError = rejectPrincipalEntityMutation(request, `tag updated`);
 	if (principalMutationError) return principalMutationError;
 	const parsed = routeBody(request);
 	const { entityUrl } = requireExistingEntityRoute(request);
@@ -7005,12 +6984,12 @@ async function setTag(request, ctx) {
 	const updated = await ctx.entityManager.setTag(entityUrl, decodeURIComponent(request.params.tagKey), { value: parsed.value }, token);
 	return (0, itty_router.json)(toPublicEntity(updated));
 }
-async function removeTag(request, ctx) {
-	const principalMutationError = rejectPrincipalEntityMutation(request, `untagged`);
+async function deleteTag(request, ctx) {
+	const principalMutationError = rejectPrincipalEntityMutation(request, `tag deleted`);
 	if (principalMutationError) return principalMutationError;
 	const { entityUrl } = requireExistingEntityRoute(request);
 	const token = writeTokenFromRequest(request);
-	const updated = await ctx.entityManager.removeTag(entityUrl, decodeURIComponent(request.params.tagKey), token);
+	const updated = await ctx.entityManager.deleteTag(entityUrl, decodeURIComponent(request.params.tagKey), token);
 	return (0, itty_router.json)(toPublicEntity(updated));
 }
 async function forkEntity(request, ctx) {
@@ -7142,17 +7121,13 @@ const registerEntityTypeBodySchema = __sinclair_typebox.Type.Object({
 	creation_schema: __sinclair_typebox.Type.Optional(jsonObjectSchema),
 	inbox_schemas: __sinclair_typebox.Type.Optional(schemaMapSchema),
 	state_schemas: __sinclair_typebox.Type.Optional(schemaMapSchema),
-	input_schemas: __sinclair_typebox.Type.Optional(schemaMapSchema),
-	output_schemas: __sinclair_typebox.Type.Optional(schemaMapSchema),
 	serve_endpoint: __sinclair_typebox.Type.Optional(__sinclair_typebox.Type.String()),
 	default_dispatch_policy: __sinclair_typebox.Type.Optional(dispatchPolicySchema)
-});
+}, { additionalProperties: false });
 const amendEntityTypeSchemasBodySchema = __sinclair_typebox.Type.Object({
-	input_schemas: __sinclair_typebox.Type.Optional(schemaMapSchema),
-	output_schemas: __sinclair_typebox.Type.Optional(schemaMapSchema),
 	inbox_schemas: __sinclair_typebox.Type.Optional(schemaMapSchema),
 	state_schemas: __sinclair_typebox.Type.Optional(schemaMapSchema)
-});
+}, { additionalProperties: false });
 const entityTypesRouter = (0, itty_router.Router)({ base: `/_electric/entity-types` });
 entityTypesRouter.get(`/`, listEntityTypes);
 entityTypesRouter.post(`/`, withSchema(registerEntityTypeBodySchema), registerEntityType);
@@ -7192,8 +7167,8 @@ async function getEntityType(request, ctx) {
 async function amendSchemas(request, ctx) {
 	const parsed = routeBody(request);
 	const updated = await ctx.entityManager.amendSchemas(request.params.name, {
-		inbox_schemas: parsed.inbox_schemas ?? parsed.input_schemas,
-		state_schemas: parsed.state_schemas ?? parsed.output_schemas
+		inbox_schemas: parsed.inbox_schemas,
+		state_schemas: parsed.state_schemas
 	});
 	return (0, itty_router.json)(toPublicEntityType(updated));
 }
@@ -7203,13 +7178,12 @@ async function deleteEntityType(request, ctx) {
 }
 function normalizeEntityTypeRequest(parsed) {
 	const serveEndpoint = rewriteLoopbackWebhookUrl(parsed.serve_endpoint);
-	const compatibilityFields = parsed;
 	return {
 		name: parsed.name ?? ``,
 		description: parsed.description ?? ``,
 		creation_schema: parsed.creation_schema,
-		inbox_schemas: parsed.inbox_schemas ?? compatibilityFields.input_schemas,
-		state_schemas: parsed.state_schemas ?? compatibilityFields.output_schemas,
+		inbox_schemas: parsed.inbox_schemas,
+		state_schemas: parsed.state_schemas,
 		serve_endpoint: serveEndpoint,
 		default_dispatch_policy: parsed.default_dispatch_policy ?? (serveEndpoint ? { targets: [{
 			type: `webhook`,
@@ -7220,8 +7194,6 @@ function normalizeEntityTypeRequest(parsed) {
 function toPublicEntityType(entityType) {
 	return {
 		...entityType,
-		input_schemas: entityType.inbox_schemas,
-		output_schemas: entityType.state_schemas,
 		revision: entityType.revision
 	};
 }
@@ -7305,13 +7277,35 @@ function errorMapper(err, req) {
 function rejectIfShuttingDown(req, ctx) {
 	if (!ctx.isShuttingDown()) return void 0;
 	const path$2 = new URL(req.url).pathname;
-	if (!path$2.startsWith(`/_electric/webhook-forward/`)) return void 0;
+	if (!path$2.startsWith(`/_electric/subscription-webhooks/`)) return void 0;
 	return apiError(503, `SERVER_STOPPING`, `Server is shutting down`);
 }
 function getRequestSpan(req) {
 	return carrier(req)[SPAN_KEY];
 }
 
+//#endregion
+//#region src/routing/observations-router.ts
+const stringRecordSchema = __sinclair_typebox.Type.Record(__sinclair_typebox.Type.String(), __sinclair_typebox.Type.String());
+const ensureEntitiesMembershipStreamBodySchema = __sinclair_typebox.Type.Object({ tags: __sinclair_typebox.Type.Optional(stringRecordSchema) });
+const ensureCronStreamBodySchema = __sinclair_typebox.Type.Object({
+	expression: __sinclair_typebox.Type.String(),
+	timezone: __sinclair_typebox.Type.Optional(__sinclair_typebox.Type.String())
+});
+const observationsRouter = (0, itty_router.Router)({ base: `/_electric/observations` });
+observationsRouter.post(`/entities/ensure-stream`, withSchema(ensureEntitiesMembershipStreamBodySchema), ensureEntitiesMembershipStream);
+observationsRouter.post(`/cron/ensure-stream`, withSchema(ensureCronStreamBodySchema), ensureCronStream);
+async function ensureEntitiesMembershipStream(request, ctx) {
+	const parsed = routeBody(request);
+	const result = await ctx.entityManager.ensureEntitiesMembershipStream(parsed.tags ?? {});
+	return (0, itty_router.json)(result);
+}
+async function ensureCronStream(request, ctx) {
+	const parsed = routeBody(request);
+	const streamPath = await ctx.entityManager.getOrCreateCronStream(parsed.expression, parsed.timezone);
+	return (0, itty_router.json)({ streamUrl: streamPath });
+}
+
 //#endregion
 //#region src/routing/tenant-stream-paths.ts
 function withLeadingSlash(path$2) {
@@ -7650,7 +7644,7 @@ async function notificationFromClaim(ctx, input) {
 		wakeId: input.claim.wake_id,
 		streamPath: primaryStream,
 		streams: streams$1,
-		callback: (0, __electric_ax_agents_runtime.appendPathToUrl)(ctx.publicUrl, `/_electric/callback-forward/${encodeURIComponent(input.claim.wake_id)}`),
+		callback: (0, __electric_ax_agents_runtime.appendPathToUrl)(ctx.publicUrl, `/_electric/wake-callbacks/${encodeURIComponent(input.claim.wake_id)}`),
 		claimToken: input.claim.token,
 		triggerEvent: `message_received`,
 		entity: {
@@ -7685,7 +7679,7 @@ const wakeRegistrationBodySchema = __sinclair_typebox.Type.Object({
 	includeResponse: __sinclair_typebox.Type.Optional(__sinclair_typebox.Type.Boolean()),
 	manifestKey: __sinclair_typebox.Type.Optional(__sinclair_typebox.Type.String())
 });
-const webhookForwardBodySchema = __sinclair_typebox.Type.Object({
+const subscriptionWebhookBodySchema = __sinclair_typebox.Type.Object({
 	subscription_id: __sinclair_typebox.Type.Optional(__sinclair_typebox.Type.String()),
 	wake_id: __sinclair_typebox.Type.Optional(__sinclair_typebox.Type.String()),
 	generation: __sinclair_typebox.Type.Optional(__sinclair_typebox.Type.Number()),
@@ -7699,7 +7693,7 @@ const webhookForwardBodySchema = __sinclair_typebox.Type.Object({
 	consumer_id: __sinclair_typebox.Type.Optional(__sinclair_typebox.Type.String()),
 	callback: __sinclair_typebox.Type.Optional(__sinclair_typebox.Type.String())
 }, { additionalProperties: true });
-const callbackForwardBodySchema = __sinclair_typebox.Type.Object({
+const wakeCallbackBodySchema = __sinclair_typebox.Type.Object({
 	epoch: __sinclair_typebox.Type.Optional(__sinclair_typebox.Type.Number()),
 	generation: __sinclair_typebox.Type.Optional(__sinclair_typebox.Type.Number()),
 	wakeId: __sinclair_typebox.Type.Optional(__sinclair_typebox.Type.String()),
@@ -7712,13 +7706,13 @@ const internalRouter = (0, itty_router.Router)({ base: `/_electric` });
 internalRouter.get(`/health`, () => (0, itty_router.json)({ status: `ok` }));
 internalRouter.get(`/event-sources`, listEventSources);
 internalRouter.post(`/wake`, withSchema(wakeRegistrationBodySchema), registerWake);
-internalRouter.post(`/webhook-forward/:subscriptionId`, webhookForward);
-internalRouter.post(`/callback-forward/:consumerId`, callbackForward);
+internalRouter.post(`/subscription-webhooks/:subscriptionId`, subscriptionWebhook);
+internalRouter.post(`/wake-callbacks/:consumerId`, wakeCallback);
 internalRouter.all(`/runners`, runnersRouter.fetch);
 internalRouter.all(`/runners/*`, runnersRouter.fetch);
 internalRouter.all(`/entities/*`, entitiesRouter.fetch);
 internalRouter.all(`/entity-types/*`, entityTypesRouter.fetch);
-internalRouter.all(`/cron/*`, cronRouter.fetch);
+internalRouter.all(`/observations/*`, observationsRouter.fetch);
 internalRouter.get(`/electric/*`, electricProxyRouter.fetch);
 internalRouter.all(`*`, () => (0, itty_router.status)(404));
 function routeParam(request, name) {
@@ -7751,13 +7745,30 @@ function resolveWebhookSigner(ctx) {
 	return ctx.webhookSigner ?? getDefaultWebhookSigner();
 }
 function durableStreamsWebhookJwksUrl(ctx) {
-	if (!ctx.durableStreamsRouting) return (0, __electric_ax_agents_runtime.appendPathToUrl)(ctx.durableStreamsUrl, `/__ds/jwks.json`);
+	if (!ctx.durableStreamsRouting) return appendPathToBackendUrl(ctx.durableStreamsUrl, `/__ds/jwks.json`);
 	return resolveDurableStreamsRoutingAdapter(ctx.durableStreamsRouting, ctx.durableStreamsUrl).controlUrl({
 		durableStreamsUrl: ctx.durableStreamsUrl,
 		serviceId: ctx.service,
 		requestUrl: (0, __electric_ax_agents_runtime.appendPathToUrl)(ctx.publicUrl, `/__ds/jwks.json`)
 	}).toString();
 }
+function appendPathToBackendUrl(baseUrl, path$2) {
+	const base = new URL(baseUrl);
+	const pathUrl = new URL(path$2, `http://electric-agents.local`);
+	const basePath = base.pathname === `/` ? `` : base.pathname.replace(/\/+$/, ``);
+	const suffix = pathUrl.pathname.startsWith(`/`) ? pathUrl.pathname : `/${pathUrl.pathname}`;
+	const target = new URL(base);
+	target.pathname = `${basePath}${suffix}`;
+	target.search = ``;
+	target.hash = pathUrl.hash;
+	base.searchParams.forEach((value, key) => {
+		target.searchParams.append(key, value);
+	});
+	pathUrl.searchParams.forEach((value, key) => {
+		target.searchParams.append(key, value);
+	});
+	return target.toString();
+}
 function durableStreamsJwksFetchClient(ctx) {
 	return async (input, init) => {
 		const headers = new Headers(init?.headers);
@@ -7821,10 +7832,10 @@ async function listEventSources(_request, ctx) {
 function isAgentVisibleEventSource(source) {
 	return source.agentVisible === true && source.status === `active`;
 }
-async function webhookForward(request, ctx) {
+async function subscriptionWebhook(request, ctx) {
 	const subscriptionId = routeParam(request, `subscriptionId`);
 	const rootSpan = getRequestSpan(request);
-	rootSpan?.updateName(`webhook-forward`);
+	rootSpan?.updateName(`subscription-webhook`);
 	rootSpan?.setAttribute(`electric_agents.webhook.subscription_id`, subscriptionId);
 	const body = await readRequestBody(request);
 	const signatureError = await verifyDurableStreamsWebhook(request, ctx, body);
@@ -7838,7 +7849,7 @@ async function webhookForward(request, ctx) {
 		}
 	});
 	if (!targetWebhookUrl) return apiError(404, ErrCodeSubscriptionNotFound, `Unknown webhook subscription`);
-	const parsedBodyResult = validateOptionalJsonBody(webhookForwardBodySchema, body, request.headers.get(`content-type`));
+	const parsedBodyResult = validateOptionalJsonBody(subscriptionWebhookBodySchema, body, request.headers.get(`content-type`));
 	if (!parsedBodyResult.ok) return parsedBodyResult.response;
 	let forwardBody = body;
 	let runningEntityUrl = null;
@@ -7884,7 +7895,7 @@ async function webhookForward(request, ctx) {
 					span.end();
 				}
 			}).catch((err) => {
-				serverLog.warn(`[webhook-forward] consumerCallbacks upsert failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`);
+				serverLog.warn(`[subscription-webhook] consumerCallbacks upsert failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`);
 			}) : void 0;
 			const [entity, enriched] = await Promise.all([entityPromise, enrichPromise]);
 			if (entity?.status === `stopped` || entity?.status === `paused`) {
@@ -7905,7 +7916,7 @@ async function webhookForward(request, ctx) {
 				runningEntityUrl = entity.url;
 			}
 			if (consumerId && callbackUrl) {
-				const callback = (0, __electric_ax_agents_runtime.appendPathToUrl)(ctx.publicUrl, `/_electric/callback-forward/${encodeURIComponent(consumerId)}`);
+				const callback = (0, __electric_ax_agents_runtime.appendPathToUrl)(ctx.publicUrl, `/_electric/wake-callbacks/${encodeURIComponent(consumerId)}`);
 				enriched.callback = callback;
 				if (newWebhook) {
 					enriched.consumerId = newWebhook.wakeId;
@@ -7942,21 +7953,21 @@ async function webhookForward(request, ctx) {
 		});
 	} catch (err) {
 		if (runningEntityUrl) await ctx.entityManager.registry.updateStatus(runningEntityUrl, `idle`);
-		return apiError(502, `WEBHOOK_FORWARD_FAILED`, err instanceof Error ? err.message : String(err));
+		return apiError(502, `SUBSCRIPTION_WEBHOOK_FAILED`, err instanceof Error ? err.message : String(err));
 	}
 	const responseBytes = upstream.body ? new Uint8Array(await upstream.arrayBuffer()) : new Uint8Array();
 	return responseFromUpstream(upstream, responseBytes);
 }
-async function callbackForward(request, ctx) {
+async function wakeCallback(request, ctx) {
 	const consumerId = routeParam(request, `consumerId`);
 	const rows = await ctx.pgDb.select().from(consumerCallbacks).where((0, drizzle_orm.and)((0, drizzle_orm.eq)(consumerCallbacks.tenantId, ctx.service), (0, drizzle_orm.eq)(consumerCallbacks.consumerId, consumerId))).limit(1);
 	const target = rows[0] ? {
 		callbackUrl: rows[0].callbackUrl,
 		primaryStream: rows[0].primaryStream
 	} : void 0;
-	if (!target) return apiError(404, ErrCodeCallbackNotFound, `Unknown callback-forward consumer`);
+	if (!target) return apiError(404, ErrCodeWakeCallbackNotFound, `Unknown wake-callback consumer`);
 	const body = await readRequestBody(request);
-	const parsedBodyResult = validateOptionalJsonBody(callbackForwardBodySchema, body, request.headers.get(`content-type`));
+	const parsedBodyResult = validateOptionalJsonBody(wakeCallbackBodySchema, body, request.headers.get(`content-type`));
 	if (!parsedBodyResult.ok) return parsedBodyResult.response;
 	const requestBody = parsedBodyResult.value;
 	const isClaimRequest = requestBody?.wakeId !== void 0 || requestBody?.wake_id !== void 0;
@@ -7974,14 +7985,14 @@ async function callbackForward(request, ctx) {
 		}
 		return (0, itty_router.json)(responseBody);
 	}
-	const upstreamBody = encodeCallbackForwardBody(ctx.service, consumerId, requestBody, resolveDurableStreamsRoutingAdapter(ctx.durableStreamsRouting, ctx.durableStreamsUrl));
+	const upstreamBody = encodeWakeCallbackBody(ctx.service, consumerId, requestBody, resolveDurableStreamsRoutingAdapter(ctx.durableStreamsRouting, ctx.durableStreamsUrl));
 	let upstream;
 	try {
 		const subscriptionId = durableStreamsSubscriptionCallback(target.callbackUrl);
 		if (subscriptionId) {
 			const token = claimTokenFromRequest(request);
 			if (!token) return apiError(401, `UNAUTHORIZED`, `Missing claim token`);
-			const upstreamPayload = encodeCallbackForwardPayload(consumerId, requestBody, (stream) => stream.replace(/^\/+/, ``));
+			const upstreamPayload = encodeWakeCallbackPayload(consumerId, requestBody, (stream) => stream.replace(/^\/+/, ``));
 			const result = await ctx.streamClient.ackSubscription(subscriptionId, token, upstreamPayload);
 			upstream = (0, itty_router.json)(result);
 		} else upstream = await fetch(target.callbackUrl, {
@@ -7990,7 +8001,7 @@ async function callbackForward(request, ctx) {
 			body: bodyFromBytes(upstreamBody)
 		});
 	} catch (err) {
-		return apiError(502, `CALLBACK_FORWARD_FAILED`, err instanceof Error ? err.message : String(err));
+		return apiError(502, `WAKE_CALLBACK_FAILED`, err instanceof Error ? err.message : String(err));
 	}
 	let responseBytes = upstream.body ? new Uint8Array(await upstream.arrayBuffer()) : new Uint8Array();
 	if (isClaimRequest && upstream.ok && target.primaryStream) {
@@ -8010,7 +8021,7 @@ async function callbackForward(request, ctx) {
 			epoch
 		});
 		if (upstream.ok && isDoneRequest && target.primaryStream) {
-			serverLog.info(`[callback-forward] done received for stream=${target.primaryStream} consumer=${consumerId}`);
+			serverLog.info(`[wake-callback] done received for stream=${target.primaryStream} consumer=${consumerId}`);
 			const stillOwnsClaim = ctx.runtime.claimWriteTokens.owns(ctx.service, target.primaryStream, consumerId);
 			const entity = await ctx.entityManager.registry.getEntityByStream(target.primaryStream);
 			let entityCleared = false;
@@ -8032,13 +8043,13 @@ async function callbackForward(request, ctx) {
 			if (entity && (entityCleared || stillOwnsClaim)) {
 				await ctx.entityManager.registry.updateStatus(entity.url, entity.status === `stopping` ? `stopped` : `idle`);
 				await ctx.entityBridgeManager.onEntityChanged(entity.url);
-				serverLog.info(`[callback-forward] status updated after done for ${entity.url}`);
-			} else if (!entity) serverLog.warn(`[callback-forward] done received but no entity found for stream=${target.primaryStream}`);
+				serverLog.info(`[wake-callback] status updated after done for ${entity.url}`);
+			} else if (!entity) serverLog.warn(`[wake-callback] done received but no entity found for stream=${target.primaryStream}`);
 			if (stillOwnsClaim) ctx.runtime.claimWriteTokens.clearStream(ctx.service, target.primaryStream);
-			else if (entity) serverLog.info(`[callback-forward] done arrived after in-memory token evicted (stream=${target.primaryStream} consumer=${consumerId})`);
-		} else if (requestBody?.done === true) serverLog.warn(`[callback-forward] done received but skipped: upstream.ok=${upstream.ok} primaryStream=${target.primaryStream ?? `null`} consumer=${consumerId}`);
+			else if (entity) serverLog.info(`[wake-callback] done arrived after in-memory token evicted (stream=${target.primaryStream} consumer=${consumerId})`);
+		} else if (requestBody?.done === true) serverLog.warn(`[wake-callback] done received but skipped: upstream.ok=${upstream.ok} primaryStream=${target.primaryStream ?? `null`} consumer=${consumerId}`);
 	} catch (err) {
-		serverLog.error(`[callback-forward] error processing done for consumer=${consumerId}: ${err instanceof Error ? err.message : String(err)}`);
+		serverLog.error(`[wake-callback] error processing done for consumer=${consumerId}: ${err instanceof Error ? err.message : String(err)}`);
 	}
 	return responseFromUpstream(upstream, responseBytes);
 }
@@ -8047,11 +8058,11 @@ async function mintClaimWriteToken(ctx, streamPath, consumerId) {
 	if (!entity) return void 0;
 	return ctx.runtime.claimWriteTokens.mint(ctx.service, streamPath, consumerId);
 }
-function encodeCallbackForwardBody(service, consumerId, body, routingAdapter) {
-	const payload = encodeCallbackForwardPayload(consumerId, body, (stream) => routingAdapter.toBackendStreamPath(service, stream));
+function encodeWakeCallbackBody(service, consumerId, body, routingAdapter) {
+	const payload = encodeWakeCallbackPayload(consumerId, body, (stream) => routingAdapter.toBackendStreamPath(service, stream));
 	return new TextEncoder().encode(JSON.stringify(payload));
 }
-function encodeCallbackForwardPayload(consumerId, body, mapStream) {
+function encodeWakeCallbackPayload(consumerId, body, mapStream) {
 	if (!body) return {};
 	const generation = body.generation ?? body.epoch;
 	const wakeId = body.wake_id ?? body.wakeId ?? consumerId;

package/dist/index.d.cts

@@ -4158,7 +4158,7 @@ declare class EntityManager {
   private syncManifestFutureSendSchedule;
   private parseEntityUrl;
   /**
-   * Deliver a message to an entity's main stream, with optional input schema
+   * Deliver a message to an entity's main stream, with optional inbox schema
    * validation.
    */
   send(entityUrl: string, req: SendRequest, opts?: {
@@ -4172,8 +4172,8 @@ declare class EntityManager {
   }): Promise<void>;
   deleteInboxMessage(entityUrl: string, key: string): Promise<void>;
   setTag(entityUrl: string, key: string, req: SetTagRequest, token: string): Promise<ElectricAgentsEntity>;
-  removeTag(entityUrl: string, key: string, token: string): Promise<ElectricAgentsEntity>;
-  registerEntitiesSource(tags: Record<string, string>): Promise<{
+  deleteTag(entityUrl: string, key: string, token: string): Promise<ElectricAgentsEntity>;
+  ensureEntitiesMembershipStream(tags: Record<string, string>): Promise<{
     sourceRef: string;
     streamUrl: string;
   }>;
@@ -4263,7 +4263,7 @@ declare class EntityManager {
     status: number;
   } | null>;
   /**
-   * Add new input/output schema keys to an entity type directly in Postgres.
+   * Add new inbox/state schema keys to an entity type directly in Postgres.
    */
   amendSchemas(typeName: string, schemas: {
     inbox_schemas?: Record<string, Record<string, unknown>>;
@@ -4271,7 +4271,7 @@ declare class EntityManager {
   }): Promise<ElectricAgentsEntityType>;
   /**
    * Enrich webhook payload with entity context.
-   * Called by ElectricAgentsServer during webhook forwarding to inject entity context.
+   * Called by ElectricAgentsServer during subscription webhook dispatch to inject entity context.
    */
   enrichPayload(payload: Record<string, unknown>, consumer: {
     primary_stream: string;

package/dist/index.d.ts

@@ -4159,7 +4159,7 @@ declare class EntityManager {
   private syncManifestFutureSendSchedule;
   private parseEntityUrl;
   /**
-   * Deliver a message to an entity's main stream, with optional input schema
+   * Deliver a message to an entity's main stream, with optional inbox schema
    * validation.
    */
   send(entityUrl: string, req: SendRequest, opts?: {
@@ -4173,8 +4173,8 @@ declare class EntityManager {
   }): Promise<void>;
   deleteInboxMessage(entityUrl: string, key: string): Promise<void>;
   setTag(entityUrl: string, key: string, req: SetTagRequest, token: string): Promise<ElectricAgentsEntity>;
-  removeTag(entityUrl: string, key: string, token: string): Promise<ElectricAgentsEntity>;
-  registerEntitiesSource(tags: Record<string, string>): Promise<{
+  deleteTag(entityUrl: string, key: string, token: string): Promise<ElectricAgentsEntity>;
+  ensureEntitiesMembershipStream(tags: Record<string, string>): Promise<{
     sourceRef: string;
     streamUrl: string;
   }>;
@@ -4264,7 +4264,7 @@ declare class EntityManager {
     status: number;
   } | null>;
   /**
-   * Add new input/output schema keys to an entity type directly in Postgres.
+   * Add new inbox/state schema keys to an entity type directly in Postgres.
    */
   amendSchemas(typeName: string, schemas: {
     inbox_schemas?: Record<string, Record<string, unknown>>;
@@ -4272,7 +4272,7 @@ declare class EntityManager {
   }): Promise<ElectricAgentsEntityType>;
   /**
    * Enrich webhook payload with entity context.
-   * Called by ElectricAgentsServer during webhook forwarding to inject entity context.
+   * Called by ElectricAgentsServer during subscription webhook dispatch to inject entity context.
    */
   enrichPayload(payload: Record<string, unknown>, consumer: {
     primary_stream: string;