@electric-ax/agents-server-conformance-tests 0.1.7 → 0.1.9

package/dist/index.js

@@ -4,10 +4,30 @@ import { createServer } from "node:http";
 import { Shape, ShapeStream } from "@electric-sql/client";
 import { execFile } from "node:child_process";
 
+//#region src/url.ts
+function appendPathToUrl(baseUrl, path) {
+	const base = new URL(baseUrl);
+	const pathUrl = new URL(path, `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();
+}
+
+//#endregion
 //#region src/electric-agents-dsl.ts
 async function fetchShapeRows(baseUrl, table) {
 	const stream = new ShapeStream({
-		url: `${baseUrl}/_electric/electric/v1/shape`,
+		url: appendPathToUrl(baseUrl, `/_electric/electric/v1/shape`),
 		params: { table },
 		subscribe: false
 	});
@@ -30,10 +50,8 @@ function toServerEntityTypeRegistration(registration) {
 		...registration.metadata_schema && { metadata_schema: registration.metadata_schema },
 		...registration.serve_endpoint && { serve_endpoint: registration.serve_endpoint }
 	};
-	const inboxSchemas = registration.inbox_schemas ?? registration.input_schemas;
-	const stateSchemas = registration.state_schemas ?? registration.output_schemas;
-	if (inboxSchemas) body.inbox_schemas = inboxSchemas;
-	if (stateSchemas) body.state_schemas = stateSchemas;
+	if (registration.inbox_schemas) body.inbox_schemas = registration.inbox_schemas;
+	if (registration.state_schemas) body.state_schemas = registration.state_schemas;
 	return body;
 }
 function normalizeWebhookPayload(body) {
@@ -174,7 +192,7 @@ var ServeEndpointReceiver = class {
 	}
 };
 async function electricAgentsFetch$1(baseUrl, path, opts = {}) {
-	return fetch(`${baseUrl}${routeControlPlanePath$1(path)}`, {
+	return fetch(appendPathToUrl(baseUrl, routeControlPlanePath$1(path)), {
 		...opts,
 		headers: {
 			"content-type": `application/json`,
@@ -193,7 +211,7 @@ function isEntityStreamPath$1(pathname) {
 	return segments.length >= 3 && (lastSegment === `main` || lastSegment === `error`);
 }
 function subscriptionEndpoint$1(baseUrl, id) {
-	return `${baseUrl}/__ds/subscriptions/${encodeURIComponent(id)}`;
+	return appendPathToUrl(baseUrl, `/__ds/subscriptions/${encodeURIComponent(id)}`);
 }
 function subscriptionPattern$1(pattern) {
 	return pattern.replace(/^\/+/, ``);
@@ -353,8 +371,8 @@ var ElectricAgentsScenario = class {
 		this.steps.push({
 			kind: `amendSchemas`,
 			name,
-			input_schemas: schemas.input_schemas,
-			output_schemas: schemas.output_schemas
+			inbox_schemas: schemas.inbox_schemas,
+			state_schemas: schemas.state_schemas
 		});
 		return this;
 	}
@@ -422,7 +440,7 @@ var ElectricAgentsScenario = class {
 			typeName,
 			instanceId,
 			args: opts?.args,
-			code: `SCHEMA_VALIDATION_ERROR`,
+			code: `SCHEMA_VALIDATION_FAILED`,
 			status: 422
 		});
 		return this;
@@ -432,7 +450,7 @@ var ElectricAgentsScenario = class {
 			kind: `expectSendSchemaError`,
 			payload,
 			messageType: opts?.type ?? `default`,
-			code: `SCHEMA_VALIDATION_ERROR`,
+			code: `SCHEMA_VALIDATION_FAILED`,
 			status: 422
 		});
 		return this;
@@ -442,7 +460,7 @@ var ElectricAgentsScenario = class {
 			kind: `expectWriteSchemaError`,
 			payload,
 			eventType: opts?.type ?? `default`,
-			code: `SCHEMA_VALIDATION_ERROR`,
+			code: `SCHEMA_VALIDATION_FAILED`,
 			status: 422
 		});
 		return this;
@@ -671,7 +689,7 @@ async function executeStep(ctx, step) {
 		case `readStream`: {
 			if (!ctx.currentEntityStreams) throw new Error(`No current entity streams`);
 			const streamPath = step.stream === `error` ? ctx.currentEntityStreams.error : ctx.currentEntityStreams.main;
-			const res = await fetch(`${ctx.baseUrl}${streamPath}?offset=0000000000000000_0000000000000000`);
+			const res = await fetch(appendPathToUrl(ctx.baseUrl, `${streamPath}?offset=0000000000000000_0000000000000000`));
 			if (res.status === 200) {
 				const text = await res.text();
 				const messages = text ? JSON.parse(text) : [];
@@ -812,8 +830,8 @@ async function executeStep(ctx, step) {
 		}
 		case `amendSchemas`: {
 			const body = {};
-			if (step.input_schemas) body.inbox_schemas = step.input_schemas;
-			if (step.output_schemas) body.state_schemas = step.output_schemas;
+			if (step.inbox_schemas) body.inbox_schemas = step.inbox_schemas;
+			if (step.state_schemas) body.state_schemas = step.state_schemas;
 			const res = await electricAgentsFetch$1(ctx.baseUrl, `/_electric/entity-types/${step.name}/schemas`, {
 				method: `PATCH`,
 				body: JSON.stringify(body)
@@ -1315,8 +1333,8 @@ function applyElectricAgentsAction(model, action, targetIdx, opts) {
 				entityTypes: [...model.entityTypes, {
 					name: opts?.typeName ?? `prop-type-${typeNum}`,
 					hasCreationSchema: false,
-					hasInputSchemas: false,
-					hasOutputSchemas: false
+					hasInboxSchemas: false,
+					hasStateSchemas: false
 				}]
 			};
 		}
@@ -1474,7 +1492,7 @@ function checkStateProtocolInvariants(events) {
 //#endregion
 //#region src/cli-dsl.ts
 function subscriptionEndpoint(baseUrl, id) {
-	return `${baseUrl}/__ds/subscriptions/${encodeURIComponent(id)}`;
+	return appendPathToUrl(baseUrl, `/__ds/subscriptions/${encodeURIComponent(id)}`);
 }
 function subscriptionPattern(pattern) {
 	return pattern.replace(/^\/+/, ``);
@@ -1623,7 +1641,7 @@ var CliScenario = class {
 		try {
 			for (const step of this.steps) switch (step.kind) {
 				case `setupType`: {
-					const res = await fetch(`${this.baseUrl}/_electric/entity-types`, {
+					const res = await fetch(appendPathToUrl(this.baseUrl, `/_electric/entity-types`), {
 						method: `POST`,
 						headers: { "content-type": `application/json` },
 						body: JSON.stringify(step.registration)
@@ -1752,7 +1770,7 @@ function startNoopReceiver() {
 //#endregion
 //#region src/electric-agents-tests.ts
 async function electricAgentsFetch(baseUrl, path, opts = {}) {
-	return fetch(`${baseUrl}${routeControlPlanePath(path)}`, {
+	return fetch(appendPathToUrl(baseUrl, routeControlPlanePath(path)), {
 		...opts,
 		headers: {
 			"content-type": `application/json`,
@@ -1773,7 +1791,7 @@ function isEntityStreamPath(pathname) {
 async function pollEntityStatus(baseUrl, entityUrl, statuses, timeoutMs = 8e3) {
 	const deadline = Date.now() + timeoutMs;
 	while (Date.now() < deadline) {
-		const res = await fetch(`${baseUrl}${routeControlPlanePath(entityUrl)}`);
+		const res = await fetch(appendPathToUrl(baseUrl, routeControlPlanePath(entityUrl)));
 		expect(res.status).toBe(200);
 		const entity = await res.json();
 		if (statuses.includes(String(entity.status))) return entity;
@@ -1788,13 +1806,13 @@ function runElectricAgentsConformanceTests(config) {
 			description: `Test entity type for spawn`,
 			creation_schema: { type: `object` }
 		}).spawn(`spawn-test-agent`, `entity-1`).expectStatus(`running`).custom(async (ctx) => {
-			const mainRes = await fetch(`${ctx.baseUrl}${ctx.currentEntityStreams.main}`, { method: `HEAD` });
+			const mainRes = await fetch(appendPathToUrl(ctx.baseUrl, ctx.currentEntityStreams.main), { method: `HEAD` });
 			expect(mainRes.status).toBe(200);
-			const errorRes = await fetch(`${ctx.baseUrl}${ctx.currentEntityStreams.error}`, { method: `HEAD` });
+			const errorRes = await fetch(appendPathToUrl(ctx.baseUrl, ctx.currentEntityStreams.error), { method: `HEAD` });
 			expect(errorRes.status).toBe(200);
 		}).run());
 		test(`spawn at unregistered type returns UNKNOWN_ENTITY_TYPE`, () => electricAgents(config.baseUrl).custom(async (ctx) => {
-			const res = await fetch(`${ctx.baseUrl}${routeControlPlanePath(`/unregistered/entity-1`)}`, {
+			const res = await fetch(appendPathToUrl(ctx.baseUrl, routeControlPlanePath(`/unregistered/entity-1`)), {
 				method: `PUT`,
 				headers: { "content-type": `application/json` },
 				body: JSON.stringify({})
@@ -1836,7 +1854,7 @@ function runElectricAgentsConformanceTests(config) {
 			creation_schema: { type: `object` }
 		}).spawn(`webhook-ctx-agent`, `entity-1`).send({ ping: true }).expectWebhook().expectEntityContext({ type: `webhook-ctx-agent` }).respondDone().run());
 		test(`send to nonexistent entity returns 404`, () => electricAgents(config.baseUrl).custom(async (ctx) => {
-			const res = await fetch(`${ctx.baseUrl}${routeControlPlanePath(`/nonexistent-type/nonexistent-id/send`)}`, {
+			const res = await fetch(appendPathToUrl(ctx.baseUrl, routeControlPlanePath(`/nonexistent-type/nonexistent-id/send`)), {
 				method: `POST`,
 				headers: { "content-type": `application/json` },
 				body: JSON.stringify({ payload: {} })
@@ -1962,12 +1980,12 @@ function runElectricAgentsConformanceTests(config) {
 				type: `object`,
 				properties: { name: { type: `string` } }
 			},
-			input_schemas: { query: {
+			inbox_schemas: { query: {
 				type: `object`,
 				properties: { text: { type: `string` } },
 				required: [`text`]
 			} },
-			output_schemas: { result: {
+			state_schemas: { result: {
 				type: `object`,
 				properties: { answer: { type: `string` } }
 			} }
@@ -2003,7 +2021,7 @@ function runElectricAgentsConformanceTests(config) {
 					type: `object`,
 					properties: { x: { type: `number` } }
 				},
-				input_schemas: { ping: {
+				inbox_schemas: { ping: {
 					type: `object`,
 					properties: { msg: { type: `string` } }
 				} }
@@ -2029,7 +2047,7 @@ function runElectricAgentsConformanceTests(config) {
 				description: `First registration`,
 				creation_schema: { type: `object` }
 			}).custom(async (ctx) => {
-				const res = await fetch(`${ctx.baseUrl}/_electric/entity-types`, {
+				const res = await fetch(appendPathToUrl(ctx.baseUrl, `/_electric/entity-types`), {
 					method: `POST`,
 					headers: { "content-type": `application/json` },
 					body: JSON.stringify({
@@ -2046,7 +2064,7 @@ function runElectricAgentsConformanceTests(config) {
 			}).run();
 		});
 		test(`register rejects missing required fields`, () => electricAgents(config.baseUrl).custom(async (ctx) => {
-			const res = await fetch(`${ctx.baseUrl}/_electric/entity-types`, {
+			const res = await fetch(appendPathToUrl(ctx.baseUrl, `/_electric/entity-types`), {
 				method: `POST`,
 				headers: { "content-type": `application/json` },
 				body: JSON.stringify({})
@@ -2091,7 +2109,7 @@ function runElectricAgentsConformanceTests(config) {
 			}).expectSpawnSchemaError(typeName, `bad-entity-1`, { args: { invalid: true } }).run();
 		});
 		test(`typed spawn at unregistered type returns UNKNOWN_ENTITY_TYPE (C9)`, () => electricAgents(config.baseUrl).custom(async (ctx) => {
-			const res = await fetch(`${ctx.baseUrl}${routeControlPlanePath(`/nonexistent/should-fail`)}`, {
+			const res = await fetch(appendPathToUrl(ctx.baseUrl, routeControlPlanePath(`/nonexistent/should-fail`)), {
 				method: `PUT`,
 				headers: { "content-type": `application/json` },
 				body: JSON.stringify({})
@@ -2110,7 +2128,7 @@ function runElectricAgentsConformanceTests(config) {
 			}).spawn(typeName, `parent-entity`).custom(async (ctx) => {
 				parentUrl = ctx.currentEntityUrl;
 			}).custom(async (ctx) => {
-				const res = await fetch(`${ctx.baseUrl}${routeControlPlanePath(`/${typeName}/child-entity`)}`, {
+				const res = await fetch(appendPathToUrl(ctx.baseUrl, routeControlPlanePath(`/${typeName}/child-entity`)), {
 					method: `PUT`,
 					headers: { "content-type": `application/json` },
 					body: JSON.stringify({ parent: parentUrl })
@@ -2137,7 +2155,7 @@ function runElectricAgentsConformanceTests(config) {
 				description: `Type for orphan spawn test`,
 				creation_schema: { type: `object` }
 			}).custom(async (ctx) => {
-				const res = await fetch(`${ctx.baseUrl}${routeControlPlanePath(`/${typeName}/orphan-entity`)}`, {
+				const res = await fetch(appendPathToUrl(ctx.baseUrl, routeControlPlanePath(`/${typeName}/orphan-entity`)), {
 					method: `PUT`,
 					headers: { "content-type": `application/json` },
 					body: JSON.stringify({ parent: `/nonexistent/parent` })
@@ -2158,7 +2176,7 @@ function runElectricAgentsConformanceTests(config) {
 				color: `blue`,
 				count: `42`
 			} }).custom(async (ctx) => {
-				const res = await fetch(`${ctx.baseUrl}${routeControlPlanePath(ctx.currentEntityUrl)}`);
+				const res = await fetch(appendPathToUrl(ctx.baseUrl, routeControlPlanePath(ctx.currentEntityUrl)));
 				const entity = await res.json();
 				const tags = entity.tags;
 				expect(tags.color).toBe(`blue`);
@@ -2172,7 +2190,7 @@ function runElectricAgentsConformanceTests(config) {
 				name: typeName,
 				description: `Type with string-only tags`
 			}).custom(async (ctx) => {
-				const res = await fetch(`${ctx.baseUrl}${routeControlPlanePath(`/${typeName}/should-fail`)}`, {
+				const res = await fetch(appendPathToUrl(ctx.baseUrl, routeControlPlanePath(`/${typeName}/should-fail`)), {
 					method: `PUT`,
 					headers: { "content-type": `application/json` },
 					body: JSON.stringify({ tags: { wrong: 123 } })
@@ -2186,20 +2204,20 @@ function runElectricAgentsConformanceTests(config) {
 				name: typeName,
 				description: `Type with default empty tags`
 			}).spawn(typeName, `entity-1`).custom(async (ctx) => {
-				const res = await fetch(`${ctx.baseUrl}${routeControlPlanePath(ctx.currentEntityUrl)}`);
+				const res = await fetch(appendPathToUrl(ctx.baseUrl, routeControlPlanePath(ctx.currentEntityUrl)));
 				const entity = await res.json();
 				expect(entity.tags).toEqual({});
 			}).run();
 		});
 	});
 	describe(`Electric Agents Schema Validation Gates`, () => {
-		test(`send validates input_schemas (C11)`, () => {
+		test(`send validates inbox_schemas (C11)`, () => {
 			const typeName = `send-schema-valid-${Date.now()}`;
 			return electricAgents(config.baseUrl).subscription(`/${typeName}/**`, `send-schema-sub`).registerType({
 				name: typeName,
-				description: `Type with input schemas`,
+				description: `Type with inbox schemas`,
 				creation_schema: { type: `object` },
-				input_schemas: { query: {
+				inbox_schemas: { query: {
 					type: `object`,
 					properties: { text: { type: `string` } },
 					required: [`text`]
@@ -2210,9 +2228,9 @@ function runElectricAgentsConformanceTests(config) {
 			const typeName = `send-schema-inv-${Date.now()}`;
 			return electricAgents(config.baseUrl).subscription(`/${typeName}/**`, `send-schema-inv-sub`).registerType({
 				name: typeName,
-				description: `Type with strict input schemas`,
+				description: `Type with strict inbox schemas`,
 				creation_schema: { type: `object` },
-				input_schemas: { query: {
+				inbox_schemas: { query: {
 					type: `object`,
 					properties: { text: { type: `string` } },
 					required: [`text`]
@@ -2223,30 +2241,30 @@ function runElectricAgentsConformanceTests(config) {
 			const typeName = `send-unknown-type-${Date.now()}`;
 			return electricAgents(config.baseUrl).subscription(`/${typeName}/**`, `send-unknown-sub`).registerType({
 				name: typeName,
-				description: `Type with defined input schemas`,
+				description: `Type with defined inbox schemas`,
 				creation_schema: { type: `object` },
-				input_schemas: { query: {
+				inbox_schemas: { query: {
 					type: `object`,
 					properties: { text: { type: `string` } },
 					required: [`text`]
 				} }
 			}).spawn(typeName, `entity-1`).expectSendUnknownType({ text: `hi` }, { type: `unknown_type` }).run();
 		});
-		test(`send without type when no input_schemas accepts any`, () => {
+		test(`send without type when no inbox_schemas accepts any`, () => {
 			const typeName = `send-no-schemas-${Date.now()}`;
 			return electricAgents(config.baseUrl).subscription(`/${typeName}/**`, `send-noschema-sub`).registerType({
 				name: typeName,
-				description: `Type without input schemas`,
+				description: `Type without inbox schemas`,
 				creation_schema: { type: `object` }
 			}).spawn(typeName, `entity-1`).send({ anything: `goes` }).expectWebhook().respondDone().run();
 		});
-		test(`send with empty input_schemas rejects all`, () => {
+		test(`send with empty inbox_schemas rejects all`, () => {
 			const typeName = `send-empty-schemas-${Date.now()}`;
 			return electricAgents(config.baseUrl).subscription(`/${typeName}/**`, `send-empty-sub`).registerType({
 				name: typeName,
-				description: `Type with empty input schemas`,
+				description: `Type with empty inbox schemas`,
 				creation_schema: { type: `object` },
-				input_schemas: {}
+				inbox_schemas: {}
 			}).spawn(typeName, `entity-1`).expectSendUnknownType({ text: `anything` }, { type: `some_type` }).run();
 		});
 		test.skip(`write appends event to entity stream`, () => {
@@ -2255,7 +2273,7 @@ function runElectricAgentsConformanceTests(config) {
 				name: typeName,
 				description: `Type for write test`,
 				creation_schema: { type: `object` },
-				output_schemas: { research_result: {
+				state_schemas: { research_result: {
 					type: `object`,
 					properties: { findings: {
 						type: `array`,
@@ -2264,13 +2282,13 @@ function runElectricAgentsConformanceTests(config) {
 				} }
 			}).spawn(typeName, `entity-1`).write({ findings: [`test`] }, { type: `research_result` }).readStream().expectStreamContains(`research_result`).run();
 		});
-		test.skip(`write validates output_schemas (C12)`, () => {
+		test.skip(`write validates state_schemas (C12)`, () => {
 			const typeName = `write-schema-inv-${Date.now()}`;
 			return electricAgents(config.baseUrl).subscription(`/${typeName}/**`, `write-schema-sub`).registerType({
 				name: typeName,
-				description: `Type with strict output schemas`,
+				description: `Type with strict state schemas`,
 				creation_schema: { type: `object` },
-				output_schemas: { result: {
+				state_schemas: { result: {
 					type: `object`,
 					properties: { value: { type: `number` } },
 					required: [`value`]
@@ -2281,19 +2299,19 @@ function runElectricAgentsConformanceTests(config) {
 			const typeName = `write-unknown-type-${Date.now()}`;
 			return electricAgents(config.baseUrl).subscription(`/${typeName}/**`, `write-unknown-sub`).registerType({
 				name: typeName,
-				description: `Type with defined output schemas`,
+				description: `Type with defined state schemas`,
 				creation_schema: { type: `object` },
-				output_schemas: { result: {
+				state_schemas: { result: {
 					type: `object`,
 					properties: { value: { type: `number` } }
 				} }
 			}).spawn(typeName, `entity-1`).expectWriteUnknownType({ data: `test` }, { type: `unknown_event` }).run();
 		});
-		test.skip(`write without type when no output_schemas accepts any`, () => {
+		test.skip(`write without type when no state_schemas accepts any`, () => {
 			const typeName = `write-no-schemas-${Date.now()}`;
 			return electricAgents(config.baseUrl).subscription(`/${typeName}/**`, `write-noschema-sub`).registerType({
 				name: typeName,
-				description: `Type without output schemas`,
+				description: `Type without state schemas`,
 				creation_schema: { type: `object` }
 			}).spawn(typeName, `entity-1`).write({ anything: `goes` }).run();
 		});
@@ -2306,7 +2324,7 @@ function runElectricAgentsConformanceTests(config) {
 			}).spawn(typeName, `entity-1`).kill().custom(async (ctx) => {
 				const writeHeaders = { "content-type": `application/json` };
 				if (ctx.currentWriteToken) writeHeaders[`authorization`] = `Bearer ${ctx.currentWriteToken}`;
-				const res = await fetch(`${ctx.baseUrl}${ctx.currentEntityUrl}/main`, {
+				const res = await fetch(appendPathToUrl(ctx.baseUrl, `${ctx.currentEntityUrl}/main`), {
 					method: `POST`,
 					headers: writeHeaders,
 					body: JSON.stringify({
@@ -2360,7 +2378,7 @@ function runElectricAgentsConformanceTests(config) {
 			}).spawn(typeName, `entity-1`).custom(async (ctx) => {
 				const tagHeaders = { "content-type": `application/json` };
 				if (ctx.currentWriteToken) tagHeaders[`authorization`] = `Bearer ${ctx.currentWriteToken}`;
-				const res = await fetch(`${ctx.baseUrl}${routeControlPlanePath(`${ctx.currentEntityUrl}/tags/owner`)}`, {
+				const res = await fetch(appendPathToUrl(ctx.baseUrl, routeControlPlanePath(`${ctx.currentEntityUrl}/tags/owner`)), {
 					method: `POST`,
 					headers: tagHeaders,
 					body: JSON.stringify({ value: 123 })
@@ -2380,7 +2398,7 @@ function runElectricAgentsConformanceTests(config) {
 			}).custom(async (ctx) => {
 				const tagHeaders = {};
 				if (ctx.currentWriteToken) tagHeaders.authorization = `Bearer ${ctx.currentWriteToken}`;
-				const res = await fetch(`${ctx.baseUrl}${routeControlPlanePath(`${ctx.currentEntityUrl}/tags/priority`)}`, {
+				const res = await fetch(appendPathToUrl(ctx.baseUrl, routeControlPlanePath(`${ctx.currentEntityUrl}/tags/priority`)), {
 					method: `DELETE`,
 					headers: tagHeaders
 				});
@@ -2413,12 +2431,12 @@ function runElectricAgentsConformanceTests(config) {
 				name: typeName,
 				description: `Type for schema amendment`,
 				creation_schema: { type: `object` },
-				input_schemas: { query: {
+				inbox_schemas: { query: {
 					type: `object`,
 					properties: { text: { type: `string` } },
 					required: [`text`]
 				} }
-			}).amendSchemas(typeName, { input_schemas: { command: {
+			}).amendSchemas(typeName, { inbox_schemas: { command: {
 				type: `object`,
 				properties: { action: { type: `string` } },
 				required: [`action`]
@@ -2430,13 +2448,13 @@ function runElectricAgentsConformanceTests(config) {
 				name: typeName,
 				description: `Type for schema conflict test`,
 				creation_schema: { type: `object` },
-				input_schemas: { query: {
+				inbox_schemas: { query: {
 					type: `object`,
 					properties: { text: { type: `string` } },
 					required: [`text`]
 				} }
 			}).custom(async (ctx) => {
-				const res = await fetch(`${ctx.baseUrl}/_electric/entity-types/${typeName}/schemas`, {
+				const res = await fetch(appendPathToUrl(ctx.baseUrl, `/_electric/entity-types/${typeName}/schemas`), {
 					method: `PATCH`,
 					headers: { "content-type": `application/json` },
 					body: JSON.stringify({ inbox_schemas: { query: {
@@ -2453,13 +2471,13 @@ function runElectricAgentsConformanceTests(config) {
 				name: typeName,
 				description: `Type for revision pinning test`,
 				creation_schema: { type: `object` },
-				input_schemas: { query: {
+				inbox_schemas: { query: {
 					type: `object`,
 					properties: { text: { type: `string` } },
 					required: [`text`]
 				} }
 			}).spawn(typeName, `entity-1`).custom(async (ctx) => {
-				const res = await fetch(`${ctx.baseUrl}/_electric/entity-types/${typeName}/schemas`, {
+				const res = await fetch(appendPathToUrl(ctx.baseUrl, `/_electric/entity-types/${typeName}/schemas`), {
 					method: `PATCH`,
 					headers: { "content-type": `application/json` },
 					body: JSON.stringify({ inbox_schemas: { new_command: {
@@ -2469,7 +2487,7 @@ function runElectricAgentsConformanceTests(config) {
 				});
 				expect(res.status).toBe(200);
 			}).custom(async (ctx) => {
-				const res = await fetch(`${ctx.baseUrl}${routeControlPlanePath(`${ctx.currentEntityUrl}/send`)}`, {
+				const res = await fetch(appendPathToUrl(ctx.baseUrl, routeControlPlanePath(`${ctx.currentEntityUrl}/send`)), {
 					method: `POST`,
 					headers: { "content-type": `application/json` },
 					body: JSON.stringify({
@@ -2500,7 +2518,7 @@ function runElectricAgentsConformanceTests(config) {
 			};
 			await receiver.start(manifest);
 			try {
-				const res = await fetch(`${ctx.baseUrl}/_electric/entity-types`, {
+				const res = await fetch(appendPathToUrl(ctx.baseUrl, `/_electric/entity-types`), {
 					method: `POST`,
 					headers: { "content-type": `application/json` },
 					body: JSON.stringify({
@@ -3078,7 +3096,7 @@ function runElectricAgentsConformanceTests(config) {
 				name: `rev-multi-agent-${id}`,
 				description: `Test multi-revision pinning`,
 				creation_schema: { type: `object` },
-				input_schemas: { greet: {
+				inbox_schemas: { greet: {
 					type: `object`,
 					properties: { name: { type: `string` } },
 					required: [`name`]
@@ -3119,7 +3137,7 @@ function runElectricAgentsConformanceTests(config) {
 			}).deleteType(`amend-del-agent-${id}`).custom(async (ctx) => {
 				const res = await electricAgentsFetch(ctx.baseUrl, `/_electric/entity-types/amend-del-agent-${id}/schemas`, {
 					method: `PATCH`,
-					body: JSON.stringify({ input_schemas: { msg: { type: `object` } } })
+					body: JSON.stringify({ inbox_schemas: { msg: { type: `object` } } })
 				});
 				expect(res.status).toBe(404);
 			}).run();
@@ -3195,7 +3213,7 @@ function runElectricAgentsConformanceTests(config) {
 				description: `Test write without token`,
 				creation_schema: { type: `object` }
 			}).spawn(`auth-notoken-agent-${id}`, `entity-1`).custom(async (ctx) => {
-				const res = await fetch(`${ctx.baseUrl}${ctx.currentEntityUrl}/main`, {
+				const res = await fetch(appendPathToUrl(ctx.baseUrl, `${ctx.currentEntityUrl}/main`), {
 					method: `POST`,
 					headers: { "content-type": `application/json` },
 					body: JSON.stringify({
@@ -3215,7 +3233,7 @@ function runElectricAgentsConformanceTests(config) {
 				description: `Test write with wrong token`,
 				creation_schema: { type: `object` }
 			}).spawn(`auth-wrongtoken-agent-${id}`, `entity-1`).custom(async (ctx) => {
-				const res = await fetch(`${ctx.baseUrl}${ctx.currentEntityUrl}/main`, {
+				const res = await fetch(appendPathToUrl(ctx.baseUrl, `${ctx.currentEntityUrl}/main`), {
 					method: `POST`,
 					headers: {
 						"content-type": `application/json`,
@@ -3248,7 +3266,7 @@ function runElectricAgentsConformanceTests(config) {
 				description: `Test tag update without token`,
 				creation_schema: { type: `object` }
 			}).spawn(`auth-meta-notoken-agent-${id}`, `entity-1`).custom(async (ctx) => {
-				const res = await fetch(`${ctx.baseUrl}${routeControlPlanePath(`${ctx.currentEntityUrl}/tags/key`)}`, {
+				const res = await fetch(appendPathToUrl(ctx.baseUrl, routeControlPlanePath(`${ctx.currentEntityUrl}/tags/key`)), {
 					method: `POST`,
 					headers: { "content-type": `application/json` },
 					body: JSON.stringify({ value: `value` })
@@ -3273,7 +3291,7 @@ function runElectricAgentsConformanceTests(config) {
 				description: `Test send without auth`,
 				creation_schema: { type: `object` }
 			}).spawn(`auth-send-noauth-agent-${id}`, `entity-1`).custom(async (ctx) => {
-				const res = await fetch(`${ctx.baseUrl}${routeControlPlanePath(`${ctx.currentEntityUrl}/send`)}`, {
+				const res = await fetch(appendPathToUrl(ctx.baseUrl, routeControlPlanePath(`${ctx.currentEntityUrl}/send`)), {
 					method: `POST`,
 					headers: { "content-type": `application/json` },
 					body: JSON.stringify({ payload: `hi` })
@@ -3288,7 +3306,7 @@ function runElectricAgentsConformanceTests(config) {
 				description: `Test GET does not leak write_token`,
 				creation_schema: { type: `object` }
 			}).spawn(`auth-noleak-agent-${id}`, `entity-1`).custom(async (ctx) => {
-				const res = await fetch(`${ctx.baseUrl}${routeControlPlanePath(ctx.currentEntityUrl)}`);
+				const res = await fetch(appendPathToUrl(ctx.baseUrl, routeControlPlanePath(ctx.currentEntityUrl)));
 				expect(res.status).toBe(200);
 				const entity = await res.json();
 				expect(entity.write_token).toBeUndefined();
@@ -3358,7 +3376,7 @@ function runCliConformanceTests(config) {
 				name: `cli-spawn-type`,
 				description: `Type for CLI spawn test`
 			}).setupSubscription(`/cli-spawn-type/**`, `cli-spawn-sub`).exec(`spawn`, `/cli-spawn-type/${id}`).expectExitCode(0).expectStdout(/Spawned/).verifyApi(async (baseUrl) => {
-				const res = await fetch(`${baseUrl}${routeControlPlanePath(`/cli-spawn-type/${id}`)}`);
+				const res = await fetch(appendPathToUrl(baseUrl, routeControlPlanePath(`/cli-spawn-type/${id}`)));
 				expect(res.status).toBe(200);
 				const entity = await res.json();
 				expect([`running`, `idle`]).toContain(entity.status);
@@ -3401,11 +3419,11 @@ function runCliConformanceTests(config) {
 				name: `cli-send-type`,
 				description: `Type for CLI send test`
 			}).setupSubscription(`/cli-send-type/**`, `cli-send-sub`).exec(`spawn`, `/cli-send-type/${id}`).expectExitCode(0).exec(`send`, `/cli-send-type/${id}`, `hello world`).expectExitCode(0).expectStdout(/Message sent/).verifyApi(async (baseUrl) => {
-				const res = await fetch(`${baseUrl}${routeControlPlanePath(`/cli-send-type/${id}`)}`);
+				const res = await fetch(appendPathToUrl(baseUrl, routeControlPlanePath(`/cli-send-type/${id}`)));
 				expect(res.status).toBe(200);
 				const entity = await res.json();
 				const streams = entity.streams;
-				const streamRes = await fetch(`${baseUrl}${streams.main}?offset=0000000000000000_0000000000000000`);
+				const streamRes = await fetch(appendPathToUrl(baseUrl, `${streams.main}?offset=0000000000000000_0000000000000000`));
 				const events = await streamRes.json();
 				expect(events.length).toBeGreaterThanOrEqual(1);
 				const msgEvent = events.find((e) => e.type === `inbox`);
@@ -3425,7 +3443,7 @@ function runCliConformanceTests(config) {
 				name: `cli-inspect-etype`,
 				description: `Type for CLI inspect test`
 			}).setupSubscription(`/cli-inspect-etype/**`, `cli-inspect-sub`).exec(`spawn`, `/cli-inspect-etype/${id}`).expectExitCode(0).exec(`inspect`, `/cli-inspect-etype/${id}`).expectExitCode(0).expectStdout(/running|idle/).verifyApi(async (baseUrl) => {
-				const res = await fetch(`${baseUrl}${routeControlPlanePath(`/cli-inspect-etype/${id}`)}`);
+				const res = await fetch(appendPathToUrl(baseUrl, routeControlPlanePath(`/cli-inspect-etype/${id}`)));
 				expect(res.status).toBe(200);
 				const entity = await res.json();
 				expect([`running`, `idle`]).toContain(entity.status);
@@ -3457,7 +3475,7 @@ function runCliConformanceTests(config) {
 				name: `cli-lifecycle-type`,
 				description: `Type for full lifecycle test`
 			}).setupSubscription(`/cli-lifecycle-type/**`, `cli-lifecycle-sub`).exec(`spawn`, `/cli-lifecycle-type/${id}`).expectExitCode(0).expectStdout(/Spawned/).verifyApi(async (baseUrl) => {
-				const res = await fetch(`${baseUrl}${routeControlPlanePath(`/cli-lifecycle-type/${id}`)}`);
+				const res = await fetch(appendPathToUrl(baseUrl, routeControlPlanePath(`/cli-lifecycle-type/${id}`)));
 				expect(res.status, `entity should exist after spawn`).toBe(200);
 				const entity = await res.json();
 				expect([`running`, `idle`]).toContain(entity.status);
@@ -3488,7 +3506,7 @@ function runCliConformanceTests(config) {
 }
 function runMockAgentTests(config) {
 	async function spawnEntity(baseUrl, typeName, instanceId) {
-		const res = await fetch(`${baseUrl}${routeControlPlanePath(`/${encodeURIComponent(typeName)}/${encodeURIComponent(instanceId)}`)}`, {
+		const res = await fetch(appendPathToUrl(baseUrl, routeControlPlanePath(`/${encodeURIComponent(typeName)}/${encodeURIComponent(instanceId)}`)), {
 			method: `PUT`,
 			headers: { "content-type": `application/json` },
 			body: JSON.stringify({})
@@ -3497,7 +3515,7 @@ function runMockAgentTests(config) {
 		return await res.json();
 	}
 	async function sendMessage(baseUrl, entityUrl, text) {
-		const res = await fetch(`${baseUrl}${routeControlPlanePath(`${entityUrl}/send`)}`, {
+		const res = await fetch(appendPathToUrl(baseUrl, routeControlPlanePath(`${entityUrl}/send`)), {
 			method: `POST`,
 			headers: { "content-type": `application/json` },
 			body: JSON.stringify({ payload: { text } })
@@ -3507,11 +3525,11 @@ function runMockAgentTests(config) {
 	async function pollForAgentResponse(baseUrl, entityUrl, timeoutMs = 1e4) {
 		const start = Date.now();
 		while (Date.now() - start < timeoutMs) {
-			const entityRes = await fetch(`${baseUrl}${routeControlPlanePath(entityUrl)}`);
+			const entityRes = await fetch(appendPathToUrl(baseUrl, routeControlPlanePath(entityUrl)));
 			if (!entityRes.ok) throw new Error(`Entity ${entityUrl} not found`);
 			const entity = await entityRes.json();
 			const streams = entity.streams;
-			const streamRes = await fetch(`${baseUrl}${streams.main}?offset=0000000000000000_0000000000000000`);
+			const streamRes = await fetch(appendPathToUrl(baseUrl, `${streams.main}?offset=0000000000000000_0000000000000000`));
 			const events = await streamRes.json();
 			const hasRunComplete = events.some((e) => e.type === `run` && e.headers?.operation === `update`);
 			if (hasRunComplete) return events;
@@ -3564,11 +3582,11 @@ function runMockAgentCliTests(config) {
 		test(`spawn → send → agent responds with State Protocol events`, async () => {
 			const id = `cli-mock-${Date.now()}`;
 			await cliTest(config.baseUrl, config.cliBin).exec(`spawn`, `/chat/${id}`).expectExitCode(0).expectStdout(/Spawned/).exec(`send`, `/chat/${id}`, `hello from CLI`).expectExitCode(0).expectStdout(/Message sent/).wait(3e3).verifyApi(async (baseUrl) => {
-				const res = await fetch(`${baseUrl}${routeControlPlanePath(`/chat/${id}`)}`);
+				const res = await fetch(appendPathToUrl(baseUrl, routeControlPlanePath(`/chat/${id}`)));
 				expect(res.status, `entity should exist`).toBe(200);
 				const entity = await res.json();
 				const streams = entity.streams;
-				const streamRes = await fetch(`${baseUrl}${streams.main}?offset=0000000000000000_0000000000000000`);
+				const streamRes = await fetch(appendPathToUrl(baseUrl, `${streams.main}?offset=0000000000000000_0000000000000000`));
 				const events = await streamRes.json();
 				expect(events.some((e) => e.type === `run`), `stream should contain run events from agent`).toBe(true);
 				expect(events.some((e) => e.type === `text`), `stream should contain text events from agent`).toBe(true);
@@ -3578,11 +3596,11 @@ function runMockAgentCliTests(config) {
 		test(`inspect shows entity after mock agent processes message`, async () => {
 			const id = `cli-inspect-mock-${Date.now()}`;
 			await cliTest(config.baseUrl, config.cliBin).exec(`spawn`, `/chat/${id}`).expectExitCode(0).exec(`send`, `/chat/${id}`, `test message`).expectExitCode(0).wait(3e3).exec(`inspect`, `/chat/${id}`).expectExitCode(0).expectStdout(/running|idle/).verifyApi(async (baseUrl) => {
-				const res = await fetch(`${baseUrl}${routeControlPlanePath(`/chat/${id}`)}`);
+				const res = await fetch(appendPathToUrl(baseUrl, routeControlPlanePath(`/chat/${id}`)));
 				expect(res.status).toBe(200);
 				const entity = await res.json();
 				const streams = entity.streams;
-				const streamRes = await fetch(`${baseUrl}${streams.main}?offset=0000000000000000_0000000000000000`);
+				const streamRes = await fetch(appendPathToUrl(baseUrl, `${streams.main}?offset=0000000000000000_0000000000000000`));
 				const events = await streamRes.json();
 				const hasRunComplete = events.some((e) => e.type === `run` && e.headers?.operation === `update`);
 				expect(hasRunComplete, `mock agent should have written run completion event`).toBe(true);