a2a-exposed 0.8.36 → 0.8.38

package/lib/hosted.mjs

@@ -5,6 +5,7 @@ import { controlOrigin, deviceLogin } from "./account.mjs";
 import { CliError, upstreamUrlProblem } from "./a2a.mjs";
 
 export const SETUP_SCOPES = ["agents:read", "agents:create", "agents:owner-token", "wake:write", "wake:test"];
+const SETUP_UNSUPPORTED = "This service does not expose scoped hosted setup capabilities. Check the --control-url service origin. Use the service dashboard to create an agent and configure Wake settings, or hosted MCP create_agent/set_wake with human confirmation and secret entry. Do not run init or deploy to repair a hosted address; no setup approval was requested.";
 const NEXT = "Run hosted capabilities --json to list scopes and presets; login --machine NAME --scopes SCOPES to approve setup.";
 const fail = (code, next) => { const error = new CliError(next); error.result = { ok: false, code, next }; throw error; };
 const printable = value => typeof value === "string" && value.length <= 4096 && !/[\x00-\x1f\x7f]/.test(value);
@@ -34,14 +35,16 @@ function originFor(o = {}) {
 
 async function request(origin, path, { token = "", method = "GET", body, fetchImpl = fetch } = {}) {
 	let response, data;
+	const discovery = method === "GET" && path === "/api/v1/setup/capabilities";
 	try {
 		response = await fetchImpl(`${origin}${path}`, {
 			method, redirect: "error", signal: AbortSignal.timeout(30_000),
 			headers: { accept: "application/json", ...(token ? { authorization: `Bearer ${token}` } : {}), ...(body === undefined ? {} : { "content-type": "application/json" }) },
 			...(body === undefined ? {} : { body: JSON.stringify(body) }),
 		});
-		data = await response.json();
+		if (!(discovery && response.status === 404)) data = await response.json();
 	} catch { fail("unavailable", "Hosted setup did not answer with JSON. Check the service and try again. Do not repeat a create request until hosted list confirms its result."); }
+	if (discovery && response.status === 404) fail("unsupported", SETUP_UNSUPPORTED);
 	if (!data || typeof data !== "object" || Array.isArray(data)) fail("invalid_response", "The hosted service returned an invalid setup response.");
 	if (!response.ok) {
 		if (response.status === 429 && data.error === "too_many_references") {
@@ -70,7 +73,7 @@ async function request(origin, path, { token = "", method = "GET", body, fetchIm
 
 export async function capabilities(o = {}) {
 	const data = await request(originFor(o), "/api/v1/setup/capabilities");
-	if (!Array.isArray(data.scopes) || !Array.isArray(data.wake?.presets)) fail("unsupported", "This service does not expose hosted setup capabilities yet.");
+	if (!Array.isArray(data.scopes) || !Array.isArray(data.wake?.presets)) fail("unsupported", SETUP_UNSUPPORTED);
 	return { ok: true, code: "capabilities", next: "Select explicit scopes and a wake preset from this listing.", scopes: data.scopes.filter(s => SETUP_SCOPES.includes(s)), presets: data.wake.presets.filter(s => /^[a-z-]+$/.test(s)), preflight: data.preflight === true, secret_reference: data.wake.secret_reference === true, wake_removal: data.wake.removal === true, secure_link_create: data.wake.secure_link_create === true };
 }
 

package/lib/main.mjs

@@ -28,6 +28,7 @@ Setup options: --skip-install skips dependency installation when dependencies al
 
 Hosted setup:
   hosted capabilities --json   list setup scopes, wake presets and service capabilities
+                                unsupported/404: check --control-url; use dashboard or hosted MCP with human confirmation
   login --machine NAME --scopes SCOPES [--control-url URL] --json
                                 approve the explicit scopes using the printed website link once;
                                 save the scoped grant locally (mode 600), never print it
@@ -314,6 +315,8 @@ Outbound (agents you call)
   poll --to <alias|url> <taskId> [--proto 0.3|1.0]
                           send/poll need only peer config; owner history/task storage is optional.
                           Storage failures warn on stderr; the peer response still prints and exits 0
+                          Self-hosted MCP: poll_outbound fetches current state; cancel_outbound asks the peer
+                          to cancel a sent task. Ask the human before canceling consequential work
   outbound <taskId>       stored state of a task you sent (incl. pushed updates)
 
 Owner

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "a2a-exposed",
-	"version": "0.8.36",
+	"version": "0.8.38",
 	"description": "Give any AI agent a public A2A (Agent2Agent) endpoint: a Cloudflare Worker, a wake webhook, or scheduled checks",
 	"type": "module",
 	"bin": {

package/worker/src/index.ts

@@ -1147,7 +1147,7 @@ async function checkedPeerFetch(ctx: TenantContext, ectx: ExecutionContext, base
 	try { baseUrl = new URL(base); target = new URL(url); } catch { throw new ToolError("peer endpoint is not a URL"); }
 	if (target.origin !== baseUrl.origin) throw new ToolError("peer card endpoint refused: it is on a different origin");
 	const why = peerUrlProblem(target.href);
-	if (why) throw new ToolError(`peer endpoint ${target.href} refused: ${why}`);
+	if (why) throw new ToolError(`peer endpoint ${target.host} refused: ${why}`);
 	const internal = await fetchTenant(ctx, target, { ...init, redirect: "manual" });
 	if (internal) {
 		if (internal.status >= 300 && internal.status < 400) throw new ToolError("peer endpoint refused: redirects are not allowed");
@@ -1563,10 +1563,12 @@ async function deliverReplyMessage(ctx: TenantContext, ectx: ExecutionContext, t
 		const pushed = await notifyPeer(ctx, ectx, task, signal);
 		const failed = pushed.find((x: Json) => !x.ok);
 		const target = safeTarget(undefined, String((failed || pushed[0])?.url || ""));
-		const http = /HTTP (\d{3})/.exec(String((failed || pushed[0])?.info || ""));
+		const info = String((failed || pushed[0])?.info || "");
+		const http = /^HTTP (\d{3})$/.exec(info);
+		const httpStatus = http && http[0] === info ? Number(http[1]) : undefined;
 		return {
 			status: failed ? "delivery-failed" : "delivered", method: "push", taskId: task.id, state,
-			...(target ? { target } : {}), ...(http ? { httpStatus: Number(http[1]) } : {}),
+			...(target ? { target } : {}), ...(httpStatus !== undefined && httpStatus >= 100 && httpStatus <= 599 ? { httpStatus } : {}),
 			detail: failed ? "A task push failed; the reply remains stored on the task." : "Delivered as the task's existing push update.",
 		};
 	}
@@ -2195,7 +2197,7 @@ async function handleOwner(req: Request, ctx: TenantContext, ectx: ExecutionCont
 		}
 	}
 	if (seg[0] === "pairing") return await ownerPairing(req, ctx, ectx, m, seg.slice(1), body, trusted);
-	if (seg[0] === "mcp" && seg[1] && !seg[2] && m === "POST" && (seg[1] === "send" || seg[1] === "reply" || seg[1] === "mark_working" || seg[1] === "announce_address")) {
+	if (seg[0] === "mcp" && seg[1] && !seg[2] && m === "POST" && (seg[1] === "send" || seg[1] === "reply" || seg[1] === "mark_working" || seg[1] === "announce_address" || seg[1] === "poll_outbound" || seg[1] === "cancel_outbound")) {
 		const checked = ownerRpcBody(`POST /owner/mcp/${seg[1]}`, await body());
 		if (!checked.ok) return json({ error: checked.error, ...(checked.code ? { code: checked.code } : {}) }, 400);
 		try {
@@ -3565,8 +3567,15 @@ async function peerRpc(ctx: TenantContext, ectx: ExecutionContext, peer: { alias
 	const text = (await res.text()).slice(0, 1 << 20);
 	let data: Json = null;
 	try { data = JSON.parse(text); } catch { /* below */ }
-	if (res.status !== 200 || !data || typeof data !== "object" || "error" in data)
-		throw new ToolError(`peer "${peer.alias}" answered HTTP ${res.status}${data?.error ? `: ${String(data.error.message || JSON.stringify(data.error)).slice(0, 300)}` : ""}`);
+	if (res.status !== 200 || !data || typeof data !== "object" || "error" in data) {
+		const rpc = data?.error;
+		const code = Number.isSafeInteger(rpc?.code) ? `JSON-RPC ${rpc.code}` : "JSON-RPC error";
+		const detail = typeof rpc?.message === "string" ? rpc.message.replace(/[\x00-\x1f\x7f]/g, " ") : "The peer returned an invalid response";
+		const reason = rpc ? `${code}: ${detail}` : detail;
+		const status = res.status === 200 ? "" : `HTTP ${res.status}: `;
+		const safe = peer.token ? reason.split(peer.token).join("[redacted]") : reason;
+		throw new ToolError(`peer "${peer.alias}" answered ${status}${safe.slice(0, 300)}`);
+	}
 	return data.result;
 }
 
@@ -3715,17 +3724,19 @@ async function runTool(ctx: TenantContext, ectx: ExecutionContext, name: string,
 			return M.toolText(tid ? `Sent to ${peer.alias}: task ${tid} (${M.plainState(obj)}), context ${sentContext}. Check it later with poll_outbound.${warn} ${UNTRUSTED}`
 				: `Sent to ${peer.alias}; it answered directly (context ${sentContext}). ${UNTRUSTED}`, obj);
 		}
-		case "poll_outbound": {
+		case "poll_outbound":
+		case "cancel_outbound": {
+			const cancel = name === "cancel_outbound";
 			const tid = A.checkId(argStr(a, "taskId"), "taskId");
 			const rec = must(await ownerCall(ctx, ectx, "GET", `/owner/outbound/${enc(tid)}`));
 			const peer = await outboundPeer(ctx, rec.peer);
 			if (!rec.endpoint) throw new ToolError("this task has no recorded endpoint");
-			const res = await peerRpc(ctx, ectx, peer, rec.endpoint, rec.protocol || "0.3", "tasks/get", "GetTask", { id: tid });
+			const res = await peerRpc(ctx, ectx, peer, rec.endpoint, rec.protocol || "0.3", cancel ? "tasks/cancel" : "tasks/get", cancel ? "CancelTask" : "GetTask", { id: tid });
 			await ownerCall(ctx, ectx, "PUT", `/owner/outbound/${enc(tid)}`, { task: res });
 			let txt = A.textOf((res?.status || {}).message || {});
 			const arts = (res?.artifacts || []).map((x: Json) => A.textOf(x)).join("\n");
 			if (arts && arts !== txt) txt = (txt ? txt + "\n" : "") + arts;
-			await ownerCall(ctx, ectx, "POST", "/owner/history", { contextId: rec.contextId, dir: "in", peer: peer.alias, taskId: tid, event: "poll", state: M.plainState(res), text: txt });
+			await ownerCall(ctx, ectx, "POST", "/owner/history", { contextId: rec.contextId, dir: "in", peer: peer.alias, taskId: tid, event: cancel ? "cancel" : "poll", state: M.plainState(res), text: txt });
 			return M.toolText(`Task ${tid} at ${peer.alias}: ${M.plainState(res)}. ${UNTRUSTED}`, res);
 		}
 		case "list_peers": {

package/worker/src/mcp.ts

@@ -354,6 +354,9 @@ export const TOOLS: { name: string; title: string; description: string; inputSch
 	{ name: "poll_outbound", title: "Check a sent task", annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
 		description: `Fetch the current state of a task you sent to a peer (from send) and record it in the history. ${RULES}`,
 		inputSchema: { type: "object", properties: { taskId: str("Task id returned by send") }, required: ["taskId"], additionalProperties: false } },
+	{ name: "cancel_outbound", title: "Cancel a sent task", annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true },
+		description: `Ask the peer to cancel a task returned by send. Uses the recorded peer and endpoint, records the returned state in history, and does not cancel an inbound task. The peer can refuse cancellation. Ask the human before canceling consequential work. ${RULES}`,
+		inputSchema: { type: "object", properties: { taskId: str("Task id returned by send") }, required: ["taskId"], additionalProperties: false } },
 	{ name: "list_peers", title: "List peers", annotations: ro,
 		description: "Peers you can send to (outbound, synced with `peers sync`) and the labels of agents holding a token for this A2A endpoint (inbound; who can message you). Token values are never shown. An inbound peer with no card URL has no callback yet.",
 		inputSchema: { type: "object", properties: {}, additionalProperties: false } },

package/worker/src/owner-rpc.ts

@@ -4,7 +4,7 @@
 // PUT /owner/outbound-peers/:alias is the one call that accepts a peer token. handleOwner seals it.
 // The response is { ok, alias, hasToken } and the token is not logged.
 // GET /owner/export is here only because runOwnerRpc redacts it first.
-// POST /owner/mcp/send, reply, and mark_working take a checked argument object. A peer token is not one of those arguments.
+// POST /owner/mcp/send, reply, mark_working, poll_outbound, and cancel_outbound take a checked argument object. A peer token is not one of those arguments.
 // Self-host never calls this.
 
 import { ID_RE } from "./a2a.ts";
@@ -169,6 +169,8 @@ const ROUTES: RouteDef[] = [
 	{ method: "DELETE", name: "DELETE /owner/mcp/:label", take: (s) => s.length === 3 && s[1] === "mcp" && MCP_LABEL.test(s[2]!), search: noQuery, path: (s) => `/owner/mcp/${s[2]}` },
 	{ method: "POST", name: "POST /owner/mcp/send", take: (s) => s.length === 3 && s[1] === "mcp" && s[2] === "send", search: noQuery, path: () => "/owner/mcp/send" },
 	{ method: "POST", name: "POST /owner/mcp/reply", take: (s) => s.length === 3 && s[1] === "mcp" && s[2] === "reply", search: noQuery, path: () => "/owner/mcp/reply" },
+	{ method: "POST", name: "POST /owner/mcp/poll_outbound", take: (s) => s.length === 3 && s[1] === "mcp" && s[2] === "poll_outbound", search: noQuery, path: () => "/owner/mcp/poll_outbound" },
+	{ method: "POST", name: "POST /owner/mcp/cancel_outbound", take: (s) => s.length === 3 && s[1] === "mcp" && s[2] === "cancel_outbound", search: noQuery, path: () => "/owner/mcp/cancel_outbound" },
 	{ method: "POST", name: "POST /owner/mcp/mark_working", take: (s) => s.length === 3 && s[1] === "mcp" && s[2] === "mark_working", search: noQuery, path: () => "/owner/mcp/mark_working" },
 	{ method: "POST", name: "POST /owner/mcp/announce_address", take: (s) => s.length === 3 && s[1] === "mcp" && s[2] === "announce_address", search: noQuery, path: () => "/owner/mcp/announce_address" },
 	{ method: "GET", name: "GET /owner/outbound-peers", take: (s) => s.length === 2 && s[1] === "outbound-peers", search: noQuery, path: () => "/owner/outbound-peers" },
@@ -204,6 +206,8 @@ const REPLY_STATES = new Set(["completed", "input-required", "working", "failed"
 const MCP_ARGS: Record<string, { required: readonly string[]; optional: readonly string[] }> = {
 	"POST /owner/mcp/send": { required: ["to", "text"], optional: ["contextId", "taskId"] },
 	"POST /owner/mcp/reply": { required: ["taskId", "text"], optional: ["state"] },
+	"POST /owner/mcp/poll_outbound": { required: ["taskId"], optional: [] },
+	"POST /owner/mcp/cancel_outbound": { required: ["taskId"], optional: [] },
 	"POST /owner/mcp/mark_working": { required: ["taskId"], optional: [] },
 };
 

package/worker/src/version.ts

@@ -1,2 +1,2 @@
 /** Inbox build. Keep this equal to `version` in cli/package.json. */
-export const VERSION = "0.8.36";
+export const VERSION = "0.8.38";

package/worker/test/mcp.test.ts

@@ -329,7 +329,7 @@ test("scope: the MCP token is not an owner or peer token, and peer/owner tokens
 	assert.equal((await s.call("GET", "/mcp", { headers: { authorization: `Bearer ${a.access_token}` } })).status, 405);
 	// tools can't administer tokens or pairings
 	const names = (await s.mcp(a.access_token, "tools/list")).data.result.tools.map((x: any) => x.name);
-	assert.deepEqual(names, ["inbox", "show_task", "history", "mark_working", "reply", "send", "poll_outbound", "list_peers", "announce_address", "pairing_requests", "send_feedback"]);
+	assert.deepEqual(names, ["inbox", "show_task", "history", "mark_working", "reply", "send", "poll_outbound", "cancel_outbound", "list_peers", "announce_address", "pairing_requests", "send_feedback"]);
 	assert.ok(!names.some((n: string) => /approve|deny|token|revoke|issue|password/.test(n)));
 	const unknown = await s.mcp(a.access_token, "tools/call", { name: "approve_pairing", arguments: { code: "X" } });
 	assert.equal(unknown.data.error.code, -32602);

package/worker/test/owner-mcp.test.ts

@@ -21,17 +21,27 @@ test("hosted control plane send, reply, and mark_working", async (t) => {
 		config: { AGENT_NAME: "Carol" },
 	});
 	const peerCalls: { host: string; auth: string | null; body: any }[] = [];
+	let modern = true;
+	let cancelRefused = false;
 	const origFetch = globalThis.fetch;
 	globalThis.fetch = (async (input: any, init: any = {}) => {
 		const u = new URL(String(input));
 		if (u.pathname === "/.well-known/agent-card.json")
-			return Response.json({ name: u.host, supportedInterfaces: [{ url: `https://${u.host}/a2a`, protocolBinding: "JSONRPC", protocolVersion: "1.0" }] });
+			return modern ? Response.json({ name: u.host, supportedInterfaces: [{ url: `https://${u.host}/a2a`, protocolBinding: "JSONRPC", protocolVersion: "1.0" }] }) : Response.json({ url: `https://${u.host}/a2a`, protocolVersion: "0.3" });
 		if (u.pathname === "/a2a") {
 			const body = JSON.parse(init.body);
 			const auth = new Headers(init.headers).get("authorization");
 			peerCalls.push({ host: u.host, auth, body });
 			if (auth !== `Bearer tok-${u.host.split(".")[0]}`) return new Response("no", { status: 401 });
-			if (body.method === "SendMessage") return Response.json({ jsonrpc: "2.0", id: body.id, result: { task: { id: `pt-${u.host.split(".")[0]}`, contextId: "ctx-out-1", status: { state: "TASK_STATE_SUBMITTED" } } } });
+			if (body.method === "GetTask" || body.method === "tasks/get" || body.method === "CancelTask" || body.method === "tasks/cancel") {
+				assert.equal(new Headers(init.headers).get("a2a-version"), modern ? "1.0" : "0.3");
+				const cancel = body.method === "CancelTask" || body.method === "tasks/cancel";
+				if (cancel && cancelRefused) return Response.json({ jsonrpc: "2.0", id: body.id, error: { code: -32002, message: "Task cannot be canceled" } });
+				return Response.json({ jsonrpc: "2.0", id: body.id, result: { id: body.params.id, contextId: "ctx-out-1", status: { state: modern ? (cancel ? "TASK_STATE_CANCELED" : "TASK_STATE_WORKING") : (cancel ? "canceled" : "working") } } });
+			}
+			if (body.params?.message?.parts[0]?.text === "echo-token") return Response.json({ jsonrpc: "2.0", id: body.id, error: { code: -32603, message: "Rejected tok-alpha" } });
+			if (body.params?.message?.parts[0]?.text === "terminal") return Response.json({ jsonrpc: "2.0", id: body.id, error: { code: -32002, message: "Task is in a terminal state" } });
+			if (body.method === "SendMessage" || body.method === "message/send") return Response.json({ jsonrpc: "2.0", id: body.id, result: { task: { id: `pt-${u.host.split(".")[0]}${modern ? "" : "-03"}`, contextId: "ctx-out-1", status: { state: "TASK_STATE_SUBMITTED" } } } });
 		}
 		return new Response("not found", { status: 404 });
 	}) as typeof fetch;
@@ -89,6 +99,47 @@ test("hosted control plane send, reply, and mark_working", async (t) => {
 	assert.equal(peerCalls.at(-1)!.body.params.message.parts[0].text, "status?");
 	assert.equal(peerCalls.at(-1)!.body.params.message.contextId, "ctx-hosted");
 
+	for (const version of [true, false]) {
+		modern = version;
+		const taskId = version ? "pt-alpha" : "pt-alpha-03";
+		await rpc("/owner/mcp/send", { to: "alpha", text: "status?" });
+		for (const tool of ["poll_outbound", "cancel_outbound"]) {
+			const before = peerCalls.length;
+			const missing = await rpc(`/owner/mcp/${tool}`, { taskId: "unknown" });
+			assert.equal((missing.body as any).isError, true);
+			assert.equal(peerCalls.length, before, "unknown task never calls a peer");
+			const denied = await http("POST", `/owner/mcp/${tool}`, "Bearer platform-owner", { taskId });
+			assert.equal(denied.status, 401);
+			const result = await rpc(`/owner/mcp/${tool}`, { taskId });
+			assert.equal(result.status, 200);
+			assert.equal((result.body as any).isError, false, JSON.stringify(result.body));
+			assert.match((result.body as any).text, tool === "poll_outbound" ? /working/ : /canceled/);
+			assert.equal(peerCalls.at(-1)!.auth, "Bearer tok-alpha");
+			assert.equal(peerCalls.at(-1)!.body.method, version ? (tool === "poll_outbound" ? "GetTask" : "CancelTask") : (tool === "poll_outbound" ? "tasks/get" : "tasks/cancel"));
+			assert.deepEqual(peerCalls.at(-1)!.body.params, { id: taskId });
+			assert.equal(JSON.stringify(result.body).includes("tok-alpha"), false);
+			const stored = await http("GET", `/owner/outbound/${taskId}`, `Bearer ${ownerToken}`);
+			assert.match(JSON.stringify(stored.data), tool === "poll_outbound" ? /WORKING|working/ : /CANCELED|canceled/);
+		}
+		cancelRefused = true;
+		const beforeRefusal = await http("GET", `/owner/outbound/${taskId}`, `Bearer ${ownerToken}`);
+		const refused = await rpc("/owner/mcp/cancel_outbound", { taskId });
+		assert.equal((refused.body as any).isError, true);
+		assert.match((refused.body as any).text, /JSON-RPC -32002: Task cannot be canceled/);
+		assert.deepEqual((await http("GET", `/owner/outbound/${taskId}`, `Bearer ${ownerToken}`)).data, beforeRefusal.data, "refused cancellation preserves the saved task");
+		cancelRefused = false;
+		const error = await rpc("/owner/mcp/send", { to: "alpha", text: "terminal" });
+		assert.equal((error.body as any).isError, true);
+		assert.match((error.body as any).text, /JSON-RPC -32002: Task is in a terminal state/);
+		assert.doesNotMatch((error.body as any).text, /HTTP 200/);
+	}
+	modern = true;
+	const echoed = await rpc("/owner/mcp/send", { to: "alpha", text: "echo-token" });
+	assert.equal((echoed.body as any).isError, true);
+	assert.doesNotMatch(JSON.stringify(echoed.body), /tok-alpha/);
+	const history = await http("GET", "/owner/history/ctx-out-1", `Bearer ${ownerToken}`);
+	assert.match(JSON.stringify(history.data), /"event":"cancel"/);
+
 	const viaHttp = await http("POST", "/owner/mcp/send", `Bearer ${ownerToken}`, { to: "alpha", text: "from the owner token" });
 	assert.equal(viaHttp.status, 200, viaHttp.text);
 	assert.equal(viaHttp.data.isError, false);

package/worker/test/owner-rpc.test.ts

@@ -54,7 +54,11 @@ test("owner RPC allowlist is the management reads and the calls that do not retu
 	assert.deepEqual(refused("POST", "/owner/purge"), { ok: false, reason: "path" });
 	assert.deepEqual(refused("POST", "/owner/tasks/task-1/reply"), { ok: false, reason: "path" });
 	assert.deepEqual(refused("POST", "/owner/mcp/send", { to: "alpha" }), { ok: false, reason: "query" });
-	assert.deepEqual(refused("POST", "/owner/mcp/poll_outbound"), { ok: false, reason: "path" });
+	for (const tool of ["poll_outbound", "cancel_outbound"]) {
+		assert.equal(ok("POST", `/owner/mcp/${tool}`)?.path, `/owner/mcp/${tool}`);
+		assert.deepEqual(ownerRpcBody(`POST /owner/mcp/${tool}`, { taskId: "task-1" }), { ok: true, value: { taskId: "task-1" } });
+		for (const body of [{}, { taskId: ".." }, { taskId: "task-1", to: "other" }, { taskId: "task-1", token: "secret" }]) assert.equal(ownerRpcBody(`POST /owner/mcp/${tool}`, body).ok, false);
+	}
 	assert.deepEqual(refused("PUT", "/owner/mcp/send"), { ok: false, reason: "path" });
 	assert.deepEqual(refused("POST", "/owner/history"), { ok: false, reason: "path" });
 	assert.deepEqual(refused("GET", "/owner/peers/../export"), { ok: false, reason: "path" });

package/worker/test/reply-delivery.test.ts

@@ -259,3 +259,36 @@ for (const version of ["0.3", "1.0"]) {
 		});
 	}
 }
+
+
+test("push status only accepts an exact HTTP result in the output schema range", async (t) => {
+	const s = await fixture(t as never);
+	const originalFetch = globalThis.fetch;
+	t.after(() => { globalThis.fetch = originalFetch; });
+	for (const value of [200, 307, 401, 599, 99, 600, 999, "HTTP 999", "prefix HTTP 401 suffix", "HTTP 401\n"]) {
+		globalThis.fetch = (async () => {
+			if (typeof value === "string") throw value;
+			const response = new Response(null);
+			Object.defineProperty(response, "status", { value });
+			return response;
+		}) as typeof fetch;
+		const taskId = await s.sendToBob("status " + value, crypto.randomUUID(), { id: "cfg", url: "https://push.example.net/update" });
+		const result = await s.owner(s.b, "acct-bob", "POST", "/owner/mcp/reply", { taskId, text: "stored answer" });
+		const delivery = (result.body as any).structuredContent as Delivery;
+		assert.equal(delivery.httpStatus, typeof value === "number" && value >= 100 && value <= 599 ? value : undefined, String(value));
+		assert.equal(delivery.status, value === 200 ? "delivered" : "delivery-failed");
+		const stored = await s.dbB.prepare("SELECT state FROM tasks WHERE id = ?").bind(taskId).first() as { state: string };
+		assert.equal(stored.state, "completed");
+	}
+});
+
+test("direct reply refusal reports only the endpoint host", async (t) => {
+	const s = await fixture(t as never);
+	await s.dbB.prepare("UPDATE outbound_peers SET url = 'http://alice.example.com/private-path?private-query=yes' WHERE alias = 'alice'").run();
+	const taskId = await s.sendToBob("refused endpoint", "ctx-refused-url");
+	const result = await s.owner(s.b, "acct-bob", "POST", "/owner/mcp/reply", { taskId, text: "stored answer" });
+	const delivery = (result.body as any).structuredContent;
+	assert.equal(delivery.status, "delivery-failed");
+	assert.match(delivery.detail, /peer endpoint alice\.example\.com refused/);
+	assert.doesNotMatch(JSON.stringify(result.body), /private-path|private-query|http:\/\//);
+});