a2a-exposed 0.8.35 → 0.8.36

package/lib/hosted.mjs

@@ -194,6 +194,8 @@ export async function status(o = {}) {
 
 export async function wake(sub, o = {}) {
 	if (!["preview", "test", "set", "prepare", "remove", "unset"].includes(sub)) fail("usage", "Use wake preview|test|set|prepare|remove. List presets with hosted capabilities --json.");
+	if (sub === "set" && C.deploymentKind() === "hosted" && !o.agent)
+		fail("hosted_config", "This is a hosted config. Use dashboard Wake settings or hosted MCP set_wake; the human enters wake secrets on the confirmation page. For scoped CLI setup, run hosted capabilities --json, then hosted list --json to select an explicit --agent NAME before wake set --agent NAME --url URL --preset P --json. No wake settings were changed.");
 	const removing = sub === "remove" || sub === "unset";
  const preparingRemoval = sub === "prepare" && o.clear === true;
  if (o.clear && !preparingRemoval) fail("usage", "Use wake prepare --clear for an MCP removal reference, or wake remove --version N. Run wake preview --json to list the current version.");
@@ -266,7 +268,16 @@ export async function wake(sub, o = {}) {
 	// Do not print proofs, arbitrary service text, webhook URLs or unexpected fields.
 	const code = typeof result.code === "string" && /^(?:[1-5][0-9]{2}|access-40[13]|none|timeout|tls|private|dns|dns-missing|transport-delivery|transport-native|transport-socket|cloudflare-target-unsupported|connection|failed|unreadable|signing)$/.test(result.code) ? result.code : result.saved === true ? "saved" : "failed";
 	const ok = result.ok === true && (sub !== "set" || result.saved === true);
-	return { ok, code, saved: result.saved === true, next: ok ? sub === "set" ? "Check the receiver for the test wake." : "The draft passed. Run wake set with the same inputs to test and save." : code === "cloudflare-target-unsupported" ? "Use polling or a self-hosted Worker for this Cloudflare-proxied webhook." : "Saved settings were not changed. Check the receiver, credentials and draft, then test again." };
+	const recovery = {
+		"cloudflare-target-unsupported": "This hosted service cannot deliver to this Cloudflare-proxied webhook. Choose a supported public HTTPS route, polling, or an explicitly authorized self-hosted Worker; do not create another tunnel or weaken Access or hook authentication.",
+		"transport-socket": "The hosted service could not connect using its public-HTTPS socket transport. Check hosted route compatibility before changing the receiver. An owner-created Cloudflare Tunnel can pass local checks and still be unreachable by this transport; do not weaken Access or hook authentication.",
+		"dns": "The hosted service could not resolve the webhook hostname. Check its public DNS before testing again.",
+		"dns-missing": "The hosted service could not resolve the webhook hostname. Check its public DNS before testing again.",
+		"tls": "The hosted service could not establish TLS to the webhook. Check the hostname and certificate; keep HTTPS verification enabled.",
+		"access-401": "Cloudflare Access refused the test. Check the selected Access service token and policy without disabling Access or hook authentication.",
+		"access-403": "Cloudflare Access refused the test. Check the selected Access service token and policy without disabling Access or hook authentication.",
+	};
+	return { ok, code, saved: result.saved === true, next: ok ? sub === "set" ? "Check the receiver for the test wake." : "The draft passed. Run wake set with the same inputs to test and save." : `Saved settings were not changed. ${recovery[code] || "Check the receiver, credentials and draft, then test again."}` };
 }
 
 export async function output(run, o = {}) {

package/lib/main.mjs

@@ -131,7 +131,9 @@ https://github.com/telegraphic-dev/a2a-exposed/blob/main/docs/getting-started.md
   deploy [same flags]           redeploy with saved settings (secrets persist); tag the Worker version as a2a-exposed-<version>
   wake set [--preset P] [--agent-id A] [--key-header H] [--key-prefix X] [--body-template JSON]
            [--cli-command CMD] [--debounce S] [--max-per-hour N]
-                                save wake settings, upload wake secrets from env, and redeploy (one step)
+                                self-hosted: save wake settings, upload wake secrets from env, and redeploy
+                                hosted config without --agent: stop with dashboard Wake settings / hosted MCP set_wake guidance
+                                hosted CLI: list hosted capabilities --json and hosted list --json, then select --agent NAME
                                 openbot: human supplies WAKE_HMAC_SECRET via protected env/secret storage, never chat or argv
                                 the Worker refuses unsigned openbot wakes (a webhook key is not a signing secret)
                                 --max-per-hour  hourly cap; 0 or unset is unlimited, except Claude Code,
@@ -191,8 +193,11 @@ Status
                                 read selected hosted agent wake configuration; select NAME with hosted list --json.
                                 Uses setup approval or that agent's matching owner credential; no delivery test.
   Hosted-only configs report deployment: hosted and hosted recovery guidance.
+  Hosted status lists capability/preview next steps; saved wake settings do not prove delivery.
+  Offer webhook or polling after checking hook support and hosted route compatibility.
+  A listed OpenClaw preset does not prove route reachability; check delivery preflight before tunnel setup.
   status [--json]               deployment, Worker version, base URL, agent card check (fetched by the CLI), wake
-                                mode (webhook / tunnel / none = polling), tunnel state, proxy mode (--upstream):
+                                mode (webhook / tunnel / none = no webhook), tunnel state, proxy mode (--upstream):
                                 upstream card, Access credential and upstream bearer configured (separately), the
                                 live upstream check, the last failed peer call, card-leak check; warnings for peer
                                 token variables shadowing saved tokens; and the next step to run.
@@ -233,7 +238,9 @@ Inbox (owner side)
                                            requests (tell your human; the dashboard URL when MANAGE_URL is set;
                                            --json: rows on stdout, requests on stderr). Follows every page; past
                                            10000 pages it errors instead of a short list. Reading marks returned replies
-                                           seen and clears matching pending wakes; task state is unchanged
+                                           seen and clears matching pending wakes; task state is unchanged.
+                                           Direct reply messages are completed without a new-work wake;
+                                           read them with history or inbox --all
   show <taskId>                            full task JSON
   working <taskId>                         mark task working
   reply <taskId> (--text T | --stdin) [--state completed|input-required|rejected|failed|working]

package/lib/status.mjs

@@ -191,9 +191,12 @@ export async function checkCard(base) {
 
 /** One line describing how wakes reach the agent. */
 export function wakeLine(s) {
-	if (!s.wake) return "unknown (owner API not reachable)";
+	if (!s.wake) return s.deployment === "hosted" && s.ownerApi?.ok
+		? "unknown (hosted wake preview unavailable)" : "unknown (owner API not reachable)";
 	const w = s.wake;
-	if (!w.configured) return "none: no WAKE_WEBHOOK_URL on the Worker, so the agent is expected to poll the A2A endpoint";
+	if (!w.configured) return s.deployment === "hosted"
+		? "no webhook configured; choose delivery after checking hosted route compatibility"
+		: "none: no WAKE_WEBHOOK_URL on the Worker, so the agent is expected to poll the A2A endpoint";
 	const auth = [w.hasKey && "bearer/API key", w.hasHmacSecret && "HMAC signature", w.hasAccessServiceToken && "Access service token"].filter(Boolean);
 	return `webhook (preset ${w.preset}${s.tunnel ? ", through the tunnel" : ""}); auth: ${auth.join(" + ") || "none"}; URL fingerprint ${w.urlFingerprint || "-"}`;
 }
@@ -294,10 +297,13 @@ function nextStepCore(s) {
 		if (s.card.urlProblem) return fail(`the hosted agent card has a different endpoint: ${s.card.urlProblem}. Check the address with the hosted service.`);
 		if (!s.health?.ok) return fail("the hosted health check failed. Check the hosted service and run status again.");
 		if (!s.ownerApi.ok) return fail("the hosted owner API refused or could not check the saved credential. Check the hosted agent access with its owner.");
-		if (!s.wake) return done("the hosted endpoint is reachable and its owner credential is accepted. Wake preview is unavailable; check wake delivery through the hosted service.");
-		return done(s.wake?.configured
-			? "none: the hosted endpoint is reachable and its owner credential is accepted. Check wake delivery through the hosted service."
-			: "the hosted endpoint is reachable. Configure a public HTTPS webhook through the hosted service, or use polling. Cloudflare Tunnel delivery may be unavailable; do not provision a self-hosted tunnel for this address.");
+		const discover = `Run \`${CLI} hosted capabilities --json\` to list supported setup scopes and wake presets.`;
+		const fallback = "If unavailable, use hosted dashboard Wake settings or MCP set_wake.";
+		if (!s.wake) return done(`the hosted endpoint is reachable and its owner credential is accepted. Wake preview is unavailable; delivery is unverified. ${discover}`, [fallback]);
+		if (s.wake.configured) return done(`the hosted endpoint is reachable and wake settings are saved; status does not test delivery. ${discover}`, [fallback,
+			`When supported, read \`${CLI} wake preview --json\` for the saved agent before an authorized draft test, then verify an inbox-and-reply run.`]);
+		return done(`the hosted endpoint is reachable; no webhook is configured. ${discover}`, [fallback,
+			"Check hook support and hosted route compatibility, then offer webhook or polling with its interval and cost before configuring either. Do not provision a self-hosted tunnel for this address."]);
 	}
 	if (!s.deployed) return fail(`nothing is deployed from ${path.dirname(s.configFile)}. Run \`${CLI} init\` (see the quick start). Another deployment? Set A2A_CONFIG_DIR.`);
 	if (s.baseUrlEnv)

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "a2a-exposed",
-	"version": "0.8.35",
+	"version": "0.8.36",
 	"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

@@ -698,6 +698,7 @@ type Rpc = (p: Json, label: string, version: string, ctx: TenantContext, ectx: E
 const rpcSend: Rpc = async (params, label, version, ctx, ectx) => {
 	const msg = A.normMessage(params.message);
 	if (msg.role !== "user") throw new RpcError(-32602, "message.role must be user");
+	const directReply = directReplyParams(params);
 	const conf = params.configuration || {};
 	const push = conf.taskPushNotificationConfig || conf.pushNotificationConfig;
 	const pushCfg = push ? normPushCfg(push, version) : null;
@@ -718,9 +719,11 @@ const rpcSend: Rpc = async (params, label, version, ctx, ectx) => {
 	if (!task) task = { id: A.newId(), contextId, status: { state: "submitted", timestamp: ts }, artifacts: [], history: [], _peer: label, _protocol: version, _createdAt: ts, _push: [] };
 	msg.contextId = contextId; msg.taskId = task.id;
 	task.history.push(msg);
-	task.status = { state: "submitted", timestamp: ts };
+	task.status = { state: directReply ? "completed" : "submitted", timestamp: ts };
 	if (pushCfg) task._push = [...task._push.filter((c: Json) => c.id !== pushCfg.id), pushCfg];
 	if (params.metadata && typeof params.metadata === "object") task.metadata = { ...(task.metadata || {}), ...params.metadata };
+	// Keep the loop marker on the task even when it was supplied only on the message.
+	if (directReply) task.metadata = { ...(task.metadata || {}), [DIRECT_REPLY_META]: params.metadata?.[DIRECT_REPLY_META] || msg.metadata?.[DIRECT_REPLY_META] };
 	const preview = A.textOf(msg);
 	if (creating) {
 		const stored = await ctx.DB.batch([
@@ -738,7 +741,8 @@ const rpcSend: Rpc = async (params, label, version, ctx, ectx) => {
 		]);
 	}
 	log("message_received", { peer: label, contextId, taskId: task.id, chars: preview.length, version });
-	await wake(ctx, ectx, contextId, task.id, label, preview);
+	// Direct replies are stored for history, not scheduled as new work.
+	if (!directReply) await wake(ctx, ectx, contextId, task.id, label, preview);
 	const pt = A.publicTask(task, version, conf.historyLength);
 	return version.startsWith("1") ? { task: pt } : pt;
 };

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.35";
+export const VERSION = "0.8.36";

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

@@ -55,8 +55,10 @@ async function fixture(t: Parameters<typeof test>[1] extends (t: infer T) => unk
 	byId.set("id-alice", a); byId.set("id-bob", b);
 	store.set("tenant:alice", JSON.stringify({ id: "id-alice", status: "active", region: "default", version: 1 }));
 	store.set("tenant:bob", JSON.stringify({ id: "id-bob", status: "active", region: "default", version: 1 }));
-	const owner = (ctx: TenantContext, accountId: string, method: string, path: string, body?: unknown) =>
-		runOwnerRpc(ctx, ectx as never, { accountId, method, path, ...(body === undefined ? {} : { body }) });
+	const owner = (ctx: TenantContext, accountId: string, method: string, path: string, body?: unknown) => {
+		const url = new URL(path, ctx.PUBLIC_URL);
+		return runOwnerRpc(ctx, ectx as never, { accountId, method, path: url.pathname, query: Object.fromEntries(url.searchParams), ...(body === undefined ? {} : { body }) });
+	};
 	const issue = async (ctx: TenantContext, ownerToken: string, label: string) => {
 		const r = await dispatch(new Request(ctx.PUBLIC_URL + "/owner/peers", { method: "POST", headers: { authorization: `Bearer ${ownerToken}`, "content-type": "application/json" }, body: JSON.stringify({ label }) }), ctx, ectx as never);
 		return (await r.json() as { token: string }).token;
@@ -71,7 +73,7 @@ async function fixture(t: Parameters<typeof test>[1] extends (t: infer T) => unk
 		assert.equal(r.status, 200, JSON.stringify(data));
 		return data.result.id as string;
 	};
-	return { a, b, dbA, dbB, owner, sendToBob, cards, missingCard() { missingCard = true; }, get directPosts() { return directPosts; }, get aborted() { return aborted; }, blockDirect() {
+	return { a, b, dbA, dbB, owner, sendToBob, bobAtAlice, otherAtAlice: () => issue(a, ownerA, "other"), cards, missingCard() { missingCard = true; }, get directPosts() { return directPosts; }, get aborted() { return aborted; }, blockDirect() {
 		let release!: () => void;
 		hold = new Promise<void>((resolve) => { release = resolve; });
 		const started = new Promise<void>((resolve) => { posted = resolve; });
@@ -91,15 +93,20 @@ test("reply delivers once to an exact paired peer in the same context and a dire
 	assert.equal(JSON.stringify(first.body).includes("a2aow_"), false);
 	assert.equal(s.directPosts, 1);
 
-	const inbox = await s.owner(s.a, "acct-alice", "GET", "/owner/inbox");
+	const inbox = await s.owner(s.a, "acct-alice", "GET", "/owner/inbox?all=1");
 	const delivered = (inbox.body as any[]).find((row) => row.text === "answer");
 	assert.equal(delivered.contextId, "ctx-direct");
+	assert.equal(delivered.state, "completed");
+	assert.deepEqual((await s.dbA.prepare("SELECT * FROM wakes").all()).results, []);
+	const openInbox = await s.owner(s.a, "acct-alice", "GET", "/owner/inbox");
+	assert.deepEqual(openInbox.body, []);
 	const stored = await s.dbA.prepare("SELECT metadata_json FROM tasks WHERE id = ?").bind(delivered.taskId).first() as { metadata_json?: string };
 	const metadata = JSON.parse(stored.metadata_json || "{}");
 	assert.deepEqual(metadata["a2a.exposed/reply-delivery"].taskId, taskId);
 
 	const noLoop = await s.owner(s.a, "acct-alice", "POST", "/owner/mcp/reply", { taskId: delivered.taskId, text: "ack", state: "completed" });
-	assert.equal((noLoop.body as any).structuredContent.status, "stored-only");
+	assert.equal((noLoop.body as any).isError, true);
+	assert.match(String((noLoop.body as any).text), /already completed/);
 	assert.equal(s.directPosts, 1, "a directly delivered reply is never delivered back");
 
 	const retry = await s.owner(s.b, "acct-bob", "POST", "/owner/mcp/reply", { taskId, text: "answer", state: "completed" });
@@ -219,3 +226,36 @@ test("reply discovers one canonical card and uses the paired base when it is mis
 	assert.deepEqual(s.cards, ["/.well-known/agent-card.json"]);
 	assert.equal(s.directPosts, 1);
 });
+
+for (const version of ["0.3", "1.0"]) {
+	for (const placement of ["request", "message"]) {
+		test(`direct reply metadata on ${placement} auto-completes without waking (${version})`, async (t) => {
+			const s = await fixture(t as never);
+			const contextId = "ctx-marker";
+			const marker = { "a2a.exposed/reply-delivery": { taskId: "remote-task", messageId: "remote-message", state: "working" } };
+			const send = async (metadata: unknown, taskId?: string, token = s.bobAtAlice) => {
+				const message = { role: version === "1.0" ? "ROLE_USER" : "user", messageId: crypto.randomUUID(), contextId,
+					parts: [{ kind: "text", text: "reply text" }], ...(taskId ? { taskId } : {}), ...(placement === "message" ? { metadata } : {}) };
+				const r = await dispatch(new Request(s.a.PUBLIC_URL, { method: "POST", headers: { authorization: `Bearer ${token}`, "content-type": "application/json" },
+					body: JSON.stringify({ jsonrpc: "2.0", id: "marker", method: version === "1.0" ? "SendMessage" : "message/send", params: { message, ...(placement === "request" ? { metadata } : {}) } }) }), s.a, ectx as never);
+				return await r.json() as any;
+			};
+			const result = await send(marker);
+			const task = version === "1.0" ? result.result.task : result.result;
+			assert.equal(task.status.state, version === "1.0" ? "TASK_STATE_COMPLETED" : "completed");
+			assert.deepEqual(task.metadata, marker);
+			assert.deepEqual((await s.owner(s.a, "acct-alice", "GET", "/owner/inbox")).body, []);
+			assert.deepEqual((await s.dbA.prepare("SELECT * FROM wakes").all()).results, []);
+			const history = await s.owner(s.a, "acct-alice", "GET", `/owner/history/${contextId}?from=bob`);
+			assert.match(JSON.stringify(history.body), /reply text/);
+			const unauthorized = await send(marker, task.id, await s.otherAtAlice());
+			assert.equal(unauthorized.error.code, -32001);
+			for (const metadata of [{ other: {} }, { "a2a.exposed/reply-delivery": "completed" }]) {
+				const normal = await send(metadata);
+				assert.equal((version === "1.0" ? normal.result.task : normal.result).status.state, version === "1.0" ? "TASK_STATE_SUBMITTED" : "submitted");
+			}
+			assert.equal(((await s.owner(s.a, "acct-alice", "GET", "/owner/inbox")).body as any[]).length, 2);
+			assert.equal((await s.dbA.prepare("SELECT COUNT(*) AS n FROM wakes").first() as any).n, 1);
+		});
+	}
+}