@electric-ax/agents-server 0.4.7 → 0.4.11

package/dist/entrypoint.js

@@ -4,7 +4,7 @@ import { DurableStreamTestServer } from "@durable-streams/server";
 import { createServer } from "node:http";
 import { createServerAdapter } from "@whatwg-node/server";
 import { Agent } from "undici";
-import { appendPathToUrl, assertTags, buildTagsIndex, createEntityRegistry, createRuntimeHandler, entityStateSchema, getCronStreamPath, getCronStreamPathFromSpec, getEntitiesStreamPath, getNextCronFireAt, getSharedStateStreamPath, manifestChildKey, manifestSharedStateKey, manifestSourceKey, normalizeTags, parseCronStreamPath, resolveCronScheduleSpec, sourceRefForTags, verifyWebhookSignature } from "@electric-ax/agents-runtime";
+import { appendPathToUrl, assertTags, buildEventSourceManifestEntry, buildTagsIndex, createEntityRegistry, createRuntimeHandler, entityStateSchema, eventSourceSubscriptionManifestKey, getCronStreamPath, getCronStreamPathFromSpec, getEntitiesStreamPath, getNextCronFireAt, getSharedStateStreamPath, getWebhookStreamPath, manifestChildKey, manifestSharedStateKey, manifestSourceKey, normalizeTags, parseCronStreamPath, resolveCronScheduleSpec, resolveEventSourceSubscription, sourceRefForTags, verifyWebhookSignature } from "@electric-ax/agents-runtime";
 import fs, { existsSync } from "node:fs";
 import path, { dirname, resolve } from "node:path";
 import { drizzle } from "drizzle-orm/postgres-js";
@@ -446,7 +446,7 @@ const ErrCodeForkWaitTimeout = `FORK_WAIT_TIMEOUT`;
 const ErrCodeEntityPersistFailed = `ENTITY_PERSIST_FAILED`;
 const ErrCodeAgentUiNotFound = `AGENT_UI_NOT_FOUND`;
 const ErrCodeSubscriptionNotFound = `SUBSCRIPTION_NOT_FOUND`;
-const ErrCodeCallbackNotFound = `CALLBACK_NOT_FOUND`;
+const ErrCodeWakeCallbackNotFound = `WAKE_CALLBACK_NOT_FOUND`;
 
 //#endregion
 //#region src/utils/electric-url.ts
@@ -466,7 +466,7 @@ function electricUrlWithPath(electricUrl, path$1) {
 //#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;
 }
@@ -1610,7 +1610,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 {
@@ -1733,20 +1733,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` });
@@ -2668,6 +2654,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` ? getSharedStateStreamPath(manifest.sourceRef) : void 0;
+		if (manifest.sourceType === `webhook`) {
+			if (typeof config?.streamUrl === `string`) return config.streamUrl;
+			if (typeof config?.endpointKey === `string`) return getWebhookStreamPath(config.endpointKey, typeof config.bucket === `string` ? config.bucket : void 0);
+		}
 		return void 0;
 	}
 	if (manifest.kind === `shared-state`) return typeof manifest.id === `string` ? getSharedStateStreamPath(manifest.id) : void 0;
@@ -2954,7 +2944,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 = entityStateSchema.entityCreated.insert({
@@ -3627,7 +3618,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) {
@@ -3715,7 +3706,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);
@@ -3726,7 +3717,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));
 	}
@@ -3848,6 +3839,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 = 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 = eventSourceSubscriptionManifestKey(req.id);
+		const txid = 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.
 	*/
@@ -4126,7 +4146,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);
@@ -4166,7 +4186,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);
@@ -4431,7 +4451,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],
@@ -4450,7 +4470,7 @@ async function linkStreamToTargetSubscription(ctx, target, entity, subscriptionI
 
 //#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;
@@ -4467,7 +4487,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()),
@@ -4476,7 +4496,8 @@ const spawnBodySchema = Type.Object({
 		condition: wakeConditionSchema,
 		debounceMs: Type.Optional(Type.Number()),
 		timeoutMs: Type.Optional(Type.Number()),
-		includeResponse: Type.Optional(Type.Boolean())
+		includeResponse: Type.Optional(Type.Boolean()),
+		manifestKey: Type.Optional(Type.String())
 	}))
 });
 const sendBodySchema = Type.Object({
@@ -4542,10 +4563,24 @@ const scheduleBodySchema = Type.Union([Type.Object({
 	messageType: Type.Optional(Type.String()),
 	from: Type.Optional(Type.String())
 })]);
-const entitiesRegisterBodySchema = Type.Object({ tags: Type.Optional(stringRecordSchema) });
+const subscriptionLifetimeSchema = Type.Union([
+	Type.Object({ kind: Type.Literal(`until_entity_stopped`) }),
+	Type.Object({
+		kind: Type.Literal(`expires_at`),
+		at: Type.String()
+	}),
+	Type.Object({ kind: Type.Literal(`manual`) })
+]);
+const eventSourceSubscriptionBodySchema = Type.Object({
+	sourceKey: Type.String(),
+	bucketKey: Type.Optional(Type.String()),
+	params: Type.Optional(Type.Record(Type.String(), Type.Unknown())),
+	filterKey: Type.Optional(Type.String()),
+	lifetime: Type.Optional(subscriptionLifetimeSchema),
+	reason: Type.Optional(Type.String())
+});
 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);
@@ -4556,9 +4591,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;
@@ -4622,11 +4659,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;
@@ -4665,8 +4697,49 @@ async function deleteSchedule(request, ctx) {
 	const result = await ctx.entityManager.deleteSchedule(entityUrl, { id: decodeURIComponent(request.params.scheduleId) });
 	return 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 = 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: buildEventSourceManifestEntry(resolved)
+	});
+	return 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 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);
@@ -4674,12 +4747,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) {
@@ -4811,17 +4884,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);
@@ -4861,8 +4930,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));
 }
@@ -4872,13 +4941,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`,
@@ -4889,8 +4957,6 @@ function normalizeEntityTypeRequest(parsed) {
 function toPublicEntityType(entityType) {
 	return {
 		...entityType,
-		input_schemas: entityType.inbox_schemas,
-		output_schemas: entityType.state_schemas,
 		revision: entityType.revision
 	};
 }
@@ -4974,13 +5040,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) {
@@ -5319,7 +5407,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: {
@@ -5354,7 +5442,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()),
@@ -5368,7 +5456,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()),
@@ -5379,14 +5467,15 @@ const callbackForwardBodySchema = Type.Object({
 const DS_SUBSCRIPTION_CALLBACK_PREFIX = `ds-subscription:`;
 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) {
@@ -5419,13 +5508,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);
@@ -5482,10 +5588,17 @@ async function registerWake(request, ctx) {
 	await ctx.entityManager.registerWake(opts);
 	return status(204);
 }
-async function webhookForward(request, ctx) {
+async function listEventSources(_request, ctx) {
+	const eventSources = ctx.eventSources ? await ctx.eventSources.listEventSources() : [];
+	return 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);
@@ -5499,7 +5612,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;
@@ -5545,7 +5658,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`) {
@@ -5566,7 +5679,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;
@@ -5603,21 +5716,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;
@@ -5635,14 +5748,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, {
@@ -5651,7 +5764,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) {
@@ -5671,7 +5784,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;
@@ -5693,13 +5806,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);
 }
@@ -5708,11 +5821,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;
@@ -7294,7 +7407,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();
 						}
@@ -8062,6 +8175,8 @@ var ElectricAgentsServer = class {
 			streamClient: this.streamClient,
 			runtime: this.standaloneRuntime.runtime,
 			entityBridgeManager: this.entityBridgeManager,
+			...this.options.eventSources ? { eventSources: this.options.eventSources } : {},
+			...this.options.ensureEventSourceWakeSource ? { ensureEventSourceWakeSource: this.options.ensureEventSourceWakeSource } : {},
 			isShuttingDown: () => this.shuttingDown,
 			mockAgent: this.mockAgentBootstrap ? { runtime: this.mockAgentBootstrap.runtime } : void 0
 		};