a2a-exposed 0.8.37 → 0.8.38

package/lib/main.mjs

@@ -315,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.37",
+	"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

@@ -2197,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 {
@@ -3567,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;
 }
 
@@ -3717,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.37";
+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" });