@electric-ax/agents-server 0.4.7 → 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],
@@ -2653,6 +2653,10 @@ function extractManifestSourceUrl(manifest) {
 		}
 		if (manifest.sourceType === `entities`) return typeof manifest.sourceRef === `string` ? `/_entities/${manifest.sourceRef}` : void 0;
 		if (manifest.sourceType === `db`) return typeof manifest.sourceRef === `string` ? (0, __electric_ax_agents_runtime.getSharedStateStreamPath)(manifest.sourceRef) : void 0;
+		if (manifest.sourceType === `webhook`) {
+			if (typeof config?.streamUrl === `string`) return config.streamUrl;
+			if (typeof config?.endpointKey === `string`) return (0, __electric_ax_agents_runtime.getWebhookStreamPath)(config.endpointKey, typeof config.bucket === `string` ? config.bucket : void 0);
+		}
 		return void 0;
 	}
 	if (manifest.kind === `shared-state`) return typeof manifest.id === `string` ? (0, __electric_ax_agents_runtime.getSharedStateStreamPath)(manifest.id) : void 0;
@@ -2939,7 +2943,8 @@ var EntityManager = class {
 			debounceMs: req.wake.debounceMs,
 			timeoutMs: req.wake.timeoutMs,
 			oneShot: false,
-			includeResponse: req.wake.includeResponse
+			includeResponse: req.wake.includeResponse,
+			manifestKey: req.wake.manifestKey
 		});
 		const contentType = `application/json`;
 		const createdEvent = __electric_ax_agents_runtime.entityStateSchema.entityCreated.insert({
@@ -3612,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) {
@@ -3700,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);
@@ -3711,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));
 	}
@@ -3833,6 +3838,35 @@ var EntityManager = class {
 		await this.writeManifestEntry(entityUrl, manifestKey, `delete`, void 0, { txid });
 		return { txid };
 	}
+	async upsertEventSourceSubscription(entityUrl, req) {
+		const manifestKey = req.subscription.manifestKey;
+		const txid = (0, node_crypto.randomUUID)();
+		await this.writeManifestEntry(entityUrl, manifestKey, `upsert`, req.manifest, { txid });
+		await this.wakeRegistry.unregisterByManifestKey(entityUrl, manifestKey, this.tenantId);
+		await this.wakeRegistry.register({
+			tenantId: this.tenantId,
+			subscriberUrl: entityUrl,
+			sourceUrl: req.subscription.sourceUrl,
+			condition: {
+				on: `change`,
+				collections: [`webhook_event`],
+				ops: [`insert`]
+			},
+			oneShot: false,
+			manifestKey
+		});
+		return {
+			txid,
+			subscription: req.subscription
+		};
+	}
+	async deleteEventSourceSubscription(entityUrl, req) {
+		const manifestKey = (0, __electric_ax_agents_runtime.eventSourceSubscriptionManifestKey)(req.id);
+		const txid = (0, node_crypto.randomUUID)();
+		await this.writeManifestEntry(entityUrl, manifestKey, `delete`, void 0, { txid });
+		await this.wakeRegistry.unregisterByManifestKey(entityUrl, manifestKey, this.tenantId);
+		return { txid };
+	}
 	/**
 	* Register a wake subscription from a subscriber to a source entity.
 	*/
@@ -4111,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);
@@ -4151,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);
@@ -5410,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();
 						}
@@ -6197,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;
 }
@@ -6517,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 {
@@ -6640,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` });
@@ -6687,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;
@@ -6704,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()),
@@ -6713,7 +6733,8 @@ const spawnBodySchema = __sinclair_typebox.Type.Object({
 		condition: wakeConditionSchema,
 		debounceMs: __sinclair_typebox.Type.Optional(__sinclair_typebox.Type.Number()),
 		timeoutMs: __sinclair_typebox.Type.Optional(__sinclair_typebox.Type.Number()),
-		includeResponse: __sinclair_typebox.Type.Optional(__sinclair_typebox.Type.Boolean())
+		includeResponse: __sinclair_typebox.Type.Optional(__sinclair_typebox.Type.Boolean()),
+		manifestKey: __sinclair_typebox.Type.Optional(__sinclair_typebox.Type.String())
 	}))
 });
 const sendBodySchema = __sinclair_typebox.Type.Object({
@@ -6779,10 +6800,24 @@ const scheduleBodySchema = __sinclair_typebox.Type.Union([__sinclair_typebox.Typ
 	messageType: __sinclair_typebox.Type.Optional(__sinclair_typebox.Type.String()),
 	from: __sinclair_typebox.Type.Optional(__sinclair_typebox.Type.String())
 })]);
-const entitiesRegisterBodySchema = __sinclair_typebox.Type.Object({ tags: __sinclair_typebox.Type.Optional(stringRecordSchema) });
+const subscriptionLifetimeSchema = __sinclair_typebox.Type.Union([
+	__sinclair_typebox.Type.Object({ kind: __sinclair_typebox.Type.Literal(`until_entity_stopped`) }),
+	__sinclair_typebox.Type.Object({
+		kind: __sinclair_typebox.Type.Literal(`expires_at`),
+		at: __sinclair_typebox.Type.String()
+	}),
+	__sinclair_typebox.Type.Object({ kind: __sinclair_typebox.Type.Literal(`manual`) })
+]);
+const eventSourceSubscriptionBodySchema = __sinclair_typebox.Type.Object({
+	sourceKey: __sinclair_typebox.Type.String(),
+	bucketKey: __sinclair_typebox.Type.Optional(__sinclair_typebox.Type.String()),
+	params: __sinclair_typebox.Type.Optional(__sinclair_typebox.Type.Record(__sinclair_typebox.Type.String(), __sinclair_typebox.Type.Unknown())),
+	filterKey: __sinclair_typebox.Type.Optional(__sinclair_typebox.Type.String()),
+	lifetime: __sinclair_typebox.Type.Optional(subscriptionLifetimeSchema),
+	reason: __sinclair_typebox.Type.Optional(__sinclair_typebox.Type.String())
+});
 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);
@@ -6793,9 +6828,11 @@ 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);
+entitiesRouter.delete(`/:type/:instanceId/event-source-subscriptions/:subscriptionId`, withExistingEntity, deleteEventSourceSubscription);
 function entityUrlFromSegments(type, instanceId) {
 	if (!type || !instanceId) return null;
 	if (type.startsWith(`_`) || type.includes(`*`) || instanceId.includes(`*`)) return null;
@@ -6859,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;
@@ -6902,8 +6934,49 @@ async function deleteSchedule(request, ctx) {
 	const result = await ctx.entityManager.deleteSchedule(entityUrl, { id: decodeURIComponent(request.params.scheduleId) });
 	return (0, itty_router.json)(result);
 }
+async function upsertEventSourceSubscription(request, ctx) {
+	const principalMutationError = rejectPrincipalEntityMutation(request, `subscribed to event sources`);
+	if (principalMutationError) return principalMutationError;
+	const catalog = ctx.eventSources;
+	if (!catalog) return apiError(404, ErrCodeNotFound, `No event source catalog is configured`);
+	const { entityUrl } = requireExistingEntityRoute(request);
+	const parsed = routeBody(request);
+	const source = await catalog.getEventSource(parsed.sourceKey);
+	if (!source) return apiError(404, ErrCodeNotFound, `Event source "${parsed.sourceKey}" not found`);
+	if (parsed.lifetime?.kind === `expires_at`) {
+		const expiresAt = new Date(parsed.lifetime.at);
+		if (Number.isNaN(expiresAt.getTime())) return apiError(400, ErrCodeInvalidRequest, `Invalid expires_at lifetime timestamp`);
+	}
+	let resolved;
+	try {
+		resolved = (0, __electric_ax_agents_runtime.resolveEventSourceSubscription)({
+			contract: source,
+			entityUrl,
+			request: {
+				...parsed,
+				id: decodeURIComponent(request.params.subscriptionId)
+			},
+			createdBy: `tool`
+		});
+	} catch (error) {
+		return apiError(400, ErrCodeInvalidRequest, error instanceof Error ? error.message : String(error));
+	}
+	await ctx.ensureEventSourceWakeSource?.(resolved.subscription.sourceUrl);
+	const result = await ctx.entityManager.upsertEventSourceSubscription(entityUrl, {
+		subscription: resolved.subscription,
+		manifest: (0, __electric_ax_agents_runtime.buildEventSourceManifestEntry)(resolved)
+	});
+	return (0, itty_router.json)(result);
+}
+async function deleteEventSourceSubscription(request, ctx) {
+	const principalMutationError = rejectPrincipalEntityMutation(request, `unsubscribed from event sources`);
+	if (principalMutationError) return principalMutationError;
+	const { entityUrl } = requireExistingEntityRoute(request);
+	const result = await ctx.entityManager.deleteEventSourceSubscription(entityUrl, { id: decodeURIComponent(request.params.subscriptionId) });
+	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);
@@ -6911,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) {
@@ -7048,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);
@@ -7098,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));
 }
@@ -7109,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`,
@@ -7126,8 +7194,6 @@ function normalizeEntityTypeRequest(parsed) {
 function toPublicEntityType(entityType) {
 	return {
 		...entityType,
-		input_schemas: entityType.inbox_schemas,
-		output_schemas: entityType.state_schemas,
 		revision: entityType.revision
 	};
 }
@@ -7211,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) {
@@ -7556,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: {
@@ -7591,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()),
@@ -7605,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()),
@@ -7616,14 +7704,15 @@ const callbackForwardBodySchema = __sinclair_typebox.Type.Object({
 const DS_SUBSCRIPTION_CALLBACK_PREFIX = `ds-subscription:`;
 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) {
@@ -7656,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);
@@ -7719,10 +7825,17 @@ async function registerWake(request, ctx) {
 	await ctx.entityManager.registerWake(opts);
 	return (0, itty_router.status)(204);
 }
-async function webhookForward(request, ctx) {
+async function listEventSources(_request, ctx) {
+	const eventSources = ctx.eventSources ? await ctx.eventSources.listEventSources() : [];
+	return (0, itty_router.json)({ eventSources: eventSources.filter(isAgentVisibleEventSource) });
+}
+function isAgentVisibleEventSource(source) {
+	return source.agentVisible === true && source.status === `active`;
+}
+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);
@@ -7736,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;
@@ -7782,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`) {
@@ -7803,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;
@@ -7840,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;
@@ -7872,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, {
@@ -7888,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) {
@@ -7908,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;
@@ -7930,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);
 }
@@ -7945,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;