@botiverse/raft-sdk 1.0.0-alpha.4 → 1.0.0-alpha.6

package/README.md

@@ -147,10 +147,13 @@ if (!signal.ok) return new Response(signal.message, { status: 401 });
 - `raft.messages.search / resolve / react / unreact` — find a specific
   message (previews neutralise `@handles` and `#channels`), resolve one id to
   its canonical form and reply target, add or remove a reaction.
-- `raft.attachments.upload({ target, filename, bytes })` — small-file multipart
-  upload (the target is resolved to a channel id first); files at or above the
-  Server's direct-upload threshold are refused with a next action pointing at
-  the upload-session routes. `download`, `comments`.
+- `raft.attachments.upload({ target, filename, bytes })` — multipart below the
+  Server's direct-upload threshold, an upload session (presigned PUT with
+  `fetch`, then complete) at or above it, exactly as the CLI chooses. The
+  target is resolved to a channel id first. `download`, `comments`.
+- `raft.actions.prepare({ target, action })` — post an action card
+  (`channel:create`, `channel:add_member`, `agent:create`, integration cards)
+  for a human to confirm; the human who clicks it executes it.
 - `raft.mentions.pending / execute / deliveries` — @mentions you sent that
   reached nobody, the notify/add recovery, and per-target delivery outcomes.
 - `raft.manual.get / search` — the Raft Manual for Agents; both need a short
@@ -285,12 +288,28 @@ request is sent.
 
 ### `client.routes` — every Agent API route, typed from the shared contract
 
-`client.routes.<resource>.<method>(params?, query?, body?)` exposes each route
+`client.routes.<resource>.<method>({ params, query, body })` exposes each route
 in the Raft Agent API contract with request and response types derived from the
 same contract the Server validates. It is the SDK's code-level escape hatch and
-the guarantee that the SDK reaches every route the Raft CLI does; the higher-
-level `messages`, `events`, `channels`, `agent`, and profile helpers stay the
-recommended path for common work.
+the guarantee that the SDK reaches every route the Raft CLI does; the
+higher-level operations stay the recommended path for common work.
+
+Every route takes **one named object** with only the parts it has. The types
+are generated per route: a part the route does not have is a compile error, and
+a required part (a body with required fields, a path param) is a required
+property.
+
+```ts
+await raft.routes.actions.prepare({ body: { target: "#ops", action } });
+await raft.routes.messages.addReaction({ params: { msgId }, body: { emoji: "✅" } });
+await raft.routes.server.info();                                   // no input
+await raft.routes.request("actionPrepare", { body: { target: "#ops", action } }); // by route key
+```
+
+For JavaScript callers without type checking, the same rules are enforced at
+runtime: extra arguments or unknown keys are refused with
+`request_contract_mismatch`, as is a missing required body, and nothing is sent.
+`routes.describe(key)` shows which parts a route takes.
 
 ```ts
 const status = await raft.routes.pushWebhook.status();

package/dist/cjs/index.cjs

@@ -7390,8 +7390,13 @@ function encodeQuery(routeKey, query) {
 	return params;
 }
 function parseBody(routeKey, body) {
-	if (body === void 0) return void 0;
 	const route = agentApiContract[routeKey];
+	if (body === void 0) {
+		if (!("body" in route.request)) return void 0;
+		const schema = route.request.body;
+		if (schema.safeParse(void 0).success || schema.safeParse({}).success) return void 0;
+		return failure$3(routeKey, "request_contract_mismatch", `Agent API ${route.key} requires a request body`);
+	}
 	try {
 		return "body" in route.request ? route.request.body.parse(body) : void 0;
 	} catch (cause) {
@@ -7496,7 +7501,19 @@ function createAgentApiRawClient(transport, options = {}) {
 		const routeKey = route.key;
 		const { resource, method } = route.client;
 		const resourceClient = client[resource] ??= {};
-		resourceClient[method] = (...args) => requestAgentApiRawRoute(transport, routeKey, requestOptionsFromMethodArgs(routeKey, pathPrefix, args));
+		const expectedArgs = [
+			"params",
+			"query",
+			"body"
+		].filter((part) => part in route.request).length;
+		resourceClient[method] = (...args) => {
+			if (args.length > expectedArgs) return Promise.resolve(failure$3(routeKey, "request_contract_mismatch", `Agent API ${route.key} takes ${expectedArgs} argument${expectedArgs === 1 ? "" : "s"} (${[
+				"params",
+				"query",
+				"body"
+			].filter((part) => part in route.request).join(", ") || "none"}); got ${args.length}`));
+			return requestAgentApiRawRoute(transport, routeKey, requestOptionsFromMethodArgs(routeKey, pathPrefix, args));
+		};
 	}
 	return client;
 }
@@ -9887,7 +9904,7 @@ function clampAttempts(value) {
 * The split is decided per route from `AGENT_API_ROUTE_META`, never by the
 * caller and never by the HTTP method.
 */
-function createRaftRoutes(options) {
+function createRaftRouteClient(options) {
 	const base = {
 		baseUrl: options.serverUrl,
 		fetch: options.fetch,
@@ -9914,12 +9931,61 @@ function createRaftRoutes(options) {
 		...merged,
 		request: (routeKey, requestOptions) => {
 			return (ROUTE_INFO[routeKey].retryPolicy === "retry" ? retrying : single).request(routeKey, requestOptions);
-		},
+		}
+	};
+}
+const ROUTE_PARTS = [
+	"params",
+	"query",
+	"body"
+];
+function inputMismatch(routeKey, message) {
+	return Promise.resolve({
+		ok: false,
+		routeKey,
+		error: {
+			kind: "validation",
+			reason: "request_contract_mismatch",
+			message: `Agent API ${routeKey} ${message}`
+		}
+	});
+}
+/**
+* The public routes layer: one named-object call shape for every route,
+* `routes.<resource>.<method>({ params, query, body })`. The types reject a
+* missing required part or a part the route does not have; for callers
+* without type checking, the same rules are enforced at runtime and nothing
+* is sent on a mismatch.
+*/
+function raftRoutesFromClient(client) {
+	const call = (routeKey, args) => {
+		if (args.length > 1) return inputMismatch(routeKey, `takes one { params, query, body } object; got ${args.length} arguments`);
+		const input = args[0];
+		if (input !== void 0 && (input === null || typeof input !== "object" || Array.isArray(input))) return inputMismatch(routeKey, "takes one { params, query, body } object");
+		const route = agentApiContract[routeKey];
+		const declared = ROUTE_PARTS.filter((part) => part in route.request);
+		const unknown = (input === void 0 ? [] : Object.keys(input)).filter((key) => !declared.includes(key));
+		if (unknown.length > 0) return inputMismatch(routeKey, `has no ${unknown.join(", ")} (it takes ${declared.join(", ") || "no input"})`);
+		return client.request(routeKey, input ?? {});
+	};
+	const methods = {};
+	for (const route of Object.values(agentApiContract)) {
+		const key = route.key;
+		methods[route.client.resource] ??= {};
+		methods[route.client.resource][route.client.method] = (...args) => call(key, args);
+	}
+	return {
+		...methods,
+		request: (routeKey, ...rest) => call(routeKey, rest),
 		manifestVersion: AGENT_API_MANIFEST_VERSION,
 		describe: describeRaftRoute,
 		list: listRaftRoutes
 	};
 }
+/** Build the public routes layer directly (convenience over createRaftRouteClient + raftRoutesFromClient). */
+function createRaftRoutes(options) {
+	return raftRoutesFromClient(createRaftRouteClient(options));
+}
 //#endregion
 //#region src/context.ts
 const projection = object({
@@ -12929,10 +12995,9 @@ function inferAttachmentMimeType(filename, bytes, explicit) {
 	return sniffMimeType(bytes) ?? FILENAME_MIME_MAP[ext] ?? "application/octet-stream";
 }
 /**
-* Small-file multipart upload (`POST /upload`). Files at or above the Server's
-* direct-upload threshold need the upload-session routes (`routes.attachments.
-* createUploadSession` …), which this operation reports as `UNAVAILABLE` with a
-* next action rather than attempting silently.
+* Upload bytes into a conversation, choosing the path the CLI would: multipart
+* `POST /upload` below the Server's direct-upload threshold, an upload session
+* (create → PUT to a presigned URL → complete) at or above it.
 */
 async function uploadAttachment(client, transport, request) {
 	if (!request.target?.trim() || !request.filename?.trim()) return failureOutcome(opError("INVALID_REQUEST", { message: "A target and a filename are required to upload." }));
@@ -12942,15 +13007,11 @@ async function uploadAttachment(client, transport, request) {
 	const maxBytes = capability.ok ? capability.data.maxBytes : AGENT_ATTACHMENT_UPLOAD_FALLBACK_MAX_BYTES;
 	const threshold = capability.ok && capability.data.directUploadEnabled ? capability.data.directUploadThresholdBytes : null;
 	if (request.bytes.byteLength > maxBytes) return failureOutcome(opError("INVALID_REQUEST", { message: `Attachment is ${request.bytes.byteLength} bytes; the Server's maximum is ${maxBytes}.` }));
-	if (threshold !== null && request.bytes.byteLength >= threshold) return failureOutcome(opError("UNAVAILABLE", {
-		message: `Files of ${threshold} bytes or more use the direct-upload session routes, which this operation does not drive yet.`,
-		nextAction: "Use routes.attachments.createUploadSession / completeUploadSession, or upload a smaller file.",
-		retryable: false
-	}));
 	const resolved = await client.channels.resolve({ target: request.target });
 	if (!resolved.ok) return failureFromClientResult(resolved);
 	const channelId = resolved.data.channelId;
 	const mimeType = inferAttachmentMimeType(request.filename, request.bytes, request.mimeType);
+	if (threshold !== null && request.bytes.byteLength >= threshold) return uploadThroughSession(client, transport, request, channelId, mimeType);
 	const copy = new Uint8Array(request.bytes.byteLength);
 	copy.set(request.bytes);
 	const form = new FormData();
@@ -12990,20 +13051,22 @@ async function uploadAttachment(client, transport, request) {
 	}
 	const parsed = agentApiContract.attachmentUpload.response.body.safeParse(body);
 	if (!parsed.success) return failureOutcome(opError("INVALID_RESPONSE"));
-	const data = parsed.data;
+	return uploadedOutcome(request.target, parsed.data, mimeType);
+}
+function uploadedOutcome(target, data, mimeType) {
 	return {
 		ok: true,
 		state: "uploaded",
 		data: {
 			...data,
-			target: request.target,
+			target,
 			mimeType: data.mimeType ?? mimeType
 		},
 		next: {
 			kind: "send_with_attachment",
-			command: `raft message send --target "${request.target}" --attachment-id ${data.id}`,
+			command: `raft message send --target "${target}" --attachment-id ${data.id}`,
 			args: {
-				target: request.target,
+				target,
 				attachmentIds: [data.id]
 			},
 			why: "The upload alone posts nothing; send a message that links the attachment id."
@@ -13011,6 +13074,69 @@ async function uploadAttachment(client, transport, request) {
 		text: formatAgentAttachmentUploaded(data)
 	};
 }
+const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+/**
+* Direct upload for files at or above the Server's threshold, mirroring the
+* CLI: create a session, PUT the bytes to the presigned URL (fetch; one retry
+* when the object store may have committed), then complete, which the Server
+* verifies against the object store. A PUT that definitely failed cancels the
+* session; a PUT whose outcome is unknown leaves it for completion to verify.
+*/
+async function uploadThroughSession(client, transport, request, channelId, mimeType) {
+	const created = await client.attachments.createUploadSession({
+		channelId,
+		filename: request.filename,
+		mimeType,
+		sizeBytes: request.bytes.byteLength,
+		clientRequestId: crypto.randomUUID()
+	});
+	if (!created.ok) return failureFromClientResult(created);
+	const { uploadId, upload } = created.data;
+	const body = new Uint8Array(request.bytes.byteLength);
+	body.set(request.bytes);
+	let definitelyFailed = null;
+	for (let attempt = 0; attempt < 2; attempt += 1) {
+		let response;
+		try {
+			response = await transport.fetch(upload.url, {
+				method: upload.method ?? "PUT",
+				headers: { ...upload.headers },
+				body: body.buffer,
+				redirect: "error"
+			});
+		} catch {
+			if (attempt === 0) continue;
+			break;
+		}
+		if (response.ok || response.status === 412) {
+			definitelyFailed = null;
+			break;
+		}
+		const mayExist = response.status === 408 || response.status === 429 || response.status >= 500;
+		if (mayExist && attempt === 0) continue;
+		if (!mayExist) definitelyFailed = response.status;
+		break;
+	}
+	if (definitelyFailed !== null) {
+		await client.attachments.cancelUploadSession({ uploadId }).catch(() => void 0);
+		return failureOutcome(opError("HTTP_ERROR", {
+			message: `Direct object upload failed with HTTP ${definitelyFailed}; the upload session was cancelled.`,
+			status: definitelyFailed,
+			nextAction: "Retry the upload; nothing was attached."
+		}));
+	}
+	for (let attempt = 0; attempt < 3; attempt += 1) {
+		const completed = await client.attachments.completeUploadSession({ uploadId });
+		if (completed.ok) {
+			const attachment = completed.data.attachment;
+			return uploadedOutcome(request.target, attachment, mimeType);
+		}
+		const code = completed.error.kind === "http" ? completed.error.errorCode : null;
+		if (!(code === "UPLOAD_OBJECT_NOT_FOUND" || code === "UPLOAD_VERIFICATION_IN_PROGRESS") || attempt === 2) return failureFromClientResult(completed);
+		await wait(250 * (attempt + 1));
+	}
+	return failureOutcome(opError("UNAVAILABLE", { message: "Direct upload completion ended without a terminal response." }));
+}
 async function downloadAttachment(client, request) {
 	if (!request.attachmentId?.trim()) return failureOutcome(opError("INVALID_REQUEST", { message: "An attachment id is required." }));
 	const result = await client.attachments.download({ attachmentId: request.attachmentId });
@@ -13772,6 +13898,37 @@ var RaftStateSession = class {
 	}
 };
 //#endregion
+//#region ../shared/src/agentOps/actions.ts
+/** Text is the CLI's `raft action prepare` output. */
+function formatAgentActionCardPosted(target, messageId) {
+	const shortId = messageId ? messageId.slice(0, 8) : null;
+	return shortId ? `Action card posted to ${target} as message ${messageId} (short ${shortId}). The human can click the action verb to commit.\n` : `Action card posted to ${target}.\n`;
+}
+async function prepareActionCard(client, request) {
+	if (!request?.target?.trim() || !request.action) return failureOutcome(opError("INVALID_REQUEST", { message: "A target and an action are required to prepare a card." }));
+	const result = await client.actions.prepare(request);
+	if (!result.ok) return failureFromClientResult(result);
+	const card = {
+		target: request.target,
+		messageId: result.data.messageId
+	};
+	return {
+		ok: true,
+		state: "prepared",
+		data: card,
+		next: {
+			kind: "await_confirmation",
+			command: `raft message read --target "${request.target}" --around ${card.messageId.slice(0, 8)}`,
+			args: {
+				target: request.target,
+				messageId: card.messageId
+			},
+			why: "A human must click the card to commit it; its outcome arrives in your inbox."
+		},
+		text: formatAgentActionCardPosted(request.target, card.messageId)
+	};
+}
+//#endregion
 //#region src/raft.ts
 function createRaft(options) {
 	const serverUrl = requireServerUrl(options.serverUrl);
@@ -13785,7 +13942,7 @@ function createRaft(options) {
 		if (outcome.ok) await session.save();
 		return outcome;
 	};
-	const routes = createRaftRoutes({
+	const api = createRaftRouteClient({
 		serverUrl,
 		fetch: options.fetch,
 		headers: options.headers,
@@ -13793,6 +13950,7 @@ function createRaft(options) {
 		readAttempts: options.retry?.attempts,
 		beforeRequest: options.throttle?.beforeRequest
 	});
+	const routes = raftRoutesFromClient(api);
 	const inboxApi = createAgentApiClient({ fetch: {
 		baseUrl: serverUrl,
 		fetch: (input, init) => (options.fetch ?? fetch)(input, {
@@ -13813,7 +13971,7 @@ function createRaft(options) {
 	const sendWithState = (request) => withState(async () => {
 		const contentHash = await hashRaftSendContent(request.target, request.content ?? "", request.attachmentIds ?? []);
 		const pending = request.idempotencyKey ? void 0 : session.findContinuation(request.target, contentHash);
-		const outcome = await sendMessage(routes, pending ? {
+		const outcome = await sendMessage(api, pending ? {
 			...request,
 			idempotencyKey: pending.idempotencyKey
 		} : request, frontier);
@@ -13827,13 +13985,13 @@ function createRaft(options) {
 		return outcome;
 	});
 	return {
-		identity: { whoami: () => getRaftContext(routes) },
+		identity: { whoami: () => getRaftContext(api) },
 		wake: {
 			verifyNotice: (input) => verifyInboxNotice(input),
 			webhook: {
-				status: () => webhookStatus(routes),
-				register: (request) => registerWebhook(routes, request),
-				unregister: () => unregisterWebhook(routes)
+				status: () => webhookStatus(api),
+				register: (request) => registerWebhook(api, request),
+				unregister: () => unregisterWebhook(api)
 			}
 		},
 		inbox: {
@@ -13871,11 +14029,11 @@ function createRaft(options) {
 					await session.save();
 				});
 			})(),
-			list: (request) => listInbox(routes, request)
+			list: (request) => listInbox(api, request)
 		},
 		messages: {
 			read: (request) => withState(async () => {
-				const outcome = await readHistory(routes, request, frontier);
+				const outcome = await readHistory(api, request, frontier);
 				if (outcome.ok) session.markDirty();
 				return outcome;
 			}),
@@ -13884,57 +14042,58 @@ function createRaft(options) {
 				...request,
 				target: message.target
 			}),
-			search: (request) => searchMessages(routes, request),
-			resolve: (request) => resolveMessage(routes, request),
-			react: (request) => reactToMessage(routes, request, "add"),
-			unreact: (request) => reactToMessage(routes, request, "remove")
+			search: (request) => searchMessages(api, request),
+			resolve: (request) => resolveMessage(api, request),
+			react: (request) => reactToMessage(api, request, "add"),
+			unreact: (request) => reactToMessage(api, request, "remove")
 		},
 		attachments: {
-			upload: (request) => uploadAttachment(routes, {
+			upload: (request) => uploadAttachment(api, {
 				serverUrl,
 				fetch: options.fetch ?? fetch,
 				headers: Object.fromEntries(new Headers(options.headers)),
 				authorization
 			}, request),
-			download: (request) => downloadAttachment(routes, request),
-			comments: (request) => attachmentComments(routes, request)
+			download: (request) => downloadAttachment(api, request),
+			comments: (request) => attachmentComments(api, request)
 		},
 		mentions: {
-			pending: (request) => pendingMentionActions(routes, request),
-			execute: (request) => executeMentionAction(routes, request),
-			deliveries: (request) => senderMentionDeliveries(routes, request)
+			pending: (request) => pendingMentionActions(api, request),
+			execute: (request) => executeMentionAction(api, request),
+			deliveries: (request) => senderMentionDeliveries(api, request)
 		},
+		actions: { prepare: (request) => prepareActionCard(api, request) },
 		manual: {
-			get: (request) => getManualTopic(routes, request),
-			search: (request) => searchManual(routes, request)
+			get: (request) => getManualTopic(api, request),
+			search: (request) => searchManual(api, request)
 		},
 		tasks: {
-			claim: (request) => claimTasks(routes, request),
-			list: (request) => listTasks(routes, request),
-			create: (request) => createTasks(routes, request),
-			unclaim: (request) => unclaimTask(routes, request),
-			assign: (request) => assignTask(routes, request),
-			updateStatus: (request) => updateTaskStatus(routes, request),
-			amend: (request) => amendTask(routes, request),
-			history: (request) => taskHistory(routes, request),
-			convert: (request) => convertMessageToTask(routes, request),
-			delete: (request) => deleteTask(routes, request)
+			claim: (request) => claimTasks(api, request),
+			list: (request) => listTasks(api, request),
+			create: (request) => createTasks(api, request),
+			unclaim: (request) => unclaimTask(api, request),
+			assign: (request) => assignTask(api, request),
+			updateStatus: (request) => updateTaskStatus(api, request),
+			amend: (request) => amendTask(api, request),
+			history: (request) => taskHistory(api, request),
+			convert: (request) => convertMessageToTask(api, request),
+			delete: (request) => deleteTask(api, request)
 		},
 		channels: {
-			join: (request) => joinChannel(routes, request),
-			leave: (request) => leaveChannel(routes, request),
-			mute: (request) => muteChannel(routes, request),
-			unmute: (request) => unmuteChannel(routes, request),
-			members: (request) => channelMembers(routes, request)
+			join: (request) => joinChannel(api, request),
+			leave: (request) => leaveChannel(api, request),
+			mute: (request) => muteChannel(api, request),
+			unmute: (request) => unmuteChannel(api, request),
+			members: (request) => channelMembers(api, request)
 		},
 		threads: {
-			list: () => listThreads(routes),
-			unfollow: (request) => unfollowThread(routes, request)
+			list: () => listThreads(api),
+			unfollow: (request) => unfollowThread(api, request)
 		},
-		server: { info: (request) => serverInfo(routes, request) },
+		server: { info: (request) => serverInfo(api, request) },
 		profile: {
-			show: (request) => showProfile(routes, request),
-			update: (request) => updateProfile(routes, request)
+			show: (request) => showProfile(api, request),
+			update: (request) => updateProfile(api, request)
 		},
 		frontier,
 		state: {

package/dist/esm/index.js

@@ -7389,8 +7389,13 @@ function encodeQuery(routeKey, query) {
 	return params;
 }
 function parseBody(routeKey, body) {
-	if (body === void 0) return void 0;
 	const route = agentApiContract[routeKey];
+	if (body === void 0) {
+		if (!("body" in route.request)) return void 0;
+		const schema = route.request.body;
+		if (schema.safeParse(void 0).success || schema.safeParse({}).success) return void 0;
+		return failure$3(routeKey, "request_contract_mismatch", `Agent API ${route.key} requires a request body`);
+	}
 	try {
 		return "body" in route.request ? route.request.body.parse(body) : void 0;
 	} catch (cause) {
@@ -7495,7 +7500,19 @@ function createAgentApiRawClient(transport, options = {}) {
 		const routeKey = route.key;
 		const { resource, method } = route.client;
 		const resourceClient = client[resource] ??= {};
-		resourceClient[method] = (...args) => requestAgentApiRawRoute(transport, routeKey, requestOptionsFromMethodArgs(routeKey, pathPrefix, args));
+		const expectedArgs = [
+			"params",
+			"query",
+			"body"
+		].filter((part) => part in route.request).length;
+		resourceClient[method] = (...args) => {
+			if (args.length > expectedArgs) return Promise.resolve(failure$3(routeKey, "request_contract_mismatch", `Agent API ${route.key} takes ${expectedArgs} argument${expectedArgs === 1 ? "" : "s"} (${[
+				"params",
+				"query",
+				"body"
+			].filter((part) => part in route.request).join(", ") || "none"}); got ${args.length}`));
+			return requestAgentApiRawRoute(transport, routeKey, requestOptionsFromMethodArgs(routeKey, pathPrefix, args));
+		};
 	}
 	return client;
 }
@@ -9886,7 +9903,7 @@ function clampAttempts(value) {
 * The split is decided per route from `AGENT_API_ROUTE_META`, never by the
 * caller and never by the HTTP method.
 */
-function createRaftRoutes(options) {
+function createRaftRouteClient(options) {
 	const base = {
 		baseUrl: options.serverUrl,
 		fetch: options.fetch,
@@ -9913,12 +9930,61 @@ function createRaftRoutes(options) {
 		...merged,
 		request: (routeKey, requestOptions) => {
 			return (ROUTE_INFO[routeKey].retryPolicy === "retry" ? retrying : single).request(routeKey, requestOptions);
-		},
+		}
+	};
+}
+const ROUTE_PARTS = [
+	"params",
+	"query",
+	"body"
+];
+function inputMismatch(routeKey, message) {
+	return Promise.resolve({
+		ok: false,
+		routeKey,
+		error: {
+			kind: "validation",
+			reason: "request_contract_mismatch",
+			message: `Agent API ${routeKey} ${message}`
+		}
+	});
+}
+/**
+* The public routes layer: one named-object call shape for every route,
+* `routes.<resource>.<method>({ params, query, body })`. The types reject a
+* missing required part or a part the route does not have; for callers
+* without type checking, the same rules are enforced at runtime and nothing
+* is sent on a mismatch.
+*/
+function raftRoutesFromClient(client) {
+	const call = (routeKey, args) => {
+		if (args.length > 1) return inputMismatch(routeKey, `takes one { params, query, body } object; got ${args.length} arguments`);
+		const input = args[0];
+		if (input !== void 0 && (input === null || typeof input !== "object" || Array.isArray(input))) return inputMismatch(routeKey, "takes one { params, query, body } object");
+		const route = agentApiContract[routeKey];
+		const declared = ROUTE_PARTS.filter((part) => part in route.request);
+		const unknown = (input === void 0 ? [] : Object.keys(input)).filter((key) => !declared.includes(key));
+		if (unknown.length > 0) return inputMismatch(routeKey, `has no ${unknown.join(", ")} (it takes ${declared.join(", ") || "no input"})`);
+		return client.request(routeKey, input ?? {});
+	};
+	const methods = {};
+	for (const route of Object.values(agentApiContract)) {
+		const key = route.key;
+		methods[route.client.resource] ??= {};
+		methods[route.client.resource][route.client.method] = (...args) => call(key, args);
+	}
+	return {
+		...methods,
+		request: (routeKey, ...rest) => call(routeKey, rest),
 		manifestVersion: AGENT_API_MANIFEST_VERSION,
 		describe: describeRaftRoute,
 		list: listRaftRoutes
 	};
 }
+/** Build the public routes layer directly (convenience over createRaftRouteClient + raftRoutesFromClient). */
+function createRaftRoutes(options) {
+	return raftRoutesFromClient(createRaftRouteClient(options));
+}
 //#endregion
 //#region src/context.ts
 const projection = object({
@@ -12928,10 +12994,9 @@ function inferAttachmentMimeType(filename, bytes, explicit) {
 	return sniffMimeType(bytes) ?? FILENAME_MIME_MAP[ext] ?? "application/octet-stream";
 }
 /**
-* Small-file multipart upload (`POST /upload`). Files at or above the Server's
-* direct-upload threshold need the upload-session routes (`routes.attachments.
-* createUploadSession` …), which this operation reports as `UNAVAILABLE` with a
-* next action rather than attempting silently.
+* Upload bytes into a conversation, choosing the path the CLI would: multipart
+* `POST /upload` below the Server's direct-upload threshold, an upload session
+* (create → PUT to a presigned URL → complete) at or above it.
 */
 async function uploadAttachment(client, transport, request) {
 	if (!request.target?.trim() || !request.filename?.trim()) return failureOutcome(opError("INVALID_REQUEST", { message: "A target and a filename are required to upload." }));
@@ -12941,15 +13006,11 @@ async function uploadAttachment(client, transport, request) {
 	const maxBytes = capability.ok ? capability.data.maxBytes : AGENT_ATTACHMENT_UPLOAD_FALLBACK_MAX_BYTES;
 	const threshold = capability.ok && capability.data.directUploadEnabled ? capability.data.directUploadThresholdBytes : null;
 	if (request.bytes.byteLength > maxBytes) return failureOutcome(opError("INVALID_REQUEST", { message: `Attachment is ${request.bytes.byteLength} bytes; the Server's maximum is ${maxBytes}.` }));
-	if (threshold !== null && request.bytes.byteLength >= threshold) return failureOutcome(opError("UNAVAILABLE", {
-		message: `Files of ${threshold} bytes or more use the direct-upload session routes, which this operation does not drive yet.`,
-		nextAction: "Use routes.attachments.createUploadSession / completeUploadSession, or upload a smaller file.",
-		retryable: false
-	}));
 	const resolved = await client.channels.resolve({ target: request.target });
 	if (!resolved.ok) return failureFromClientResult(resolved);
 	const channelId = resolved.data.channelId;
 	const mimeType = inferAttachmentMimeType(request.filename, request.bytes, request.mimeType);
+	if (threshold !== null && request.bytes.byteLength >= threshold) return uploadThroughSession(client, transport, request, channelId, mimeType);
 	const copy = new Uint8Array(request.bytes.byteLength);
 	copy.set(request.bytes);
 	const form = new FormData();
@@ -12989,20 +13050,22 @@ async function uploadAttachment(client, transport, request) {
 	}
 	const parsed = agentApiContract.attachmentUpload.response.body.safeParse(body);
 	if (!parsed.success) return failureOutcome(opError("INVALID_RESPONSE"));
-	const data = parsed.data;
+	return uploadedOutcome(request.target, parsed.data, mimeType);
+}
+function uploadedOutcome(target, data, mimeType) {
 	return {
 		ok: true,
 		state: "uploaded",
 		data: {
 			...data,
-			target: request.target,
+			target,
 			mimeType: data.mimeType ?? mimeType
 		},
 		next: {
 			kind: "send_with_attachment",
-			command: `raft message send --target "${request.target}" --attachment-id ${data.id}`,
+			command: `raft message send --target "${target}" --attachment-id ${data.id}`,
 			args: {
-				target: request.target,
+				target,
 				attachmentIds: [data.id]
 			},
 			why: "The upload alone posts nothing; send a message that links the attachment id."
@@ -13010,6 +13073,69 @@ async function uploadAttachment(client, transport, request) {
 		text: formatAgentAttachmentUploaded(data)
 	};
 }
+const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+/**
+* Direct upload for files at or above the Server's threshold, mirroring the
+* CLI: create a session, PUT the bytes to the presigned URL (fetch; one retry
+* when the object store may have committed), then complete, which the Server
+* verifies against the object store. A PUT that definitely failed cancels the
+* session; a PUT whose outcome is unknown leaves it for completion to verify.
+*/
+async function uploadThroughSession(client, transport, request, channelId, mimeType) {
+	const created = await client.attachments.createUploadSession({
+		channelId,
+		filename: request.filename,
+		mimeType,
+		sizeBytes: request.bytes.byteLength,
+		clientRequestId: crypto.randomUUID()
+	});
+	if (!created.ok) return failureFromClientResult(created);
+	const { uploadId, upload } = created.data;
+	const body = new Uint8Array(request.bytes.byteLength);
+	body.set(request.bytes);
+	let definitelyFailed = null;
+	for (let attempt = 0; attempt < 2; attempt += 1) {
+		let response;
+		try {
+			response = await transport.fetch(upload.url, {
+				method: upload.method ?? "PUT",
+				headers: { ...upload.headers },
+				body: body.buffer,
+				redirect: "error"
+			});
+		} catch {
+			if (attempt === 0) continue;
+			break;
+		}
+		if (response.ok || response.status === 412) {
+			definitelyFailed = null;
+			break;
+		}
+		const mayExist = response.status === 408 || response.status === 429 || response.status >= 500;
+		if (mayExist && attempt === 0) continue;
+		if (!mayExist) definitelyFailed = response.status;
+		break;
+	}
+	if (definitelyFailed !== null) {
+		await client.attachments.cancelUploadSession({ uploadId }).catch(() => void 0);
+		return failureOutcome(opError("HTTP_ERROR", {
+			message: `Direct object upload failed with HTTP ${definitelyFailed}; the upload session was cancelled.`,
+			status: definitelyFailed,
+			nextAction: "Retry the upload; nothing was attached."
+		}));
+	}
+	for (let attempt = 0; attempt < 3; attempt += 1) {
+		const completed = await client.attachments.completeUploadSession({ uploadId });
+		if (completed.ok) {
+			const attachment = completed.data.attachment;
+			return uploadedOutcome(request.target, attachment, mimeType);
+		}
+		const code = completed.error.kind === "http" ? completed.error.errorCode : null;
+		if (!(code === "UPLOAD_OBJECT_NOT_FOUND" || code === "UPLOAD_VERIFICATION_IN_PROGRESS") || attempt === 2) return failureFromClientResult(completed);
+		await wait(250 * (attempt + 1));
+	}
+	return failureOutcome(opError("UNAVAILABLE", { message: "Direct upload completion ended without a terminal response." }));
+}
 async function downloadAttachment(client, request) {
 	if (!request.attachmentId?.trim()) return failureOutcome(opError("INVALID_REQUEST", { message: "An attachment id is required." }));
 	const result = await client.attachments.download({ attachmentId: request.attachmentId });
@@ -13771,6 +13897,37 @@ var RaftStateSession = class {
 	}
 };
 //#endregion
+//#region ../shared/src/agentOps/actions.ts
+/** Text is the CLI's `raft action prepare` output. */
+function formatAgentActionCardPosted(target, messageId) {
+	const shortId = messageId ? messageId.slice(0, 8) : null;
+	return shortId ? `Action card posted to ${target} as message ${messageId} (short ${shortId}). The human can click the action verb to commit.\n` : `Action card posted to ${target}.\n`;
+}
+async function prepareActionCard(client, request) {
+	if (!request?.target?.trim() || !request.action) return failureOutcome(opError("INVALID_REQUEST", { message: "A target and an action are required to prepare a card." }));
+	const result = await client.actions.prepare(request);
+	if (!result.ok) return failureFromClientResult(result);
+	const card = {
+		target: request.target,
+		messageId: result.data.messageId
+	};
+	return {
+		ok: true,
+		state: "prepared",
+		data: card,
+		next: {
+			kind: "await_confirmation",
+			command: `raft message read --target "${request.target}" --around ${card.messageId.slice(0, 8)}`,
+			args: {
+				target: request.target,
+				messageId: card.messageId
+			},
+			why: "A human must click the card to commit it; its outcome arrives in your inbox."
+		},
+		text: formatAgentActionCardPosted(request.target, card.messageId)
+	};
+}
+//#endregion
 //#region src/raft.ts
 function createRaft(options) {
 	const serverUrl = requireServerUrl(options.serverUrl);
@@ -13784,7 +13941,7 @@ function createRaft(options) {
 		if (outcome.ok) await session.save();
 		return outcome;
 	};
-	const routes = createRaftRoutes({
+	const api = createRaftRouteClient({
 		serverUrl,
 		fetch: options.fetch,
 		headers: options.headers,
@@ -13792,6 +13949,7 @@ function createRaft(options) {
 		readAttempts: options.retry?.attempts,
 		beforeRequest: options.throttle?.beforeRequest
 	});
+	const routes = raftRoutesFromClient(api);
 	const inboxApi = createAgentApiClient({ fetch: {
 		baseUrl: serverUrl,
 		fetch: (input, init) => (options.fetch ?? fetch)(input, {
@@ -13812,7 +13970,7 @@ function createRaft(options) {
 	const sendWithState = (request) => withState(async () => {
 		const contentHash = await hashRaftSendContent(request.target, request.content ?? "", request.attachmentIds ?? []);
 		const pending = request.idempotencyKey ? void 0 : session.findContinuation(request.target, contentHash);
-		const outcome = await sendMessage(routes, pending ? {
+		const outcome = await sendMessage(api, pending ? {
 			...request,
 			idempotencyKey: pending.idempotencyKey
 		} : request, frontier);
@@ -13826,13 +13984,13 @@ function createRaft(options) {
 		return outcome;
 	});
 	return {
-		identity: { whoami: () => getRaftContext(routes) },
+		identity: { whoami: () => getRaftContext(api) },
 		wake: {
 			verifyNotice: (input) => verifyInboxNotice(input),
 			webhook: {
-				status: () => webhookStatus(routes),
-				register: (request) => registerWebhook(routes, request),
-				unregister: () => unregisterWebhook(routes)
+				status: () => webhookStatus(api),
+				register: (request) => registerWebhook(api, request),
+				unregister: () => unregisterWebhook(api)
 			}
 		},
 		inbox: {
@@ -13870,11 +14028,11 @@ function createRaft(options) {
 					await session.save();
 				});
 			})(),
-			list: (request) => listInbox(routes, request)
+			list: (request) => listInbox(api, request)
 		},
 		messages: {
 			read: (request) => withState(async () => {
-				const outcome = await readHistory(routes, request, frontier);
+				const outcome = await readHistory(api, request, frontier);
 				if (outcome.ok) session.markDirty();
 				return outcome;
 			}),
@@ -13883,57 +14041,58 @@ function createRaft(options) {
 				...request,
 				target: message.target
 			}),
-			search: (request) => searchMessages(routes, request),
-			resolve: (request) => resolveMessage(routes, request),
-			react: (request) => reactToMessage(routes, request, "add"),
-			unreact: (request) => reactToMessage(routes, request, "remove")
+			search: (request) => searchMessages(api, request),
+			resolve: (request) => resolveMessage(api, request),
+			react: (request) => reactToMessage(api, request, "add"),
+			unreact: (request) => reactToMessage(api, request, "remove")
 		},
 		attachments: {
-			upload: (request) => uploadAttachment(routes, {
+			upload: (request) => uploadAttachment(api, {
 				serverUrl,
 				fetch: options.fetch ?? fetch,
 				headers: Object.fromEntries(new Headers(options.headers)),
 				authorization
 			}, request),
-			download: (request) => downloadAttachment(routes, request),
-			comments: (request) => attachmentComments(routes, request)
+			download: (request) => downloadAttachment(api, request),
+			comments: (request) => attachmentComments(api, request)
 		},
 		mentions: {
-			pending: (request) => pendingMentionActions(routes, request),
-			execute: (request) => executeMentionAction(routes, request),
-			deliveries: (request) => senderMentionDeliveries(routes, request)
+			pending: (request) => pendingMentionActions(api, request),
+			execute: (request) => executeMentionAction(api, request),
+			deliveries: (request) => senderMentionDeliveries(api, request)
 		},
+		actions: { prepare: (request) => prepareActionCard(api, request) },
 		manual: {
-			get: (request) => getManualTopic(routes, request),
-			search: (request) => searchManual(routes, request)
+			get: (request) => getManualTopic(api, request),
+			search: (request) => searchManual(api, request)
 		},
 		tasks: {
-			claim: (request) => claimTasks(routes, request),
-			list: (request) => listTasks(routes, request),
-			create: (request) => createTasks(routes, request),
-			unclaim: (request) => unclaimTask(routes, request),
-			assign: (request) => assignTask(routes, request),
-			updateStatus: (request) => updateTaskStatus(routes, request),
-			amend: (request) => amendTask(routes, request),
-			history: (request) => taskHistory(routes, request),
-			convert: (request) => convertMessageToTask(routes, request),
-			delete: (request) => deleteTask(routes, request)
+			claim: (request) => claimTasks(api, request),
+			list: (request) => listTasks(api, request),
+			create: (request) => createTasks(api, request),
+			unclaim: (request) => unclaimTask(api, request),
+			assign: (request) => assignTask(api, request),
+			updateStatus: (request) => updateTaskStatus(api, request),
+			amend: (request) => amendTask(api, request),
+			history: (request) => taskHistory(api, request),
+			convert: (request) => convertMessageToTask(api, request),
+			delete: (request) => deleteTask(api, request)
 		},
 		channels: {
-			join: (request) => joinChannel(routes, request),
-			leave: (request) => leaveChannel(routes, request),
-			mute: (request) => muteChannel(routes, request),
-			unmute: (request) => unmuteChannel(routes, request),
-			members: (request) => channelMembers(routes, request)
+			join: (request) => joinChannel(api, request),
+			leave: (request) => leaveChannel(api, request),
+			mute: (request) => muteChannel(api, request),
+			unmute: (request) => unmuteChannel(api, request),
+			members: (request) => channelMembers(api, request)
 		},
 		threads: {
-			list: () => listThreads(routes),
-			unfollow: (request) => unfollowThread(routes, request)
+			list: () => listThreads(api),
+			unfollow: (request) => unfollowThread(api, request)
 		},
-		server: { info: (request) => serverInfo(routes, request) },
+		server: { info: (request) => serverInfo(api, request) },
 		profile: {
-			show: (request) => showProfile(routes, request),
-			update: (request) => updateProfile(routes, request)
+			show: (request) => showProfile(api, request),
+			update: (request) => updateProfile(api, request)
 		},
 		frontier,
 		state: {

package/dist/index.d.ts

@@ -980,6 +980,14 @@ export declare function parseRaftState(value: unknown): RaftState | null;
 /** Hex SHA-256 identifying one logical message (WebCrypto; Workers-safe). */
 export declare function hashRaftSendContent(target: string, content: string, attachmentIds?: readonly string[]): Promise<string>;
 //#endregion
+//#region ../shared/src/agentOps/actions.d.ts
+type PrepareActionCardRequest = AgentApiActionPrepareBody;
+interface RaftPreparedCard {
+  target: string;
+  /** The card message; a human commits it by clicking its action verb. */
+  messageId: string;
+}
+//#endregion
 //#region ../shared/src/agentApiRawClient.d.ts
 type AgentApiRawClientErrorReason = "missing_route" | "missing_path_param" | "request_contract_mismatch" | "transport_error" | "http_error" | "empty_response" | "response_contract_mismatch";
 interface AgentApiRawTransportRequest<K extends AgentApiRouteKey = AgentApiRouteKey> {
@@ -988,25 +996,6 @@ interface AgentApiRawTransportRequest<K extends AgentApiRouteKey = AgentApiRoute
   path: string;
   body?: unknown;
 }
-type AgentApiRawSuccess<K extends AgentApiRouteKey> = {
-  ok: true;
-  routeKey: K;
-  status: number;
-  data: AgentApiResponseByRoute[K];
-};
-type AgentApiRawFailure<K extends AgentApiRouteKey = AgentApiRouteKey> = {
-  ok: false;
-  routeKey?: K;
-  status?: number;
-  reason: AgentApiRawClientErrorReason;
-  message: string;
-  errorCode?: string | null;
-  suggestedNextAction?: string | null;
-  proxy?: unknown;
-  cause?: unknown;
-  response?: unknown;
-};
-type AgentApiRawResult<K extends AgentApiRouteKey> = AgentApiRawSuccess<K> | AgentApiRawFailure<K>;
 type AgentApiRawClientResource = AgentApiContract[AgentApiRouteKey]["client"]["resource"];
 type AgentApiRawClientResourceMethod<R extends AgentApiRawClientResource> = { [K in AgentApiRouteKey]: AgentApiContract[K]["client"] extends {
   resource: R;
@@ -1016,9 +1005,6 @@ type AgentApiRouteKeyForClient<R extends AgentApiRawClientResource, M extends Ag
   resource: R;
   method: M;
 } ? K : never; }[AgentApiRouteKey];
-type AgentApiRawClientMethodArgs<K extends AgentApiRouteKey> = [AgentApiRequestParamsByRoute[K]] extends [never] ? [AgentApiRequestQueryByRoute[K]] extends [never] ? [AgentApiRequestBodyByRoute[K]] extends [never] ? [] : [body: AgentApiRequestBodyByRoute[K]] : [query: AgentApiRequestQueryByRoute[K]] : [AgentApiRequestQueryByRoute[K]] extends [never] ? [AgentApiRequestBodyByRoute[K]] extends [never] ? [params: AgentApiRequestParamsByRoute[K]] : [params: AgentApiRequestParamsByRoute[K], body: AgentApiRequestBodyByRoute[K]] : [AgentApiRequestBodyByRoute[K]] extends [never] ? [params: AgentApiRequestParamsByRoute[K], query: AgentApiRequestQueryByRoute[K]] : [params: AgentApiRequestParamsByRoute[K], query: AgentApiRequestQueryByRoute[K], body: AgentApiRequestBodyByRoute[K]];
-type AgentApiRawClientMethod<K extends AgentApiRouteKey> = (...args: AgentApiRawClientMethodArgs<K>) => Promise<AgentApiRawResult<K>>;
-type AgentApiRawClient = { [R in AgentApiRawClientResource]: { [M in AgentApiRawClientResourceMethod<R>]: AgentApiRawClientMethod<AgentApiRouteKeyForClient<R, M>>; }; };
 //#endregion
 //#region ../shared/src/index.d.ts
 /**
@@ -8944,16 +8930,6 @@ interface AgentApiClientFailure<K extends AgentApiRouteKey = AgentApiRouteKey> {
   error: AgentApiClientError;
 }
 type AgentApiClientResult<K extends AgentApiRouteKey> = AgentApiClientSuccess<K> | AgentApiClientFailure<K>;
-type AgentApiClientMethod<K extends AgentApiRouteKey> = (...args: Parameters<AgentApiRawClientMethod<K>>) => Promise<AgentApiClientResult<K>>;
-type AgentApiClientMethods = { [R in keyof AgentApiRawClient]: { [M in keyof AgentApiRawClient[R]]: AgentApiRawClient[R][M] extends AgentApiRawClientMethod<infer K> ? AgentApiClientMethod<K> : never; }; };
-interface AgentApiClientRequestOptions<K extends AgentApiRouteKey> {
-  params?: AgentApiRequestParamsByRoute[K];
-  query?: AgentApiRequestQueryByRoute[K];
-  body?: AgentApiRequestBodyByRoute[K];
-}
-type AgentApiClient = AgentApiClientMethods & {
-  request<K extends AgentApiRouteKey>(routeKey: K, options?: AgentApiClientRequestOptions<K>): Promise<AgentApiClientResult<K>>;
-};
 type AgentApiAuthHeaders = Record<string, string>;
 type AgentApiAuthStrategy = AgentApiAuthHeaders | ((request: AgentApiRawTransportRequest) => AgentApiAuthHeaders | Promise<AgentApiAuthHeaders>);
 interface AgentApiFetchTransportOptions {
@@ -9068,12 +9044,24 @@ interface RaftRouteInfo extends RaftRouteMeta {
   annotations: RaftRouteAnnotations;
 }
 /**
- * `routes.<resource>.<method>(params?, query?, body?)` for every route in the
+ * `routes.<resource>.<method>({ params, query, body })` (one named object, typed per route) for every route in the
  * contract, plus route introspection. Reads retry (bounded); writes and
  * destructive reads make exactly one attempt regardless of client retry
  * settings, because the contract says repeating them is not safe.
  */
-type RaftRoutes = AgentApiClient & {
+type RoutePart<Name extends string, T> = [T] extends [never] ? { [P in Name]?: never; } : {} extends T ? { [P in Name]?: T; } : { [P in Name]: T; };
+/**
+ * The single input every route takes: `{ params, query, body }`, typed per
+ * route. A part the route does not have is `never` (passing it is a compile
+ * error); a part with required fields is a required property.
+ */
+type RaftRouteInput<K extends RaftRouteKey> = RoutePart<"params", AgentApiRequestParamsByRoute[K]> & RoutePart<"query", AgentApiRequestQueryByRoute[K]> & RoutePart<"body", AgentApiRequestBodyByRoute[K]>;
+type RaftRouteMethod<K extends RaftRouteKey> = {} extends RaftRouteInput<K> ? (input?: RaftRouteInput<K>) => Promise<RaftRouteResult<K>> : (input: RaftRouteInput<K>) => Promise<RaftRouteResult<K>>;
+/** `routes.<resource>.<method>({ params, query, body })` for every route in the contract. */
+type RaftRouteMethods = { [R in AgentApiRawClientResource]: { [M in AgentApiRawClientResourceMethod<R>]: RaftRouteMethod<AgentApiRouteKeyForClient<R, M>>; }; };
+type RaftRoutes = RaftRouteMethods & {
+  /** The same call by route key: `request("actionPrepare", { body })`. */
+  request<K extends RaftRouteKey>(routeKey: K, input?: RaftRouteInput<K>): Promise<RaftRouteResult<K>>;
   /** Content hash of the route manifest this SDK was built against. */
   manifestVersion: string;
   /** Static description of one route: capability, side effect, idempotency, audience, retry policy. */
@@ -9094,12 +9082,7 @@ interface CreateRaftRoutesOptions {
     beforeRequest?: infer F;
   } | undefined ? F : never;
 }
-/**
- * Build the routes layer over two transports: a retrying one for routes the
- * contract marks retry-safe, and a single-attempt one for everything else.
- * The split is decided per route from `AGENT_API_ROUTE_META`, never by the
- * caller and never by the HTTP method.
- */
+/** Build the public routes layer directly (convenience over createRaftRouteClient + raftRoutesFromClient). */
 export declare function createRaftRoutes(options: CreateRaftRoutesOptions): RaftRoutes;
 //#endregion
 //#region src/context.d.ts
@@ -9209,7 +9192,7 @@ type RaftClient = AgentApiMessageClient & RaftManageClient & {
     join(request: RaftChannelJoinRequest): Promise<RaftChannelJoinResult>;
   };
   /**
-   * Every Agent API route as `routes.<resource>.<method>(params?, query?, body?)`,
+   * Every Agent API route as `routes.<resource>.<method>({ params, query, body })` (one named object, typed per route),
    * typed from the shared contract, with per-route metadata via `routes.describe`.
    * Retry policy follows the contract: reads may retry, writes make one attempt.
    */
@@ -9451,6 +9434,14 @@ interface Raft {
       messageId: string;
     }): Promise<RaftOutcome<AgentApiSenderMentionDeliveriesResponse, "deliveries" | "empty">>;
   };
+  actions: {
+    /**
+     * Post an action card for a human to confirm (channel:create,
+     * channel:add_member, agent:create, and the integration card types). The
+     * human who clicks it executes it as themselves.
+     */
+    prepare(request: PrepareActionCardRequest): Promise<RaftOutcome<RaftPreparedCard, "prepared">>;
+  };
   manual: {
     /** Fetch a Manual topic; `intent` and `reason` are required and must never carry prompts, credentials, or message payloads. */
     get(request: {
@@ -9543,4 +9534,4 @@ interface Raft {
 }
 export declare function createRaft(options: CreateRaftOptions): Raft;
 //#endregion
-export type { AmendTaskOutcome, AmendTaskRequest, AssignTaskRequest, BootstrapRaftCredentialOptions, CheckInboxOutcome, CheckInboxRequest, ClaimTasksOutcome, ClaimTasksRequest, CreateRaftClientFromStoreOptions, CreateRaftClientOptions, CreateRaftOptions, CreateRaftRoutesOptions, CreateTasksRequest, DrainInboxRequest, ExecuteMentionActionRequest, ListInboxRequest, ListTasksRequest, ManualContext, Raft, RaftAckMode, RaftActionPrepareRequest, RaftActionPrepared, RaftApiError, RaftApiResult, RaftAppConfig, RaftAppConfigPatch, RaftAttachmentBytes, RaftAttachmentUploaded, RaftAvatarUpload, RaftChannelJoinClient, RaftChannelJoinClientResult, RaftChannelJoinError, RaftChannelJoinFailure, RaftChannelJoinOperation, RaftChannelJoinRequest, RaftChannelJoinResult, RaftChannelJoinSuccess, RaftChannelJoinTransportError, RaftChannelMuteState, RaftChannelRef, RaftClaimHeld, RaftClaimHeldLike, RaftClaimResult, RaftClaimRow, RaftClaimRowState, RaftClient, RaftClientError, RaftClientFailure, RaftClientResult, RaftClientSuccess, RaftClientThrottleOptions, RaftClientTransportRequest, RaftContextAgent, RaftContextData, RaftContextError, RaftContextResult, RaftContextServer, RaftCredentialErrorCode, RaftCredentialIdentity, RaftCredentialStore, RaftEvent, RaftEventAttachment, RaftEventExternalMessage, RaftEventsReceiveData, RaftEventsReceiveError, RaftEventsReceiveRequest, RaftEventsReceiveResult, RaftFailure, RaftHeld, RaftHeldBase, RaftHistoryPage, RaftInboxBatch, RaftInboxCommitResult, RaftInboxConversation, RaftInboxDrainSummary, RaftInboxListing, RaftInboxNotice, RaftManageClient, RaftMessage, RaftMessageAttachment, RaftMessageTask, RaftNextStep, RaftNoticeFlag, RaftNoticeTarget, RaftOpError, RaftOpErrorCode, RaftOutcome, RaftPendingMentions, RaftProfile, RaftProfileUpdate, RaftRouteAnnotations, RaftRouteInfo, RaftRouteKey, RaftRouteMeta, RaftRouteResult, RaftRouteRetryPolicy, RaftRoutes, RaftSdkConfigurationErrorCode, RaftSearchPage, RaftSendContinuation, RaftSenderType, RaftSent, RaftServerInfo, RaftServerProfile, RaftServerUpdate, RaftState, RaftStateContinuation, RaftStateSaveErrorHandler, RaftStateStore, RaftTaskBoard, RaftTaskStatus, RaftTasksCreated, RaftWebhookStatus, ReactRequest, ReadHistoryRequest, SearchMessagesRequest, SeenAttestation, SeenFrontierSnapshot, SendMessageOutcome, SendMessageRequest, ServerInfoRequest, ServerInfoSection, StoredRaftCredential, TaskRef, UpdateTaskStatusOutcome, UpdateTaskStatusRequest, UploadAttachmentRequest, VerifyNoticeInput, VerifyNoticeRejection, VerifyNoticeResult };
+export type { AmendTaskOutcome, AmendTaskRequest, AssignTaskRequest, BootstrapRaftCredentialOptions, CheckInboxOutcome, CheckInboxRequest, ClaimTasksOutcome, ClaimTasksRequest, CreateRaftClientFromStoreOptions, CreateRaftClientOptions, CreateRaftOptions, CreateRaftRoutesOptions, CreateTasksRequest, DrainInboxRequest, ExecuteMentionActionRequest, ListInboxRequest, ListTasksRequest, ManualContext, PrepareActionCardRequest, Raft, RaftAckMode, RaftActionPrepareRequest, RaftActionPrepared, RaftApiError, RaftApiResult, RaftAppConfig, RaftAppConfigPatch, RaftAttachmentBytes, RaftAttachmentUploaded, RaftAvatarUpload, RaftChannelJoinClient, RaftChannelJoinClientResult, RaftChannelJoinError, RaftChannelJoinFailure, RaftChannelJoinOperation, RaftChannelJoinRequest, RaftChannelJoinResult, RaftChannelJoinSuccess, RaftChannelJoinTransportError, RaftChannelMuteState, RaftChannelRef, RaftClaimHeld, RaftClaimHeldLike, RaftClaimResult, RaftClaimRow, RaftClaimRowState, RaftClient, RaftClientError, RaftClientFailure, RaftClientResult, RaftClientSuccess, RaftClientThrottleOptions, RaftClientTransportRequest, RaftContextAgent, RaftContextData, RaftContextError, RaftContextResult, RaftContextServer, RaftCredentialErrorCode, RaftCredentialIdentity, RaftCredentialStore, RaftEvent, RaftEventAttachment, RaftEventExternalMessage, RaftEventsReceiveData, RaftEventsReceiveError, RaftEventsReceiveRequest, RaftEventsReceiveResult, RaftFailure, RaftHeld, RaftHeldBase, RaftHistoryPage, RaftInboxBatch, RaftInboxCommitResult, RaftInboxConversation, RaftInboxDrainSummary, RaftInboxListing, RaftInboxNotice, RaftManageClient, RaftMessage, RaftMessageAttachment, RaftMessageTask, RaftNextStep, RaftNoticeFlag, RaftNoticeTarget, RaftOpError, RaftOpErrorCode, RaftOutcome, RaftPendingMentions, RaftPreparedCard, RaftProfile, RaftProfileUpdate, RaftRouteAnnotations, RaftRouteInfo, RaftRouteKey, RaftRouteMeta, RaftRouteResult, RaftRouteRetryPolicy, RaftRoutes, RaftSdkConfigurationErrorCode, RaftSearchPage, RaftSendContinuation, RaftSenderType, RaftSent, RaftServerInfo, RaftServerProfile, RaftServerUpdate, RaftState, RaftStateContinuation, RaftStateSaveErrorHandler, RaftStateStore, RaftTaskBoard, RaftTaskStatus, RaftTasksCreated, RaftWebhookStatus, ReactRequest, ReadHistoryRequest, SearchMessagesRequest, SeenAttestation, SeenFrontierSnapshot, SendMessageOutcome, SendMessageRequest, ServerInfoRequest, ServerInfoSection, StoredRaftCredential, TaskRef, UpdateTaskStatusOutcome, UpdateTaskStatusRequest, UploadAttachmentRequest, VerifyNoticeInput, VerifyNoticeRejection, VerifyNoticeResult };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botiverse/raft-sdk",
-  "version": "1.0.0-alpha.4",
+  "version": "1.0.0-alpha.6",
   "license": "FSL-1.1-ALv2",
   "description": "Typed Raft Agent API client for external agents and bots.",
   "type": "module",