@layers/amba-mcp 4.0.11 → 4.0.12

package/dist/index.js

@@ -48,20 +48,50 @@ function isTokenExpired(credentials) {
 var AmbaApiError = class extends Error {
 	status;
 	code;
-	constructor(status, code, message) {
+	/** The API's own `error.message`, without the `API error <status>:` prefix. */
+	apiMessage;
+	/**
+	* The API's `error.details`, when the response carried one: for example a
+	* 402 `FREE_TIER_LIMIT_REACHED` names the limit, the reset date, the
+	* billing URL and the one-call upgrade there. Tool results pass it to the
+	* agent (`lib/tool-result.ts` `apiErrorResult`).
+	*/
+	details;
+	constructor(status, code, message, details) {
 		super(`API error ${status}: ${message}`);
 		this.name = "AmbaApiError";
 		this.status = status;
 		this.code = code;
+		this.apiMessage = message;
+		this.details = details;
 	}
 };
+/**
+* Read a non-2xx response's `{ error: { code, message, details } }` envelope
+* into an `AmbaApiError`. A body that is not that JSON envelope falls back to
+* the status text.
+*/
+async function ambaApiErrorFromResponse(res) {
+	let errorMessage = res.statusText;
+	let errorCode;
+	let details;
+	try {
+		const err = (await res.json())?.error;
+		if (typeof err?.message === "string") errorMessage = err.message;
+		if (typeof err?.code === "string") errorCode = err.code;
+		details = err?.details;
+	} catch {}
+	return new AmbaApiError(res.status, errorCode, errorMessage, details);
+}
 const BASE_URL = "https://api.amba.dev/v1/admin";
 var ApiClient = class ApiClient {
+	authProxyHeaders;
 	baseUrl;
 	apiRoot;
 	tokenProvider;
 	signupToken;
 	constructor(options) {
+		this.authProxyHeaders = { ...options?.authProxyHeaders };
 		const raw = (options?.baseUrl ?? BASE_URL).replace(/\/+$/, "");
 		if (!/\/admin$/.test(raw)) throw new Error(`ApiClient baseUrl must end in /admin (got ${JSON.stringify(raw)}). Set AMBA_API_URL=https://api.amba.dev/v1/admin (or your equivalent versioned host).`);
 		this.baseUrl = raw;
@@ -114,6 +144,15 @@ var ApiClient = class ApiClient {
 		return this.apiRoot;
 	}
 	/**
+	* Headers to add to public developer-auth calls (see
+	* `ApiClientOptions.authProxyHeaders`). Those calls always run on the
+	* client the tools were registered with, so a `withToken` sibling does not
+	* need to carry them.
+	*/
+	getAuthProxyHeaders() {
+		return { ...this.authProxyHeaders };
+	}
+	/**
 	* Resolve the current developer Bearer token, going through the configured
 	* tokenProvider (or `~/.amba/credentials.json` for the CLI fallback).
 	*
@@ -146,6 +185,23 @@ var ApiClient = class ApiClient {
 		if (isTokenExpired(credentials)) throw new Error("Developer access token has expired. Run \"amba login\" to re-authenticate.");
 		return credentials.access_token;
 	}
+	/**
+	* Account notices (`X-Amba-Notice`, e.g. the unclaimed-sandbox claim
+	* instruction) seen on responses since the last `takeNotices()`. The
+	* `registerTool` wrapper drains them into the tool result so the agent
+	* reads them alongside the data it asked for.
+	*/
+	notices = /* @__PURE__ */ new Set();
+	/** Return and clear the notices collected since the last call. */
+	takeNotices() {
+		const out = [...this.notices];
+		this.notices.clear();
+		return out;
+	}
+	captureNotice(res) {
+		const notice = res.headers?.get?.("x-amba-notice");
+		if (notice) this.notices.add(notice);
+	}
 	async request(method, path, body, query) {
 		const token = await this.getToken();
 		let url = `${this.baseUrl}${path}`;
@@ -163,16 +219,8 @@ var ApiClient = class ApiClient {
 			headers,
 			body: body !== void 0 ? JSON.stringify(body) : void 0
 		});
-		if (!res.ok) {
-			let errorMessage = res.statusText;
-			let errorCode;
-			try {
-				const errorBody = await res.json();
-				errorMessage = errorBody?.error?.message ?? res.statusText;
-				errorCode = errorBody?.error?.code;
-			} catch {}
-			throw new AmbaApiError(res.status, errorCode, errorMessage);
-		}
+		this.captureNotice(res);
+		if (!res.ok) throw await ambaApiErrorFromResponse(res);
 		if (res.status === 204) return;
 		return await res.json();
 	}
@@ -215,16 +263,8 @@ var ApiClient = class ApiClient {
 				Accept: "text/csv, application/x-ndjson, */*"
 			}
 		});
-		if (!res.ok) {
-			let errorMessage = res.statusText;
-			let errorCode;
-			try {
-				const errorBody = await res.json();
-				errorMessage = errorBody?.error?.message ?? res.statusText;
-				errorCode = errorBody?.error?.code;
-			} catch {}
-			throw new AmbaApiError(res.status, errorCode, errorMessage);
-		}
+		this.captureNotice(res);
+		if (!res.ok) throw await ambaApiErrorFromResponse(res);
 		const contentType = res.headers.get("content-type");
 		const reader = res.body?.getReader();
 		if (!reader) {
@@ -387,6 +427,7 @@ const WRITE_VERBS = new Set([
 	"insert",
 	"invite",
 	"register",
+	"claim",
 	"define",
 	"map",
 	"adopt",
@@ -403,7 +444,8 @@ const WRITE_VERBS = new Set([
 	"generate",
 	"enroll",
 	"request",
-	"clawback"
+	"clawback",
+	"upgrade"
 ]);
 /**
 * Split a tool name into lowercase verb-candidate tokens, dropping the
@@ -562,8 +604,174 @@ function deriveToolAnnotations(name) {
 	}
 }
 //#endregion
+//#region src/lib/tool-result.ts
+/**
+* Shared MCP tool result helpers.
+*
+* Every tool emits the same `{ content: [{ type: 'text', text: <json> }] }`
+* envelope. Two helpers centralize that:
+*
+*   - [`jsonResult`] — wraps an arbitrary payload.
+*   - [`passthroughResult`] — flattens an upstream HTTP response
+*     (status + parsed body) into the same envelope. Status is written
+*     LAST so a colliding top-level `status` field in the API response
+*     cannot shadow the HTTP status — agents look at `parsed.status` to
+*     distinguish 2xx from 4xx/5xx.
+*
+* Lives in `src/lib/` (vs. `src/tools/_helpers.ts`) to set the same
+* cross-cutting-helper precedent as `src/lib/with-pat.ts` (task #36).
+* `tools/*` files stay strictly tool registrations.
+*/
+/**
+* Wire-shape every MCP tool handler returns.
+*
+* The MCP SDK's `tool()` callback signature is structurally typed and
+* carries an open index signature for `_meta` etc. Declaring our return
+* type as a plain `{ content: [...] }` interface won't satisfy that
+* structural check — so the helpers' return type is left as the actual
+* inferred shape (no explicit interface) and consumers rely on the
+* inference + the SDK's structural compatibility. If we ever want a
+* named alias, write it as a type-alias over the inferred shape rather
+* than a closed interface.
+*/
+/** Wrap an arbitrary payload as a JSON-text tool result. */
+function jsonResult$1(payload) {
+	return { content: [{
+		type: "text",
+		text: JSON.stringify(payload, null, 2)
+	}] };
+}
+/** Preserve an HTTP response wrapper while mapping failures to MCP isError. */
+function httpResult(result) {
+	return {
+		...jsonResult$1(result),
+		...result.status >= 400 ? { isError: true } : {}
+	};
+}
+/**
+* Flatten an upstream HTTP response into the agent-facing tool payload.
+* Body fields are spread FIRST so a future top-level `status` key in
+* the API response cannot shadow the HTTP `status` — agents read
+* `parsed.status` to distinguish 2xx from 4xx/5xx.
+*/
+function passthroughResult(result) {
+	return {
+		...jsonResult$1({
+			...result.body !== null && typeof result.body === "object" ? result.body : {},
+			status: result.status
+		}),
+		...result.status >= 400 ? { isError: true } : {}
+	};
+}
+/**
+* Tool result for a failed API call. The first text item is the
+* human-readable line tools have always returned (`API error 402: ...`). The
+* second is the API's structured error as JSON,
+* `{ "status": 402, "error": { "code", "message", "details" } }`, so an agent
+* can branch on `error.code` and read `details` (a free-tier 402 carries the
+* limit, the reset date, the billing URL and the one-call upgrade there).
+*
+* Code mode joins an error result's text items with a newline into the
+* exception it throws in the sandbox, so the same JSON reaches that surface
+* after the first line of the error message.
+*/
+function apiErrorResult(err) {
+	const error = {
+		code: err.code ?? null,
+		message: err.apiMessage
+	};
+	if (err.details !== void 0) error.details = err.details;
+	return {
+		content: [{
+			type: "text",
+			text: err.message
+		}, {
+			type: "text",
+			text: JSON.stringify({
+				status: err.status,
+				error
+			}, null, 2)
+		}],
+		isError: true
+	};
+}
+//#endregion
 //#region src/lib/with-pat.ts
 /**
+* Attach the account notices the API sent with this call's responses
+* (`X-Amba-Notice`, collected by `ApiClient`), so an agent sees "claim this
+* account" next to what it asked for. A successful result gets them as extra
+* text items. An error result gets them as a `notices` array inside its
+* trailing JSON error, so that item stays the last one and stays parseable
+* (code mode joins the text items into the message of the Error it throws).
+* A result without notices is returned unchanged.
+*/
+function withAccountNotices(result, client) {
+	const take = client.takeNotices;
+	const notices = typeof take === "function" ? take.call(client) : [];
+	if (notices.length === 0) return result;
+	if (result.isError) {
+		const folded = foldNoticesIntoErrorJson(result, notices);
+		if (folded) return folded;
+	}
+	return {
+		...result,
+		content: [...result.content, ...notices.map((notice) => ({
+			type: "text",
+			text: `Notice from Amba: ${notice}`
+		}))]
+	};
+}
+/** `result` with `notices` merged into its last text item, or null when that item is not a JSON object. */
+function foldNoticesIntoErrorJson(result, notices) {
+	const last = result.content[result.content.length - 1];
+	if (!last) return null;
+	let parsed;
+	try {
+		parsed = JSON.parse(last.text);
+	} catch {
+		return null;
+	}
+	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+	const payload = parsed;
+	const existing = Array.isArray(payload["notices"]) ? payload["notices"] : [];
+	const merged = {
+		...payload,
+		notices: [...existing, ...notices]
+	};
+	return {
+		...result,
+		content: [...result.content.slice(0, -1), {
+			type: "text",
+			text: JSON.stringify(merged, null, 2)
+		}]
+	};
+}
+/**
+* True for an `AmbaApiError`. The duck-typed branch also accepts one thrown
+* by a second copy of this package (a bundler that inlines it twice), where
+* `instanceof` against this copy's class is false.
+*/
+function isAmbaApiError(err) {
+	if (err instanceof AmbaApiError) return true;
+	if (!(err instanceof Error) || err.name !== "AmbaApiError") return false;
+	const e = err;
+	return typeof e.status === "number" && typeof e.apiMessage === "string";
+}
+/**
+* Run a tool handler; a failed API call it throws becomes an error result
+* that keeps the API's `code`, `message` and `details` (`apiErrorResult`).
+* Any other throw propagates, and the MCP SDK reports its message.
+*/
+async function structuredApiErrors(run) {
+	try {
+		return await run();
+	} catch (err) {
+		if (isAmbaApiError(err)) return apiErrorResult(err);
+		throw err;
+	}
+}
+/**
 * The `pat` schema entry injected into every tool that goes through
 * `registerTool`. Exported so tests can assert on its presence.
 */
@@ -578,26 +786,30 @@ const PAT_ARG_SCHEMA = z.string().optional().describe([
 ].join(" "));
 /**
 * Build the MISSING_PAT short-circuit payload. Shape matches the auth
-* tools so agents can parse `error.code` uniformly.
+* tools so agents can parse `error.code` uniformly. It is an error result
+* like any other failed call (code mode throws it).
 */
 function missingPatResult(toolName) {
-	return { content: [{
-		type: "text",
-		text: JSON.stringify({
-			status: 401,
-			error: {
-				code: "MISSING_PAT",
-				message: [
-					`Tool "${toolName}" requires a developer Bearer.`,
-					"Pass `pat` as a tool argument (the value returned by",
-					"`amba_developer_signup` / `amba_developer_login`). The next",
-					"agent session will pick the PAT up automatically once the",
-					"snippet in `mcp_config` is written to the customer's MCP",
-					"client config, at which point the `pat` arg becomes optional."
-				].join(" ")
-			}
-		}, null, 2)
-	}] };
+	return {
+		isError: true,
+		content: [{
+			type: "text",
+			text: JSON.stringify({
+				status: 401,
+				error: {
+					code: "MISSING_PAT",
+					message: [
+						`Tool "${toolName}" requires a developer Bearer.`,
+						"Pass `pat` as a tool argument (the value returned by",
+						"`amba_developer_signup` / `amba_developer_login`). The next",
+						"agent session will pick the PAT up automatically once the",
+						"snippet in `mcp_config` is written to the customer's MCP",
+						"client config, at which point the `pat` arg becomes optional."
+					].join(" ")
+				}
+			}, null, 2)
+		}]
+	};
 }
 /**
 * Register a tool that:
@@ -633,10 +845,10 @@ function registerTool(server, apiClient, name, description, schema, handler, ali
 			client = apiClient;
 		}
 		if (!pat) return missingPatResult(registeredName);
-		return handler(rawArgs, {
+		return withAccountNotices(await structuredApiErrors(() => handler(rawArgs, {
 			pat,
 			client
-		});
+		})), client);
 	};
 	server.tool(name, description, extendedSchema, deriveToolAnnotations(name), wrappedHandler(name));
 	for (const alias of aliases) server.tool(alias, description, extendedSchema, deriveToolAnnotations(alias), (async (rawArgs) => {
@@ -651,15 +863,16 @@ function registerTool(server, apiClient, name, description, schema, handler, ali
 * should go through `registerTool`.
 */
 function registerPublicTool(server, name, description, schema, handler, aliases = [], annotations) {
-	server.tool(name, description, schema, annotations ?? deriveToolAnnotations(name), handler);
+	const wrappedHandler = (args) => structuredApiErrors(() => handler(args));
+	server.tool(name, description, schema, annotations ?? deriveToolAnnotations(name), wrappedHandler);
 	for (const alias of aliases) server.tool(alias, description, schema, annotations ?? deriveToolAnnotations(alias), (async (args) => {
 		warnDeprecatedAlias(alias, name);
-		return handler(args);
+		return wrappedHandler(args);
 	}));
 }
 //#endregion
 //#region src/tools/projects.ts
-function registerTools$42(server, apiClient) {
+function registerTools$43(server, apiClient) {
 	registerTool(server, apiClient, "amba_projects_list", "List all Amba projects owned by the authenticated developer. Returns project id, name, bundle_id, platform, environment, the persisted billing `tier`, and `effective_tier` (the runtime entitlement tier; comped projects are effectively enterprise).", {}, async (_, { client }) => {
 		const result = await client.get("/projects");
 		return { content: [{
@@ -770,7 +983,7 @@ function registerTools$42(server, apiClient) {
 }
 //#endregion
 //#region src/tools/push.ts
-function registerTools$41(server, apiClient) {
+function registerTools$42(server, apiClient) {
 	registerTool(server, apiClient, "amba_push_campaigns_create", "Create a new push notification campaign for a project. The campaign starts in \"draft\" status. You can optionally target a segment and schedule delivery.", {
 		project_id: z.string().describe("The project ID"),
 		title: z.string().describe("Push notification title shown to the user"),
@@ -900,7 +1113,7 @@ const segmentRulesSchema = z.object({
 	operator: z.enum(["AND", "OR"]).describe("Logical operator combining conditions"),
 	conditions: z.array(segmentConditionSchema).describe("Array of filter conditions")
 });
-function registerTools$40(server, apiClient) {
+function registerTools$41(server, apiClient) {
 	registerTool(server, apiClient, "amba_segments_list", "List user segments for a project. Segments define groups of users based on rules (e.g. \"active in last 7 days\", \"premium users\"). Returns only project-custom segments by default. Pass include_system: true to also include the built-in system segments (e.g. \"all\", \"active_7d\", \"premium\").", {
 		project_id: z.string().describe("The project ID"),
 		include_system: z.boolean().optional().describe("Include built-in system segments in the result. Defaults to false.")
@@ -985,7 +1198,7 @@ const configConditionSchema = z.object({
 	percentage: z.number().optional().describe("Percentage rollout (0-100)"),
 	value: z.unknown().describe("Override value for this condition")
 });
-function registerTools$39(server, apiClient) {
+function registerTools$40(server, apiClient) {
 	registerTool(server, apiClient, "amba_remote_configs_list", "List remote-config keys for a project. Returns key, value, value_type, description, conditions, and version per active row. Remote config lets you change app behavior without deploying an update. Returns only project-created config keys by default. Pass include_system: true to also include platform-provided defaults (e.g. app_version_min, maintenance_mode).", {
 		project_id: z.string().describe("The project ID"),
 		include_system: z.boolean().optional().describe("Include platform-provided default config keys in the result. Defaults to false.")
@@ -1063,7 +1276,7 @@ const contentItemSchema = z.object({
 	metadata: z.record(z.unknown()).optional().describe("Arbitrary metadata key-value pairs"),
 	is_premium: z.boolean().optional().describe("Whether this content requires a premium entitlement")
 });
-function registerTools$38(server, apiClient) {
+function registerTools$39(server, apiClient) {
 	registerTool(server, apiClient, "amba_content_libraries_create", "Create a content library for a project. A content library is a collection of content items (tips, quotes, articles) that can be delivered on a schedule to keep users engaged. The library `name` IS the channel handle the in-app SDK uses: `Amba.content.library(name)` reads this library (names are unique). The response echoes it as `channel`.", {
 		project_id: z.string().describe("The project ID"),
 		name: z.string().describe("Library name (e.g. \"Daily Motivation\", \"Workout Tips\")"),
@@ -1281,7 +1494,7 @@ function registerTools$38(server, apiClient) {
 }
 //#endregion
 //#region src/tools/streaks.ts
-function registerTools$37(server, apiClient) {
+function registerTools$38(server, apiClient) {
 	registerTool(server, apiClient, "amba_streaks_create", "Create a streak definition for a project. Streaks track consecutive user engagement (e.g. daily logins, workout completions). Supports configurable periods, grace periods, and freeze mechanics.", {
 		project_id: z.string().describe("The project ID"),
 		key: z.string().regex(/^[a-z0-9_-]{1,64}$/).optional().describe("Stable identifier used by the SDK to qualify a streak without knowing its UUID: `Amba.streaks.qualify(\"daily_login\")`. Lowercase letters, digits, underscore, hyphen, 1-64 characters. Immutable after creation — changing it breaks live SDK calls. When omitted the server derives one from `name`."),
@@ -1373,7 +1586,7 @@ function registerTools$37(server, apiClient) {
 //#endregion
 //#region src/tools/integrations.ts
 const providerEnum = z.enum(INTEGRATION_PROVIDERS);
-function registerTools$36(server, apiClient) {
+function registerTools$37(server, apiClient) {
 	registerTool(server, apiClient, "amba_integrations_configure", "Configure (create or replace) a third-party integration for a project. Supported providers: \"apns\" (Apple Push), \"fcm\" (Firebase Cloud Messaging), \"revenuecat\" (subscription management), \"superwall\" (paywall management), \"stripe_billing\" (web subscriptions through the app's own Stripe Billing account — web purchases grant the same Amba entitlements as mobile ones; the response includes the webhook_url to register in the Stripe dashboard), \"google_play\" (a Play Console service account with the Android Publisher permission — lets `amba_monetization_apply` create one-time Play products directly, price included). Each provider requires specific config fields. Push credentials (.p8 / service-account JSON) are passed inline here and stored server-side automatically — no separate secrets step.", {
 		project_id: z.string().describe("The project ID"),
 		provider: providerEnum.describe("Integration provider name"),
@@ -1443,7 +1656,7 @@ const PERIOD_DAYS = {
 	"30d": "30",
 	"90d": "90"
 };
-function registerTools$35(server, apiClient) {
+function registerTools$36(server, apiClient) {
 	registerTool(server, apiClient, "amba_analytics_get", "Get daily analytics for a project. Returns per-day event counts and unique-user counts for the requested window, plus totals. Use this to verify that end-to-end event tracking is working after seeding and testing.", {
 		project_id: z.string().describe("The project ID"),
 		period: z.enum([
@@ -1465,68 +1678,8 @@ function registerTools$35(server, apiClient) {
 	}, ["amba_get_analytics"]);
 }
 //#endregion
-//#region src/lib/tool-result.ts
-/**
-* Shared MCP tool result helpers.
-*
-* Every tool emits the same `{ content: [{ type: 'text', text: <json> }] }`
-* envelope. Two helpers centralize that:
-*
-*   - [`jsonResult`] — wraps an arbitrary payload.
-*   - [`passthroughResult`] — flattens an upstream HTTP response
-*     (status + parsed body) into the same envelope. Status is written
-*     LAST so a colliding top-level `status` field in the API response
-*     cannot shadow the HTTP status — agents look at `parsed.status` to
-*     distinguish 2xx from 4xx/5xx.
-*
-* Lives in `src/lib/` (vs. `src/tools/_helpers.ts`) to set the same
-* cross-cutting-helper precedent as `src/lib/with-pat.ts` (task #36).
-* `tools/*` files stay strictly tool registrations.
-*/
-/**
-* Wire-shape every MCP tool handler returns.
-*
-* The MCP SDK's `tool()` callback signature is structurally typed and
-* carries an open index signature for `_meta` etc. Declaring our return
-* type as a plain `{ content: [...] }` interface won't satisfy that
-* structural check — so the helpers' return type is left as the actual
-* inferred shape (no explicit interface) and consumers rely on the
-* inference + the SDK's structural compatibility. If we ever want a
-* named alias, write it as a type-alias over the inferred shape rather
-* than a closed interface.
-*/
-/** Wrap an arbitrary payload as a JSON-text tool result. */
-function jsonResult$1(payload) {
-	return { content: [{
-		type: "text",
-		text: JSON.stringify(payload, null, 2)
-	}] };
-}
-/** Preserve an HTTP response wrapper while mapping failures to MCP isError. */
-function httpResult(result) {
-	return {
-		...jsonResult$1(result),
-		...result.status >= 400 ? { isError: true } : {}
-	};
-}
-/**
-* Flatten an upstream HTTP response into the agent-facing tool payload.
-* Body fields are spread FIRST so a future top-level `status` key in
-* the API response cannot shadow the HTTP `status` — agents read
-* `parsed.status` to distinguish 2xx from 4xx/5xx.
-*/
-function passthroughResult(result) {
-	return {
-		...jsonResult$1({
-			...result.body !== null && typeof result.body === "object" ? result.body : {},
-			status: result.status
-		}),
-		...result.status >= 400 ? { isError: true } : {}
-	};
-}
-//#endregion
 //#region src/tools/users.ts
-function registerTools$34(server, apiClient) {
+function registerTools$35(server, apiClient) {
 	registerTool(server, apiClient, "amba_users_list", "List app users for a project. Supports pagination with offset and limit, plus optional search (matches email / external_id / display_name with ILIKE) and segment filter. Returns user profiles including external_id, email, display_name, properties, and activity timestamps.", {
 		project_id: z.string().describe("The project ID"),
 		limit: z.number().optional().describe("Maximum number of users to return (default 50)"),
@@ -1973,7 +2126,7 @@ final dailyLimit = await Amba.config.get<int>('daily_limit', defaultValue: 10);
 final streak = await Amba.streaks.get('daily_login');
 print('Current streak: \${streak.currentCount}');`
 };
-function registerTools$33(server, apiClient) {
+function registerTools$34(server, apiClient) {
 	registerTool(server, apiClient, "amba_sdk_get_setup_instructions", "Get platform-specific code snippets and setup instructions for integrating the Amba client SDK into a mobile app. Supports iOS (Swift), Android (Kotlin), React Native, Expo, and Flutter.", { platform: z.enum([
 		"ios",
 		"android",
@@ -2058,7 +2211,7 @@ const criteriaSchema = z.object({
 	property_key: z.string().optional().describe("User property key (required for property_value type)"),
 	target_value: z.number().describe("Target value to unlock the achievement")
 });
-function registerTools$32(server, apiClient) {
+function registerTools$33(server, apiClient) {
 	registerTool(server, apiClient, "amba_achievements_create", "Create an achievement/badge definition. Achievements unlock automatically when users meet the criteria (e.g. track 5 workouts, reach a 7-day streak, earn 5000 XP). Can optionally award bonus XP on unlock.", {
 		project_id: z.string().describe("The project ID"),
 		key: z.string().describe("Unique key for this achievement (e.g. \"first_workout\", \"streak_master_7\")"),
@@ -2163,7 +2316,7 @@ function registerTools$32(server, apiClient) {
 }
 //#endregion
 //#region src/tools/challenges.ts
-function registerTools$31(server, apiClient) {
+function registerTools$32(server, apiClient) {
 	registerTool(server, apiClient, "amba_challenges_create", "Create a time-limited challenge. Challenges are events that run between start_at and end_at, where users try to reach a goal (e.g. track 10 workouts this week, earn 500 XP in 3 days). Can reward XP and/or unlock an achievement on completion.", {
 		project_id: z.string().describe("The project ID"),
 		name: z.string().describe("Challenge name (e.g. \"7-Day Fitness Sprint\", \"XP Weekend Blitz\")"),
@@ -2274,7 +2427,7 @@ function registerTools$31(server, apiClient) {
 }
 //#endregion
 //#region src/tools/economy.ts
-function registerTools$30(server, apiClient) {
+function registerTools$31(server, apiClient) {
 	registerTool(server, apiClient, "amba_currencies_create", "Create a virtual currency for a project. Currencies can be soft (earned through gameplay) or premium (purchased with real money). Supports auto-recharge for time-gated mechanics like hearts/energy.", {
 		project_id: z.string().describe("The project ID"),
 		code: z.string().describe("Unique currency code (e.g. \"gold\", \"gems\", \"hearts\")"),
@@ -2965,7 +3118,7 @@ const objectTypeSchema = z.enum([
 	"package",
 	"paywall"
 ]);
-function registerTools$29(server, apiClient) {
+function registerTools$30(server, apiClient) {
 	registerTool(server, apiClient, "amba_monetization_plan", "Preview the monetization plan for a project: a three-way diff between the declared subscription config (entitlements, products, offerings, packages, paywalls), the last-adopted baseline, and the live config in the connected provider (RevenueCat). Returns the op-list an apply WOULD perform (create/update/archive/attach/detach/set-current — including store-product creation steps for declared products that do not exist upstream yet), a store-floor preflight (blocking gaps: dangling product references, or no provider app connected for a store), a `human_floor` checklist (store-side steps no API can do — store SKUs outside the App Store, pricing, agreements/banking/tax, review — each with its exact console location, ready to relay to the developer), and any out-of-band drift. READ-ONLY — computes the plan; applies nothing. Use this before changing monetization so you can see exactly what differs.", { project_id: z.string().describe("The project ID") }, async ({ project_id }, { client }) => {
 		const result = await client.get(`/projects/${project_id}/monetization/plan`);
 		return { content: [{
@@ -3031,7 +3184,7 @@ function registerTools$29(server, apiClient) {
 }
 //#endregion
 //#region src/tools/leaderboards.ts
-function registerTools$28(server, apiClient) {
+function registerTools$29(server, apiClient) {
 	registerTool(server, apiClient, "amba_leaderboards_create", "Create a leaderboard definition. Leaderboards rank users by XP, streak length, or a custom metric. Supports all-time, daily, weekly, and monthly periods with configurable max entries. The returned `key` (which equals `name`) is the exact value the in-app SDK passes to `Amba.leaderboards.getEntries(key)` / `getRank(key)`.", {
 		project_id: z.string().describe("The project ID"),
 		name: z.string().describe("Leaderboard name (e.g. \"Top XP Earners\", \"Weekly Streak Leaders\")"),
@@ -3146,7 +3299,7 @@ function registerTools$28(server, apiClient) {
 * rollover (the scheduled weekly rollover) and score live off `xp_awarded`
 * engagement events.
 */
-function registerTools$27(server, apiClient) {
+function registerTools$28(server, apiClient) {
 	registerTool(server, apiClient, "amba_leagues_create", "Create a league tier (e.g. \"Bronze\", tier_order=1). Leagues are the promote/demote ladder: each week users are grouped into cohorts of `cohort_size`, the top `promote_count` move up a tier and the bottom `demote_count` move down. Create one league per tier (lowest tier_order = entry tier). Members are assigned by the weekly rollover, not at create time.", {
 		project_id: z.string().describe("The project ID"),
 		name: z.string().describe("League tier name, e.g. \"Bronze\", \"Silver\", \"Gold\""),
@@ -3209,7 +3362,7 @@ function registerTools$27(server, apiClient) {
 }
 //#endregion
 //#region src/tools/platform.ts
-function registerTools$26(server, apiClient) {
+function registerTools$27(server, apiClient) {
 	registerTool(server, apiClient, "amba_onboarding_create", "Create an onboarding flow for a project. Onboarding flows define step-by-step experiences for new users (e.g. welcome screens, permission prompts, feature tours).", {
 		project_id: z.string().describe("The project ID"),
 		name: z.string().describe("Flow name (e.g. \"Welcome Flow\", \"Premium Onboarding\")"),
@@ -3862,7 +4015,7 @@ function registerTools$26(server, apiClient) {
 }
 //#endregion
 //#region src/tools/social.ts
-function registerTools$25(server, apiClient) {
+function registerTools$26(server, apiClient) {
 	registerTool(server, apiClient, "amba_friendships_get_stats", "Get friendship statistics for a project. Returns total friendships, pending requests, accepted friendships, and blocked count.", { project_id: z.string().describe("The project ID") }, async ({ project_id }, { client }) => {
 		const result = await client.get(`/projects/${project_id}/friends/stats`);
 		return { content: [{
@@ -4187,7 +4340,7 @@ function registerTools$25(server, apiClient) {
 }
 //#endregion
 //#region src/tools/xp.ts
-function registerTools$24(server, apiClient) {
+function registerTools$25(server, apiClient) {
 	registerTool(server, apiClient, "amba_xp_rules_create", "Create an XP rule that auto-awards XP when a matching engagement event is tracked. For example, award 50 XP every time a user completes a workout, with optional daily caps and cooldowns.", {
 		project_id: z.string().describe("The project ID"),
 		name: z.string().describe("Rule name (e.g. \"Workout Completed\", \"Daily Login Bonus\")"),
@@ -4310,7 +4463,7 @@ function registerTools$24(server, apiClient) {
 }
 //#endregion
 //#region src/tools/events.ts
-function registerTools$23(server, apiClient) {
+function registerTools$24(server, apiClient) {
 	registerTool(server, apiClient, "amba_events_list", "List engagement events for a project (most recent first) with cursor pagination on (occurred_at, id). Defaults to the last 24 hours when `since` is omitted. Pass `next_cursor` from a previous page back as `cursor` to continue.", {
 		project_id: z.string().describe("The project ID"),
 		since: z.string().optional().describe("ISO-8601 lower bound for occurred_at. Defaults to 24h ago."),
@@ -4401,7 +4554,7 @@ function registerTools$23(server, apiClient) {
 }
 //#endregion
 //#region src/tools/event-catalog.ts
-function registerTools$22(server, apiClient) {
+function registerTools$23(server, apiClient) {
 	registerTool(server, apiClient, "amba_events_catalog", "Discover every event you can subscribe a webhook to — both APP events (inside your app: users, gamification, economy, social, content) and CONTROL-plane lifecycle events (about the project itself: provisioning, deploys, domains, billing). Returns each event's type, plane, payload example, and status (`live` = emitted today, `planned` = catalogued, not yet wired). Production pattern: after standing up a project, call this, then subscribe to the lifecycle events you care about (e.g. `domain.registered`, `site.deploy.completed`) with amba_control_webhooks_create and to app events with amba_webhooks_create. Subscriptions match an exact name, a namespace wildcard (`economy.*`), or all (`*`). Pass plane to filter.", {
 		project_id: z.string().describe("The project ID"),
 		plane: z.enum(["app", "control"]).optional().describe("Filter to one plane. Omit for both.")
@@ -4471,7 +4624,7 @@ const funnelStepSchema = z.object({
 	event: z.string().describe("Event name to match (engagement event_name)."),
 	filters: z.array(funnelFilterSchema).optional().describe("Optional property predicates, ANDed together, that an event must satisfy.")
 });
-function registerTools$21(server, apiClient) {
+function registerTools$22(server, apiClient) {
 	registerTool(server, apiClient, "amba_funnels_list", "List conversion funnels for a project. A funnel is a saved, ordered sequence of steps (event + optional property filters) plus a conversion window. Returns the definitions only — use amba_funnels_query to compute per-step counts.", { project_id: z.string().describe("The project ID") }, async ({ project_id }, { client }) => {
 		const result = await client.get(`/projects/${project_id}/funnels`);
 		return { content: [{
@@ -4568,7 +4721,10 @@ function registerTools$21(server, apiClient) {
 //#region src/tools/auth.ts
 async function authFetch(apiClient, options) {
 	const url = `${apiClient.getApiRoot()}${options.path}`;
-	const headers = { Accept: "application/json" };
+	const headers = {
+		...apiClient.getAuthProxyHeaders?.(),
+		Accept: "application/json"
+	};
 	if (options.body !== void 0) headers["Content-Type"] = "application/json";
 	if (options.bearer) headers["Authorization"] = `Bearer ${options.bearer}`;
 	if (options.signupToken) headers["X-Amba-Signup-Token"] = options.signupToken;
@@ -4654,6 +4810,20 @@ const LOGIN_AGENT_INSTRUCTIONS = [
 	"For browser-based MCP clients (Claude.ai web) that cannot read a static config file,",
 	"direct the customer to https://mcp.amba.dev/authorize to complete the OAuth flow instead."
 ].join(" ");
+/** The 403 codes signup answers with when new accounts are gated. */
+const SIGNUP_ACCESS_ERROR_CODES = new Set([
+	"SIGNUPS_CLOSED",
+	"INVITE_REQUIRED",
+	"INVITE_INVALID"
+]);
+const SIGNUP_ACCESS_AGENT_INSTRUCTIONS = [
+	"New Amba accounts are gated right now. On INVITE_REQUIRED or INVITE_INVALID, ask the human for their",
+	"invite code (it starts with AMBA- and arrives in their invite email) and call this tool again with `invite_code`.",
+	"On SIGNUPS_CLOSED, or when they have no code, request access for them with",
+	"POST /v1/auth/developer/waitlist {\"email\",\"note\"} using their own email (or send them to",
+	"`error.details.request_access_url`), tell them the invite code arrives by email, then stop.",
+	"Retry only with a code the human gives you; never invent codes or switch emails."
+].join(" ");
 /**
 * Extract a usable PAT string from a signup/login response body.
 *
@@ -4669,15 +4839,30 @@ function extractPat(body) {
 	if (typeof obj.access_token === "string" && obj.access_token.length > 0) return obj.access_token;
 	return null;
 }
+/** The `error.code` of a gated-signup 403 body, else null. */
+function signupAccessErrorCode(result) {
+	if (result.status !== 403 || result.body === null || typeof result.body !== "object") return null;
+	const code = result.body.error?.code;
+	return typeof code === "string" && SIGNUP_ACCESS_ERROR_CODES.has(code) ? code : null;
+}
 /**
 * Like `passthroughResult` but enriches successful signup/login bodies
 * with the agent-facing `mcp_config` + `agent_instructions` block.
 *
-* Only applied on 2xx — error bodies are returned untouched so the agent
-* can still surface API-level error codes (EMAIL_EXISTS, WEAK_PASSWORD,
-* INVALID_CREDENTIALS, …) unambiguously.
+* Error bodies keep their API-level codes (EMAIL_EXISTS, WEAK_PASSWORD,
+* INVALID_CREDENTIALS, …) verbatim. A gated-signup 403 (SIGNUPS_CLOSED,
+* INVITE_REQUIRED, INVITE_INVALID) additionally carries
+* `agent_instructions` describing the invite / request-access path.
 */
 function enrichedAuthResult(result, agentInstructions) {
+	if (signupAccessErrorCode(result) !== null) return {
+		...jsonResult$1({
+			...result.body,
+			agent_instructions: SIGNUP_ACCESS_AGENT_INSTRUCTIONS,
+			status: result.status
+		}),
+		isError: true
+	};
 	if (result.status < 200 || result.status >= 300) return passthroughResult(result);
 	const pat = extractPat(result.body);
 	if (pat === null) return passthroughResult(result);
@@ -4688,7 +4873,15 @@ function enrichedAuthResult(result, agentInstructions) {
 		status: result.status
 	});
 }
-function registerTools$20(server, apiClient) {
+const INVITE_CODE_PARAM = z.string().optional().describe("Platform invite code from the human's invite email (starts with AMBA-; case, spaces and dashes are ignored). Required while new accounts are invite-only; ask the human for it.");
+const SIGNUP_ACCESS_ERRORS_DESCRIPTION = [
+	"While signups are gated it answers 403: INVITE_REQUIRED (no invite_code sent) or INVITE_INVALID",
+	"(mistyped, expired, revoked or used up) → ask the human for their code and retry with `invite_code`;",
+	"SIGNUPS_CLOSED → no new accounts right now. On SIGNUPS_CLOSED, or when the human has no code,",
+	"request access via POST /v1/auth/developer/waitlist {\"email\",\"note\"} with their own email",
+	"(or `error.details.request_access_url`), tell the human the invite code arrives by email, and stop."
+].join(" ");
+function registerTools$21(server, apiClient) {
 	registerPublicTool(server, "amba_developer_signup", [
 		"Create a new Amba developer account. Returns a long-lived Personal Access Token (PAT)",
 		"plus a real isolated Amba project (provisioning asynchronously), plus ready-to-paste",
@@ -4702,19 +4895,24 @@ function registerTools$20(server, apiClient) {
 		"Poll `amba_projects_get_provisioning_status` until the project flips to status='active' (~10s)",
 		"before issuing client-plane traffic against the returned API keys.",
 		"Email is normalized to lowercase. Password must be at least 8 characters.",
-		"Errors: 409 EMAIL_EXISTS, 400 WEAK_PASSWORD/INVALID_INPUT, 429 if rate-limited (5/min, 50/day per IP)."
+		"Errors: 409 EMAIL_EXISTS (the address, or a +tag / Gmail-dot alias of it, is already registered),",
+		"400 DISPOSABLE_EMAIL (temporary-inbox domain; use a permanent address), 400 WEAK_PASSWORD/INVALID_INPUT,",
+		"429 if rate-limited (5/min, 50/day per IP).",
+		SIGNUP_ACCESS_ERRORS_DESCRIPTION
 	].join(" "), {
 		email: z.string().email().describe("Developer email address. Will be lowercased."),
 		password: z.string().min(8).describe("Password, minimum 8 characters."),
 		name: z.string().optional().describe("Optional display name."),
-		referral_code: z.string().optional().describe("Optional Amba partner referral code the developer arrived with (the `ref` on a partner's link). Attributes a later paid upgrade to that partner; ignored if not a live partner code.")
-	}, async ({ email, password, name, referral_code }) => {
+		referral_code: z.string().optional().describe("Optional Amba partner referral code the developer arrived with (the `ref` on a partner's link). Attributes a later paid upgrade to that partner; ignored if not a live partner code."),
+		invite_code: INVITE_CODE_PARAM
+	}, async ({ email, password, name, referral_code, invite_code }) => {
 		const body = {
 			email,
 			password
 		};
 		if (name !== void 0) body.name = name;
 		if (referral_code !== void 0) body.referral_code = referral_code;
+		if (invite_code !== void 0) body.invite_code = invite_code;
 		const signupToken = apiClient.getSignupToken();
 		return enrichedAuthResult(await authFetch(apiClient, {
 			method: "POST",
@@ -4730,18 +4928,21 @@ function registerTools$20(server, apiClient) {
 		"(amba_affiliate_invite with affiliate_org_id), then set up payouts with",
 		"amba_affiliate_my_payout_account_create. Agent: pass the returned `pat` inline on subsequent calls",
 		"and write the mcp_config snippet to the customer's MCP config for future sessions.",
-		"Email is lowercased; password must be at least 8 characters."
+		"Email is lowercased; password must be at least 8 characters.",
+		SIGNUP_ACCESS_ERRORS_DESCRIPTION
 	].join(" "), {
 		email: z.string().email().describe("Affiliate email address. Will be lowercased."),
 		password: z.string().min(8).describe("Password, minimum 8 characters."),
 		name: z.string().optional().describe("Optional display name."),
-		invite_token: z.string().optional().describe("Optional affiliate invite token (for reference).")
-	}, async ({ email, password, name }) => {
+		invite_token: z.string().optional().describe("Optional affiliate invite token (for reference)."),
+		invite_code: INVITE_CODE_PARAM
+	}, async ({ email, password, name, invite_code }) => {
 		const body = {
 			email,
 			password
 		};
 		if (name !== void 0) body.name = name;
+		if (invite_code !== void 0) body.invite_code = invite_code;
 		const signupToken = apiClient.getSignupToken();
 		return enrichedAuthResult(await authFetch(apiClient, {
 			method: "POST",
@@ -4756,7 +4957,8 @@ function registerTools$20(server, apiClient) {
 		"Agent: keep working in this same session by passing `pat` as an inline arg on every",
 		"subsequent `amba_*` tool call. Also write the matching snippet to the customer's MCP",
 		"config file so future sessions pick the PAT up as the inbound Bearer automatically — the customer does nothing.",
-		"Errors: 401 INVALID_CREDENTIALS, 429 if rate-limited (10/min, 100/day per IP)."
+		"Errors: 401 INVALID_CREDENTIALS, 429 if rate-limited (10/min, 100/day per IP; 20 failed",
+		"attempts/hour, 100/day per account)."
 	].join(" "), {
 		email: z.string().email().describe("Developer email address."),
 		password: z.string().describe("Developer password.")
@@ -4825,6 +5027,41 @@ function registerTools$20(server, apiClient) {
 	});
 }
 //#endregion
+//#region src/tools/developer-claim.ts
+function registerTools$20(server, apiClient) {
+	registerTool(server, apiClient, "amba_developer_claim", [
+		"Claim an agent-created sandbox account for its human owner. Emails a single-use link to `email`;",
+		"when the owner clicks it the account takes that address, becomes verified, and any unclaimed-sandbox",
+		"hold or archive on its projects lifts immediately. Call this as soon as you know who owns the app:",
+		"each free project of an unclaimed sandbox gets a claim notice from day 7 of its own clock, goes on hold",
+		"on day 14, and is archived (nothing deleted) on day 90. Requires the sandbox account's PAT. Errors: 409 ALREADY_CLAIMED,",
+		"409 EMAIL_TAKEN, 429 when called too often."
+	].join(" "), { email: z.string().email().describe("The human owner's email address.") }, async (args, { pat }) => {
+		const res = await fetch(`${apiClient.getApiRoot()}/auth/developer/claim`, {
+			method: "POST",
+			headers: {
+				Accept: "application/json",
+				"Content-Type": "application/json",
+				Authorization: `Bearer ${pat}`
+			},
+			body: JSON.stringify({ email: args.email })
+		});
+		let body;
+		try {
+			body = await res.json();
+		} catch {
+			body = { error: {
+				code: "INVALID_RESPONSE",
+				message: res.statusText
+			} };
+		}
+		return passthroughResult({
+			status: res.status,
+			body
+		});
+	});
+}
+//#endregion
 //#region src/tools/collections.ts
 async function adminFetch$1(apiClient, options) {
 	let url = `${apiClient.getBaseUrl()}${options.path}`;
@@ -5742,16 +5979,7 @@ async function rawFetch(baseUrl, bearer, method, path, options) {
 		headers,
 		body
 	});
-	if (!res.ok) {
-		let errorMessage = res.statusText;
-		let errorCode;
-		try {
-			const errBody = await res.json();
-			errorMessage = errBody?.error?.message ?? res.statusText;
-			errorCode = errBody?.error?.code;
-		} catch {}
-		throw new AmbaApiError(res.status, errorCode, errorMessage);
-	}
+	if (!res.ok) throw await ambaApiErrorFromResponse(res);
 	if (res.status === 204) return;
 	return await res.json();
 }
@@ -6908,7 +7136,36 @@ const TIER_CATALOG = {
 			},
 			max_projects_per_account: 2,
 			sleeps_after_inactivity_days: 14,
-			all_categories: true
+			database: {
+				max_compute_units: .25,
+				compute_cu_hours_per_month: 10,
+				storage_mb: 512,
+				at_compute_cap: "database pauses until the period resets or the project upgrades",
+				at_storage_cap: "writes that add data are refused; reads and deletes keep working",
+				upgrade_tool: "amba_billing_upgrade"
+			},
+			all_categories: true,
+			free_tier_limits: {
+				paid_features: [
+					"custom_domains",
+					"domain_purchase",
+					"email_send",
+					"email_templates",
+					"app_builder"
+				],
+				auth_emails_per_day: 100,
+				sms_otp_per_day: 10,
+				push_campaign_sends_per_day: 3,
+				push_direct_sends_per_day: 100,
+				function_invocations_per_day: 1e4,
+				function_cpu_ms_per_invocation: 50,
+				function_schedules: 2,
+				function_schedule_min_interval_minutes: 60,
+				queue_messages_per_day: 1e3,
+				tracked_links_per_day: 50,
+				sites: "preview bar + noindex on *.app.amba.host",
+				docs: "https://docs.amba.dev/billing#free-tier-limits"
+			}
 		},
 		{
 			name: "pro",
@@ -6922,6 +7179,11 @@ const TIER_CATALOG = {
 				media_storage_mb: 1024
 			},
 			sleeps_after_inactivity_days: null,
+			database: {
+				max_compute_units: 1,
+				compute_cu_hours_per_month: null,
+				storage_mb: null
+			},
 			all_categories: true
 		},
 		{
@@ -6936,6 +7198,11 @@ const TIER_CATALOG = {
 				media_storage_mb: 25600
 			},
 			sleeps_after_inactivity_days: null,
+			database: {
+				max_compute_units: 1,
+				compute_cu_hours_per_month: null,
+				storage_mb: null
+			},
 			all_categories: true
 		},
 		{
@@ -6973,7 +7240,7 @@ const TIER_CATALOG = {
 	}
 };
 function registerTools$9(server, apiClient) {
-	registerTool(server, apiClient, "amba_billing_status", "Get the persisted billing `tier`, runtime `effective_tier` (use this for quota/feature decisions), comp status, current-period usage by meter (MAU, events, push, db_storage, media_storage, agent tool calls) with per-meter cost, the billing period and its reset date, spend ceiling + percent consumed, a projected end-of-period overage, the live enforcement state (whether the project is in read-only mode — metered writes returning 402 — and which meters are over quota), and what (if any) human action is required before the agent can continue safely. Use this BEFORE provisioning new features or running data-heavy workloads so the agent can self-throttle or escalate to the human.", { project_id: z.string().describe("The project ID") }, async ({ project_id }, { client }) => {
+	registerTool(server, apiClient, "amba_billing_status", "Get the persisted billing `tier`, runtime `effective_tier` (use this for quota/feature decisions), comp status, current-period usage by meter (MAU, events, push, db_storage, media_storage, agent tool calls) with per-meter cost, the billing period and its reset date, spend ceiling + percent consumed, a projected end-of-period overage, the live enforcement state (whether the project is in read-only mode — metered writes returning 402 — and which meters are over quota), and what (if any) human action is required before the agent can continue safely. The `database` block reports the database limits: compute used vs the free-tier cap in CU-hours (`compute.used_cu_hours`, `compute.limit_cu_hours`, `compute.pct`), storage in MB (`storage.used_mb`, `storage.limit_mb`), the reset date (`period.resets_at`), and `limit_reached`. At the compute cap the database pauses and every database-backed call returns 402 FREE_TIER_LIMIT_REACHED until the period resets or the project upgrades with amba_billing_upgrade. Use this BEFORE provisioning new features or running data-heavy workloads so the agent can self-throttle, and recommend the upgrade once `database.compute.pct` reaches 0.8.", { project_id: z.string().describe("The project ID") }, async ({ project_id }, { client }) => {
 		const result = await client.get(`/projects/${project_id}/billing/status`);
 		return { content: [{
 			type: "text",
@@ -6986,6 +7253,25 @@ function registerTools$9(server, apiClient) {
 			text: JSON.stringify(TIER_CATALOG, null, 2)
 		}] };
 	});
+	registerTool(server, apiClient, "amba_billing_upgrade", "Move a project to a paid plan in one call: returns a checkout link for the project owner to open (the agent cannot complete payment). This is the call that lifts the free-tier database caps. Free projects run on a small database (0.25 compute units, 10 CU-hours of compute per billing month, 512 MB); at the compute cap the database pauses until the period resets, so an app with real users belongs on a paid plan, where there is no database compute cap. Call it when a request returns 402 FREE_TIER_LIMIT_REACHED (its `details.upgrade.mcp_args` carries the exact arguments), or when amba_billing_status shows `database.compute.pct` at 0.8 or more. Pro is the right default; Scale is for high-traffic apps. The plan applies as soon as checkout completes and a paused database resumes within seconds. This is a write action that leads to a charge: surface the link and the price to the human before calling, then give them the URL.", {
+		project_id: z.string().describe("The project ID"),
+		tier: z.enum(["pro", "scale"]).default("pro").describe("Paid plan: \"pro\" ($20/month) or \"scale\" ($200/month). Defaults to pro."),
+		interval: z.enum(["month", "year"]).default("month").describe("Billing interval. Annual plans bill 12 months at a 20% discount.")
+	}, async ({ project_id, tier, interval }, { client }) => {
+		const url = (await client.post(`/projects/${project_id}/billing/checkout`, {
+			tier: tier ?? "pro",
+			interval: interval ?? "month"
+		}))?.data?.url ?? null;
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				checkout_url: url,
+				tier: tier ?? "pro",
+				interval: interval ?? "month",
+				next_step: url ? "Give this checkout link to the project owner. The paid plan (and the lifted database caps) apply as soon as they complete checkout." : "Checkout did not return a link; check amba_billing_status for the current subscription state."
+			}, null, 2)
+		}] };
+	});
 	registerTool(server, apiClient, "amba_billing_set_ceiling", "Set or remove the monthly spend ceiling for a project. When the current billing period's overage cost reaches the ceiling, the project degrades to read-only mode: metered WRITE operations (tracking events, inserting collection rows, uploads, push sends, new signups) return 402 with a machine-readable payload (code, current usage, ceiling, reset date) while reads keep working. Control-plane webhook events `billing.ceiling_warning` / `billing.ceiling_reached` fire once per period at 80% / 100% so you can alert. The new ceiling takes effect immediately. Pass ceiling_usd: null to remove the ceiling (linear overage with no cap). This is a write action — surface to the human before calling.", {
 		project_id: z.string().describe("The project ID"),
 		ceiling_usd: z.number().min(0).max(1e5).nullable().describe("Maximum monthly bill in USD, or null to disable")
@@ -9806,6 +10092,7 @@ const TOOL_CATEGORY = {
 	amba_developer_me: "identity",
 	amba_developer_verify: "identity",
 	amba_developer_rotate_pat: "identity",
+	amba_developer_claim: "identity",
 	amba_users_list: "identity",
 	amba_list_users: "identity",
 	amba_users_create: "identity",
@@ -10290,6 +10577,7 @@ const TOOL_CATEGORY = {
 	amba_billing_status: "infrastructure",
 	amba_billing_tiers: "infrastructure",
 	amba_billing_set_ceiling: "infrastructure",
+	amba_billing_upgrade: "infrastructure",
 	amba_payments_account_create: "economy",
 	amba_payments_create_onboarding_link: "economy",
 	amba_payments_account_status: "economy",
@@ -11280,10 +11568,12 @@ async function registerAutoMcpTools(server, apiClient, options) {
 * called against it once.
 */
 function registerAllTools(server, apiClient) {
+	registerTools$21(server, apiClient);
 	registerTools$20(server, apiClient);
-	registerTools$42(server, apiClient);
+	registerTools$43(server, apiClient);
 	registerTools$5(server, apiClient);
 	registerTools$3(server, apiClient);
+	registerTools$42(server, apiClient);
 	registerTools$41(server, apiClient);
 	registerTools$40(server, apiClient);
 	registerTools$39(server, apiClient);
@@ -11304,7 +11594,6 @@ function registerAllTools(server, apiClient) {
 	registerTools$24(server, apiClient);
 	registerTools$23(server, apiClient);
 	registerTools$22(server, apiClient);
-	registerTools$21(server, apiClient);
 	registerTools$19(server, apiClient);
 	registerTools$18(server, apiClient);
 	registerTools$17(server, apiClient);
@@ -11337,6 +11626,7 @@ function createApiClient(options) {
 	const opts = {};
 	if (options.baseUrl !== void 0) opts.baseUrl = options.baseUrl;
 	if (options.signupToken !== void 0) opts.signupToken = options.signupToken;
+	if (options.authProxyHeaders !== void 0) opts.authProxyHeaders = options.authProxyHeaders;
 	if (options.token !== void 0) {
 		const token = options.token;
 		opts.getToken = async () => token;