@electric-ax/agents-server 0.4.9 → 0.4.11

package/dist/index.js

@@ -422,7 +422,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
@@ -2503,7 +2503,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 = appendPathToUrl(ctx.publicUrl, `/_electric/webhook-forward/${encodeURIComponent(subscriptionId)}`);
+	const forwardUrl = appendPathToUrl(ctx.publicUrl, `/_electric/subscription-webhooks/${encodeURIComponent(subscriptionId)}`);
 	await ensureSubscriptionIncludesStream(ctx, subscriptionId, streamPath, {
 		type: `webhook`,
 		streams: [streamPath],
@@ -3588,7 +3588,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) {
@@ -3676,7 +3676,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);
@@ -3687,7 +3687,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));
 	}
@@ -4116,7 +4116,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);
@@ -4156,7 +4156,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);
@@ -5415,7 +5415,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 && isControlMessage(message) && message.headers.control === `up-to-date`) {
 							settled = true;
 							resolve$1();
 						}
@@ -6202,7 +6202,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;
 }
@@ -6522,7 +6522,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 = appendPathToUrl(ctx.publicUrl, `/_electric/webhook-forward/${encodeURIComponent(subscriptionId)}`);
+		payload.webhook.url = appendPathToUrl(ctx.publicUrl, `/_electric/subscription-webhooks/${encodeURIComponent(subscriptionId)}`);
 	}
 	rewriteSubscriptionBodyForBackend(payload, ctx.service, routingAdapter);
 	return {
@@ -6645,20 +6645,6 @@ async function proxyPassThrough(request, ctx) {
 	}
 }
 
-//#endregion
-//#region src/routing/cron-router.ts
-const cronRegisterBodySchema = Type.Object({
-	expression: Type.String(),
-	timezone: Type.Optional(Type.String())
-});
-const cronRouter = 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 json({ streamUrl: streamPath });
-}
-
 //#endregion
 //#region src/routing/electric-proxy-router.ts
 const electricProxyRouter = Router({ base: `/_electric/electric` });
@@ -6692,7 +6678,7 @@ async function proxyElectric(request, ctx) {
 
 //#endregion
 //#region src/routing/entities-router.ts
-const stringRecordSchema = Type.Record(Type.String(), Type.String());
+const stringRecordSchema$1 = Type.Record(Type.String(), Type.String());
 function writeTokenFromRequest(request) {
 	const electricClaimToken = request.headers.get(`electric-claim-token`)?.trim();
 	if (electricClaimToken) return electricClaimToken;
@@ -6709,7 +6695,7 @@ const wakeConditionSchema = Type.Union([Type.Literal(`runFinished`), Type.Object
 })]);
 const spawnBodySchema = Type.Object({
 	args: Type.Optional(Type.Record(Type.String(), Type.Unknown())),
-	tags: Type.Optional(stringRecordSchema),
+	tags: Type.Optional(stringRecordSchema$1),
 	parent: Type.Optional(Type.String()),
 	dispatch_policy: Type.Optional(dispatchPolicySchema),
 	initialMessage: Type.Optional(Type.Unknown()),
@@ -6801,10 +6787,8 @@ const eventSourceSubscriptionBodySchema = Type.Object({
 	lifetime: Type.Optional(subscriptionLifetimeSchema),
 	reason: Type.Optional(Type.String())
 });
-const entitiesRegisterBodySchema = Type.Object({ tags: Type.Optional(stringRecordSchema) });
 const entitiesRouter = 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);
@@ -6815,7 +6799,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);
@@ -6883,11 +6867,6 @@ async function listEntities({ query }, ctx) {
 	});
 	return 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 json(result);
-}
 async function upsertSchedule(request, ctx) {
 	const principalMutationError = rejectPrincipalEntityMutation(request, `scheduled`);
 	if (principalMutationError) return principalMutationError;
@@ -6968,7 +6947,7 @@ async function deleteEventSourceSubscription(request, ctx) {
 	return 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);
@@ -6976,12 +6955,12 @@ async function setTag(request, ctx) {
 	const updated = await ctx.entityManager.setTag(entityUrl, decodeURIComponent(request.params.tagKey), { value: parsed.value }, token);
 	return 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 json(toPublicEntity(updated));
 }
 async function forkEntity(request, ctx) {
@@ -7113,17 +7092,13 @@ const registerEntityTypeBodySchema = Type.Object({
 	creation_schema: Type.Optional(jsonObjectSchema),
 	inbox_schemas: Type.Optional(schemaMapSchema),
 	state_schemas: Type.Optional(schemaMapSchema),
-	input_schemas: Type.Optional(schemaMapSchema),
-	output_schemas: Type.Optional(schemaMapSchema),
 	serve_endpoint: Type.Optional(Type.String()),
 	default_dispatch_policy: Type.Optional(dispatchPolicySchema)
-});
+}, { additionalProperties: false });
 const amendEntityTypeSchemasBodySchema = Type.Object({
-	input_schemas: Type.Optional(schemaMapSchema),
-	output_schemas: Type.Optional(schemaMapSchema),
 	inbox_schemas: Type.Optional(schemaMapSchema),
 	state_schemas: Type.Optional(schemaMapSchema)
-});
+}, { additionalProperties: false });
 const entityTypesRouter = Router({ base: `/_electric/entity-types` });
 entityTypesRouter.get(`/`, listEntityTypes);
 entityTypesRouter.post(`/`, withSchema(registerEntityTypeBodySchema), registerEntityType);
@@ -7163,8 +7138,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 json(toPublicEntityType(updated));
 }
@@ -7174,13 +7149,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`,
@@ -7191,8 +7165,6 @@ function normalizeEntityTypeRequest(parsed) {
 function toPublicEntityType(entityType) {
 	return {
 		...entityType,
-		input_schemas: entityType.inbox_schemas,
-		output_schemas: entityType.state_schemas,
 		revision: entityType.revision
 	};
 }
@@ -7276,13 +7248,35 @@ function errorMapper(err, req) {
 function rejectIfShuttingDown(req, ctx) {
 	if (!ctx.isShuttingDown()) return void 0;
 	const path$1 = new URL(req.url).pathname;
-	if (!path$1.startsWith(`/_electric/webhook-forward/`)) return void 0;
+	if (!path$1.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 = Type.Record(Type.String(), Type.String());
+const ensureEntitiesMembershipStreamBodySchema = Type.Object({ tags: Type.Optional(stringRecordSchema) });
+const ensureCronStreamBodySchema = Type.Object({
+	expression: Type.String(),
+	timezone: Type.Optional(Type.String())
+});
+const observationsRouter = 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 json(result);
+}
+async function ensureCronStream(request, ctx) {
+	const parsed = routeBody(request);
+	const streamPath = await ctx.entityManager.getOrCreateCronStream(parsed.expression, parsed.timezone);
+	return json({ streamUrl: streamPath });
+}
+
 //#endregion
 //#region src/routing/tenant-stream-paths.ts
 function withLeadingSlash(path$1) {
@@ -7621,7 +7615,7 @@ async function notificationFromClaim(ctx, input) {
 		wakeId: input.claim.wake_id,
 		streamPath: primaryStream,
 		streams: streams$1,
-		callback: appendPathToUrl(ctx.publicUrl, `/_electric/callback-forward/${encodeURIComponent(input.claim.wake_id)}`),
+		callback: appendPathToUrl(ctx.publicUrl, `/_electric/wake-callbacks/${encodeURIComponent(input.claim.wake_id)}`),
 		claimToken: input.claim.token,
 		triggerEvent: `message_received`,
 		entity: {
@@ -7656,7 +7650,7 @@ const wakeRegistrationBodySchema = Type.Object({
 	includeResponse: Type.Optional(Type.Boolean()),
 	manifestKey: Type.Optional(Type.String())
 });
-const webhookForwardBodySchema = Type.Object({
+const subscriptionWebhookBodySchema = Type.Object({
 	subscription_id: Type.Optional(Type.String()),
 	wake_id: Type.Optional(Type.String()),
 	generation: Type.Optional(Type.Number()),
@@ -7670,7 +7664,7 @@ const webhookForwardBodySchema = Type.Object({
 	consumer_id: Type.Optional(Type.String()),
 	callback: Type.Optional(Type.String())
 }, { additionalProperties: true });
-const callbackForwardBodySchema = Type.Object({
+const wakeCallbackBodySchema = Type.Object({
 	epoch: Type.Optional(Type.Number()),
 	generation: Type.Optional(Type.Number()),
 	wakeId: Type.Optional(Type.String()),
@@ -7683,13 +7677,13 @@ const internalRouter = Router({ base: `/_electric` });
 internalRouter.get(`/health`, () => 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(`*`, () => status(404));
 function routeParam(request, name) {
@@ -7722,13 +7716,30 @@ function resolveWebhookSigner(ctx) {
 	return ctx.webhookSigner ?? getDefaultWebhookSigner();
 }
 function durableStreamsWebhookJwksUrl(ctx) {
-	if (!ctx.durableStreamsRouting) return 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: appendPathToUrl(ctx.publicUrl, `/__ds/jwks.json`)
 	}).toString();
 }
+function appendPathToBackendUrl(baseUrl, path$1) {
+	const base = new URL(baseUrl);
+	const pathUrl = new URL(path$1, `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);
@@ -7792,10 +7803,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);
@@ -7809,7 +7820,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;
@@ -7855,7 +7866,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`) {
@@ -7876,7 +7887,7 @@ async function webhookForward(request, ctx) {
 				runningEntityUrl = entity.url;
 			}
 			if (consumerId && callbackUrl) {
-				const callback = appendPathToUrl(ctx.publicUrl, `/_electric/callback-forward/${encodeURIComponent(consumerId)}`);
+				const callback = appendPathToUrl(ctx.publicUrl, `/_electric/wake-callbacks/${encodeURIComponent(consumerId)}`);
 				enriched.callback = callback;
 				if (newWebhook) {
 					enriched.consumerId = newWebhook.wakeId;
@@ -7913,21 +7924,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(and(eq(consumerCallbacks.tenantId, ctx.service), 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;
@@ -7945,14 +7956,14 @@ async function callbackForward(request, ctx) {
 		}
 		return 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 = json(result);
 		} else upstream = await fetch(target.callbackUrl, {
@@ -7961,7 +7972,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) {
@@ -7981,7 +7992,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;
@@ -8003,13 +8014,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);
 }
@@ -8018,11 +8029,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@electric-ax/agents-server",
-  "version": "0.4.9",
+  "version": "0.4.11",
   "description": "Electric Agents entity runtime server",
   "author": "Durable Stream contributors",
   "bin": {
@@ -54,7 +54,7 @@
     "pino-pretty": "^13.0.0",
     "postgres": "^3.4.0",
     "undici": "^7.24.7",
-    "@electric-ax/agents-runtime": "0.3.4"
+    "@electric-ax/agents-runtime": "0.3.5"
   },
   "devDependencies": {
     "@types/node": "^22.19.15",
@@ -65,9 +65,9 @@
     "tsx": "^4.19.0",
     "typescript": "^5.0.0",
     "vitest": "^4.1.0",
-    "@electric-ax/agents": "0.4.8",
-    "@electric-ax/agents-server-conformance-tests": "0.1.7",
-    "@electric-ax/agents-server-ui": "0.4.9"
+    "@electric-ax/agents": "0.4.9",
+    "@electric-ax/agents-server-ui": "0.4.11",
+    "@electric-ax/agents-server-conformance-tests": "0.1.8"
   },
   "files": [
     "dist",

package/src/electric-agents/default-entity-schemas.ts

@@ -1 +1 @@
-export { DEFAULT_OUTPUT_SCHEMAS } from '@electric-ax/agents-runtime'
+export { DEFAULT_STATE_SCHEMAS } from '@electric-ax/agents-runtime'

package/src/electric-agents-types.ts

@@ -457,4 +457,4 @@ export const ErrCodeForkWaitTimeout = `FORK_WAIT_TIMEOUT`
 export const ErrCodeEntityPersistFailed = `ENTITY_PERSIST_FAILED`
 export const ErrCodeAgentUiNotFound = `AGENT_UI_NOT_FOUND`
 export const ErrCodeSubscriptionNotFound = `SUBSCRIPTION_NOT_FOUND`
-export const ErrCodeCallbackNotFound = `CALLBACK_NOT_FOUND`
+export const ErrCodeWakeCallbackNotFound = `WAKE_CALLBACK_NOT_FOUND`

package/src/entity-manager.ts

@@ -1675,7 +1675,7 @@ export class EntityManager {
   // ==========================================================================
 
   /**
-   * 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(
@@ -1888,7 +1888,7 @@ export class EntityManager {
     return updated
   }
 
-  async removeTag(
+  async deleteTag(
     entityUrl: string,
     key: string,
     token: string
@@ -1930,7 +1930,7 @@ export class EntityManager {
     return updated
   }
 
-  async registerEntitiesSource(tags: Record<string, string>): Promise<{
+  async ensureEntitiesMembershipStream(tags: Record<string, string>): Promise<{
     sourceRef: string
     streamUrl: string
   }> {
@@ -2742,7 +2742,7 @@ export class EntityManager {
   // ==========================================================================
 
   /**
-   * 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: string,
@@ -2831,7 +2831,7 @@ export class EntityManager {
 
   /**
    * 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: Record<string, unknown>,

package/src/routing/dispatch-policy.ts

@@ -326,7 +326,7 @@ async function linkStreamToTargetSubscription(
   }
   const forwardUrl = appendPathToUrl(
     ctx.publicUrl,
-    `/_electric/webhook-forward/${encodeURIComponent(subscriptionId)}`
+    `/_electric/subscription-webhooks/${encodeURIComponent(subscriptionId)}`
   )
   await ensureSubscriptionIncludesStream(
     ctx,

package/src/routing/durable-streams-router.ts

@@ -332,7 +332,7 @@ async function rewriteSubscriptionRequestBody(
     targetWebhookUrl = rewriteLoopbackWebhookUrl(payload.webhook.url) ?? null
     payload.webhook.url = appendPathToUrl(
       ctx.publicUrl,
-      `/_electric/webhook-forward/${encodeURIComponent(subscriptionId)}`
+      `/_electric/subscription-webhooks/${encodeURIComponent(subscriptionId)}`
     )
   }
 

package/src/routing/durable-streams-routing-adapter.ts

@@ -13,9 +13,7 @@ export interface DurableStreamsRoutingAdapter {
 
 function appendSearch(target: URL, source: URL): URL {
   source.searchParams.forEach((value, key) => {
-    if (key !== `service`) {
-      target.searchParams.append(key, value)
-    }
+    target.searchParams.append(key, value)
   })
   return target
 }