a2a-exposed 0.8.22 → 0.8.24

package/worker/test/hosted.test.ts

@@ -929,3 +929,50 @@ test("self-host workerd: human mode owner token approves, the device poll return
 	const deniedToken = await deniedPoll.json() as { error?: string };
 	assert.equal(deniedToken.error, "access_denied");
 });
+
+
+test("sealed upstream and wake Access credentials reach only their tenant context in workerd", async (t) => {
+	const received: { origin: string; bearer: string | null; id: string | null; secret: string | null }[] = [];
+	const mf = await start({
+		bindings: { TENANCY: "host", TENANT_DOMAIN: "example.com", TENANT_SECRETS_KEY: "platform-secret" },
+		durableObjects: { TENANT_DO: { className: "TenantStore", useSQLite: true } },
+		outboundService: async (request: Request) => {
+			received.push({ origin: new URL(request.url).origin, bearer: request.headers.get("authorization"), id: request.headers.get("cf-access-client-id"), secret: request.headers.get("cf-access-client-secret") });
+			return Response.json({ protocolVersion: "0.3.0", name: "Example", url: "https://upstream.example.com/a2a", capabilities: {}, skills: [] });
+		},
+	});
+	t.after(() => mf.dispose());
+	await mf.ready;
+	const ns = await mf.getDurableObjectNamespace("TENANT_DO");
+	const stub = ns.get(ns.idFromName("sealed-tenant")) as unknown as {
+		pushConfig(body: Record<string, unknown>): Promise<{ applied: boolean }>;
+		owner(input: { accountId: string; method: string; path: string }): Promise<{ status: number; body: unknown }>;
+	};
+	const secrets = { UPSTREAM_TOKEN: "dummy-bearer", UPSTREAM_ACCESS_CLIENT_ID: "dummy-upstream-id", UPSTREAM_ACCESS_CLIENT_SECRET: "dummy-upstream-secret", WAKE_ACCESS_CLIENT_ID: "dummy-wake-id", WAKE_ACCESS_CLIENT_SECRET: "dummy-wake-secret" };
+	const sealed = await sealWakeSecrets("platform-secret", "sealed-tenant", secrets);
+	assert.ok(sealed);
+	const push = async (version: number, secretsEnc: string) => stub.pushConfig({
+		version, tenantId: "sealed-tenant", name: "sealed", status: "active", ownerTokenHash: await sha256("dummy-owner-token"), secretsEnc,
+		config: { UPSTREAM_URL: "https://upstream.example.com/a2a", UPSTREAM_TOKEN: "plaintext-must-not-win", WAKE_WEBHOOK_URL: "https://hooks.example.com/wake" },
+	});
+	assert.equal((await push(1, sealed)).applied, true);
+	const facade = await stub.owner({ accountId: "dummy-owner", method: "GET", path: "/owner/facade" });
+	assert.equal(facade.status, 200);
+	assert.equal((facade.body as { hasUpstreamToken: boolean }).hasUpstreamToken, true);
+	assert.equal((facade.body as { hasUpstreamAccessServiceToken: boolean }).hasUpstreamAccessServiceToken, true);
+	assert.ok(received.length > 0);
+	for (const request of received) assert.deepEqual(request, { origin: "https://upstream.example.com", bearer: "Bearer dummy-bearer", id: "dummy-upstream-id", secret: "dummy-upstream-secret" });
+	const preview = await stub.owner({ accountId: "dummy-owner", method: "GET", path: "/owner/wake/preview" });
+	assert.equal(preview.status, 200);
+	assert.equal((preview.body as { hasAccessServiceToken: boolean }).hasAccessServiceToken, true);
+	for (const value of Object.values(secrets)) assert.equal(JSON.stringify([facade.body, preview.body]).includes(value), false);
+	const otherTenantBlob = await sealWakeSecrets("platform-secret", "another-tenant", secrets);
+	assert.ok(otherTenantBlob);
+	assert.equal((await push(2, otherTenantBlob)).applied, true);
+	const rejected = await stub.owner({ accountId: "dummy-owner", method: "GET", path: "/owner/facade" });
+	assert.equal((rejected.body as { hasUpstreamToken: boolean }).hasUpstreamToken, false);
+	assert.equal((rejected.body as { hasUpstreamAccessServiceToken: boolean }).hasUpstreamAccessServiceToken, false);
+	const emptyPreview = await stub.owner({ accountId: "dummy-owner", method: "GET", path: "/owner/wake/preview" });
+	assert.equal((emptyPreview.body as { hasAccessServiceToken: boolean }).hasAccessServiceToken, false);
+	assert.equal(received.at(-1)?.bearer, null, "an unreadable blob never falls back to plaintext");
+});

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", "pairing_requests", "send_feedback"]);
+	assert.deepEqual(names, ["inbox", "show_task", "history", "mark_working", "reply", "send", "poll_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/migrations.test.ts

@@ -59,6 +59,10 @@ test("fresh database: every migration applies in order; a second run applies not
 	assert.deepEqual(applyMigrations(db), [...FILES].sort(byNumber));
 	for (const t of ["peers", "tasks", "wakes", "wake_budget", "device_requests", "pairing_rate", "settings", "facade_owners", "oauth_clients", "oauth_codes", "mcp_grants", "outbound_peers", "oauth_client_metadata", "oidc_txns", "conversation_owners", "reply_deliveries"]) assert.ok(tables(db).includes(t), t);
 	assert.ok(columns(db, "peers").includes("source"));
+	assert.ok(columns(db, "peers").includes("identity_key"));
+	assert.ok(columns(db, "peers").includes("card_url"));
+	assert.ok(columns(db, "peers").includes("token_enc"));
+	assert.ok(columns(db, "device_requests").includes("identity_key"));
 	assert.ok(columns(db, "device_requests").includes("replaces_label"));
 	assert.ok(columns(db, "device_requests").includes("replaces_hash"));
 	assert.deepEqual(applyMigrations(db), []);
@@ -67,15 +71,15 @@ test("fresh database: every migration applies in order; a second run applies not
 test("database from the 0002 fix (0001-0003 recorded): only 0004 and later apply; pending requests keep working", () => {
 	const db = existingDb([sql("0001_init.sql"), sql("0002_wake_budget.sql"), sql("0003_device_pairing.sql")], ["0001_init.sql", "0002_wake_budget.sql", "0003_device_pairing.sql"]);
 	db.prepare("INSERT INTO device_requests (device_hash, user_code, status, created_ms, expires_ms, interval_s) VALUES ('h', 'WDJB4827', 'pending', 1, 2, 5)").run();
-	assert.deepEqual(applyMigrations(db), ["0004_pairing_replace.sql", "0005_facade_owners.sql", "0006_mcp.sql", "0007_cimd.sql", "0008_oidc_txns.sql", "0009_outbound_seen.sql", "0010_conversation_peer.sql", "0011_conversation_owner.sql", "0012_conversation_peer_owner.sql", "0013_reply_delivery.sql"]);
+	assert.deepEqual(applyMigrations(db), ["0004_pairing_replace.sql", "0005_facade_owners.sql", "0006_mcp.sql", "0007_cimd.sql", "0008_oidc_txns.sql", "0009_outbound_seen.sql", "0010_conversation_peer.sql", "0011_conversation_owner.sql", "0012_conversation_peer_owner.sql", "0013_reply_delivery.sql", "0014_peer_address.sql", "0015_outbound_source.sql"]);
 	assert.equal((db.prepare("SELECT replaces_label FROM device_requests WHERE device_hash = 'h'").get() as any).replaces_label, null);
 });
 
 test("database from v0.2.0 (0001 and 0003 recorded): 0002 applies as a no-op and keeps the data", () => {
 	const db = existingDb([sql("0001_init.sql"), sql("0003_device_pairing.sql")], ["0001_init.sql", "0003_device_pairing.sql"]);
 	db.prepare("INSERT INTO wake_budget (hour, count) VALUES (1, 7)").run();
-	assert.deepEqual(applyMigrations(db), ["0002_wake_budget.sql", "0004_pairing_replace.sql", "0005_facade_owners.sql", "0006_mcp.sql", "0007_cimd.sql", "0008_oidc_txns.sql", "0009_outbound_seen.sql", "0010_conversation_peer.sql", "0011_conversation_owner.sql", "0012_conversation_peer_owner.sql", "0013_reply_delivery.sql"]);
-	assert.deepEqual(recorded(db), ["0001_init.sql", "0003_device_pairing.sql", "0002_wake_budget.sql", "0004_pairing_replace.sql", "0005_facade_owners.sql", "0006_mcp.sql", "0007_cimd.sql", "0008_oidc_txns.sql", "0009_outbound_seen.sql", "0010_conversation_peer.sql", "0011_conversation_owner.sql", "0012_conversation_peer_owner.sql", "0013_reply_delivery.sql"]);
+	assert.deepEqual(applyMigrations(db), ["0002_wake_budget.sql", "0004_pairing_replace.sql", "0005_facade_owners.sql", "0006_mcp.sql", "0007_cimd.sql", "0008_oidc_txns.sql", "0009_outbound_seen.sql", "0010_conversation_peer.sql", "0011_conversation_owner.sql", "0012_conversation_peer_owner.sql", "0013_reply_delivery.sql", "0014_peer_address.sql", "0015_outbound_source.sql"]);
+	assert.deepEqual(recorded(db), ["0001_init.sql", "0003_device_pairing.sql", "0002_wake_budget.sql", "0004_pairing_replace.sql", "0005_facade_owners.sql", "0006_mcp.sql", "0007_cimd.sql", "0008_oidc_txns.sql", "0009_outbound_seen.sql", "0010_conversation_peer.sql", "0011_conversation_owner.sql", "0012_conversation_peer_owner.sql", "0013_reply_delivery.sql", "0014_peer_address.sql", "0015_outbound_source.sql"]);
 	assert.equal((db.prepare("SELECT count FROM wake_budget WHERE hour = 1").get() as any).count, 7);
 });
 
@@ -107,7 +111,7 @@ test("database from an earlier build without wake_budget (0001 and 0003 recorded
 		assert.equal(before.data.error?.code, -32603, JSON.stringify(before.data));
 		assert.equal(wakes.length, 0);
 
-		assert.deepEqual(applyMigrations(db), ["0002_wake_budget.sql", "0004_pairing_replace.sql", "0005_facade_owners.sql", "0006_mcp.sql", "0007_cimd.sql", "0008_oidc_txns.sql", "0009_outbound_seen.sql", "0010_conversation_peer.sql", "0011_conversation_owner.sql", "0012_conversation_peer_owner.sql", "0013_reply_delivery.sql"]);
+		assert.deepEqual(applyMigrations(db), ["0002_wake_budget.sql", "0004_pairing_replace.sql", "0005_facade_owners.sql", "0006_mcp.sql", "0007_cimd.sql", "0008_oidc_txns.sql", "0009_outbound_seen.sql", "0010_conversation_peer.sql", "0011_conversation_owner.sql", "0012_conversation_peer_owner.sql", "0013_reply_delivery.sql", "0014_peer_address.sql", "0015_outbound_source.sql"]);
 		assert.deepEqual(columns(db, "wake_budget"), ["hour", "count"]);
 		assert.deepEqual(applyMigrations(db), []);
 
@@ -169,3 +173,16 @@ test("0012 lets each peer own the same context id and keeps the first row", () =
 	const peers = db.prepare("SELECT peer FROM conversation_owners WHERE context_id = 'ctx-y' ORDER BY peer").all() as { peer: string }[];
 	assert.deepEqual(peers.map((r) => r.peer), ["ada", "bob"]);
 });
+
+test("0014 adds address columns and keeps an existing peer token", () => {
+	const prior = [...FILES].sort(byNumber).filter((f) => f !== "0014_peer_address.sql");
+	const db = existingDb(prior.map(sql), prior);
+	db.prepare("INSERT INTO peers (label, token_hash, created_at, source, user_code, client_name) VALUES ('ada', 'hash', '2026-01-01T00:00:00.000Z', 'pairing', 'WDJB4827', 'Ada')").run();
+	assert.deepEqual(applyMigrations(db), ["0014_peer_address.sql"]);
+	const row = db.prepare("SELECT token_hash, identity_key, card_url, token_enc FROM peers WHERE label = 'ada'").get() as { token_hash: string; identity_key: string | null; card_url: string | null; token_enc: string | null };
+	assert.equal(row.token_hash, "hash");
+	assert.equal(row.identity_key, null);
+	assert.equal(row.card_url, null);
+	assert.equal(row.token_enc, null);
+	assert.ok(columns(db, "device_requests").includes("identity_key"));
+});

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

@@ -20,15 +20,25 @@ async function fixture(t: Parameters<typeof test>[1] extends (t: infer T) => unk
 	};
 	const byId = new Map<string, TenantContext>();
 	let directPosts = 0;
+	const cards: string[] = [];
+	let missingCard = false;
 	let hold: Promise<void> | null = null;
+	let posted: (() => void) | null = null;
+	let aborted = false;
 	const ns: DoNamespace = {
 		idFromName(name: string) { return name; },
 		get(id: unknown) {
 			return { async fetch(req: Request) {
 				const ctx = byId.get(String(id));
 				if (!ctx) return new Response("missing", { status: 404 });
+				if (req.method === "GET" && new URL(req.url).pathname.startsWith("/.well-known/agent")) {
+					cards.push(new URL(req.url).pathname);
+					if (missingCard) return new Response("missing", { status: 404 });
+				}
 				if (req.method === "POST" && new URL(req.url).pathname === "/") {
 					directPosts++;
+					posted?.();
+					req.signal.addEventListener("abort", () => { aborted = true; }, { once: true });
 					if (hold) await hold;
 				}
 				return dispatch(req, ctx, ectx as never);
@@ -61,10 +71,11 @@ 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, get directPosts() { return directPosts; }, blockDirect() {
+	return { a, b, dbA, dbB, owner, sendToBob, cards, missingCard() { missingCard = true; }, get directPosts() { return directPosts; }, get aborted() { return aborted; }, blockDirect() {
 		let release!: () => void;
 		hold = new Promise<void>((resolve) => { release = resolve; });
-		return () => { hold = null; release(); };
+		const started = new Promise<void>((resolve) => { posted = resolve; });
+		return Object.assign(() => { hold = null; posted = null; release(); }, { started });
 	} };
 }
 
@@ -129,8 +140,9 @@ test("stale recovery never overlaps an uncertain delivery and a later retry read
 	const s = await fixture(t as never);
 	const taskId = await s.sendToBob("concurrent question", "ctx-concurrent");
 	const release = s.blockDirect();
+	t.after(release);
 	const first = s.owner(s.b, "acct-bob", "POST", "/owner/mcp/reply", { taskId, text: "one answer" });
-	while (s.directPosts === 0) await new Promise((resolve) => setTimeout(resolve, 0));
+	await release.started;
 	await s.dbB.prepare("UPDATE reply_deliveries SET updated_at = '2000-01-01T00:00:00.000Z'").run();
 	const raced = await s.owner(s.b, "acct-bob", "POST", "/owner/mcp/reply", { taskId, text: "one answer" });
 	assert.equal(raced.status, 200);
@@ -138,11 +150,48 @@ test("stale recovery never overlaps an uncertain delivery and a later retry read
 	assert.match(String((raced.body as any).structuredContent.detail), /uncertain.*not sent again/);
 	assert.equal(s.directPosts, 1, "the overlapping call cannot start a second delivery");
 	release();
-	assert.equal(((await first).body as any).structuredContent.status, "delivered");
+	assert.deepEqual(((await first).body as any).structuredContent, (raced.body as any).structuredContent, "a late success cannot replace the recorded uncertain result");
 	const retry = await s.owner(s.b, "acct-bob", "POST", "/owner/mcp/reply", { taskId, text: "one answer" });
 	assert.equal(retry.status, 200);
-	assert.equal((retry.body as any).structuredContent.status, "delivered");
+	assert.deepEqual((retry.body as any).structuredContent, (raced.body as any).structuredContent);
+	assert.equal(s.directPosts, 1);
+});
+
+test("an identical retry during delivery reports in-flight before the stored completed state", async (t) => {
+	const s = await fixture(t as never);
+	const taskId = await s.sendToBob("retry question", "ctx-in-flight");
+	const release = s.blockDirect();
+	t.after(release);
+	const first = s.owner(s.b, "acct-bob", "POST", "/owner/mcp/reply", { taskId, text: "one answer" });
+	await release.started;
+	const retry = await s.owner(s.b, "acct-bob", "POST", "/owner/mcp/reply", { taskId, text: "one answer" });
+	assert.equal(retry.status, 200);
+	assert.equal((retry.body as any).isError, true);
+	assert.match(String((retry.body as any).text), /already being delivered/);
+	assert.equal(s.directPosts, 1);
+	release();
+	assert.equal(((await first).body as any).structuredContent.status, "delivered");
+});
+
+test("the total delivery deadline returns while a peer ignores cancellation and retries never resend", async (t) => {
+	const s = await fixture(t as never);
+	const taskId = await s.sendToBob("slow question", "ctx-deadline");
+	const release = s.blockDirect();
+	t.after(release);
+	t.mock.timers.enable({ apis: ["setTimeout"] });
+	t.after(() => t.mock.timers.reset());
+	const first = s.owner(s.b, "acct-bob", "POST", "/owner/mcp/reply", { taskId, text: "bounded answer" });
+	await release.started;
+	t.mock.timers.tick(18000);
+	t.mock.timers.reset();
+	const result = await first;
+	assert.equal(result.status, 200);
+	assert.equal((result.body as any).structuredContent.status, "delivery-failed");
+	assert.equal(s.aborted, true, "the deadline reaches the actual peer request signal");
+	const retry = await s.owner(s.b, "acct-bob", "POST", "/owner/mcp/reply", { taskId, text: "bounded answer" });
+	assert.deepEqual((retry.body as any).structuredContent, (result.body as any).structuredContent);
 	assert.equal(s.directPosts, 1);
+	release();
 });
 
 test("a remote token rejection reports HTTP status without losing the stored reply", async (t) => {
@@ -159,3 +208,14 @@ test("a remote token rejection reports HTTP status without losing the stored rep
 	assert.equal(stored.state, "completed");
 	assert.match(stored.status_json, /the answer stays/);
 });
+
+
+test("reply discovers one canonical card and uses the paired base when it is missing", async (t) => {
+	const s = await fixture(t as never);
+	const taskId = await s.sendToBob("no card question", "ctx-one-card");
+	s.missingCard();
+	const result = await s.owner(s.b, "acct-bob", "POST", "/owner/mcp/reply", { taskId, text: "stored answer" });
+	assert.equal((result.body as any).structuredContent.status, "delivered");
+	assert.deepEqual(s.cards, ["/.well-known/agent-card.json"]);
+	assert.equal(s.directPosts, 1);
+});

package/worker/test/wake-target.test.ts

@@ -320,3 +320,13 @@ test("public-https does not request a metadata address, and does post to a check
 	assert.equal(tls.status, null);
 	assert.equal(tls.info, "Error: TLS Handshake Failed.");
 });
+
+
+test("an aborted peer request starts neither DNS lookup nor delivery", async () => {
+	const controller = new AbortController();
+	controller.abort(new Error("delivery deadline"));
+	await assert.rejects(() => fetchCheckedPeer("https://hook.example/rpc", { signal: controller.signal }, {
+		async lookup() { assert.fail("aborted request must not resolve DNS"); },
+		async deliver() { assert.fail("aborted request must not send"); },
+	}), /delivery deadline/);
+});