@aigne/afs-tesla 1.11.0-beta.12

package/dist/tesla-provider.cjs

@@ -0,0 +1,1720 @@
+const require_auth = require('./auth.cjs');
+const require_client = require('./client.cjs');
+const require_decorate = require('./_virtual/_@oxc-project_runtime@0.108.0/helpers/decorate.cjs');
+let _aigne_afs = require("@aigne/afs");
+let _aigne_afs_provider = require("@aigne/afs/provider");
+let ufo = require("ufo");
+let zod = require("zod");
+
+//#region src/tesla-provider.ts
+const afsTeslaOptionsSchema = zod.z.object({
+	name: zod.z.string().default("tesla"),
+	description: zod.z.string().optional(),
+	clientId: zod.z.string(),
+	clientSecret: zod.z.string(),
+	redirectUri: zod.z.string().default("https://localhost:8443/callback"),
+	region: zod.z.enum([
+		"na",
+		"eu",
+		"cn"
+	]).default("na"),
+	cacheTtl: zod.z.number().default(60),
+	cacheTtlStatic: zod.z.number().default(300),
+	autoWake: zod.z.boolean().default(false),
+	_testToken: zod.z.string().optional(),
+	_testBaseUrl: zod.z.string().optional()
+});
+const VEHICLE_ACTIONS = [
+	{
+		name: "wake",
+		severity: "boundary",
+		description: "Wake vehicle"
+	},
+	{
+		name: "lock",
+		severity: "boundary",
+		description: "Lock doors"
+	},
+	{
+		name: "unlock",
+		severity: "critical",
+		description: "Unlock doors"
+	},
+	{
+		name: "trunk",
+		severity: "boundary",
+		description: "Open/close trunk"
+	},
+	{
+		name: "frunk",
+		severity: "boundary",
+		description: "Open frunk"
+	},
+	{
+		name: "horn",
+		severity: "ambient",
+		description: "Honk horn"
+	},
+	{
+		name: "flash",
+		severity: "ambient",
+		description: "Flash lights"
+	},
+	{
+		name: "climate-on",
+		severity: "ambient",
+		description: "Start HVAC"
+	},
+	{
+		name: "climate-off",
+		severity: "ambient",
+		description: "Stop HVAC"
+	},
+	{
+		name: "set-temp",
+		severity: "ambient",
+		description: "Set temperature"
+	},
+	{
+		name: "charge-start",
+		severity: "boundary",
+		description: "Start charging"
+	},
+	{
+		name: "charge-stop",
+		severity: "boundary",
+		description: "Stop charging"
+	},
+	{
+		name: "set-charge-limit",
+		severity: "ambient",
+		description: "Set charge limit"
+	},
+	{
+		name: "sentry-on",
+		severity: "boundary",
+		description: "Enable sentry mode"
+	},
+	{
+		name: "sentry-off",
+		severity: "boundary",
+		description: "Disable sentry mode"
+	},
+	{
+		name: "set-charging-amps",
+		severity: "ambient",
+		description: "Set charging amperage"
+	},
+	{
+		name: "seat-heater",
+		severity: "ambient",
+		description: "Set seat heater level"
+	},
+	{
+		name: "charge-port-open",
+		severity: "boundary",
+		description: "Open charge port"
+	},
+	{
+		name: "charge-port-close",
+		severity: "boundary",
+		description: "Close charge port"
+	},
+	{
+		name: "navigate",
+		severity: "boundary",
+		description: "Navigate to address"
+	},
+	{
+		name: "share",
+		severity: "ambient",
+		description: "Share to vehicle"
+	},
+	{
+		name: "window-vent",
+		severity: "boundary",
+		description: "Vent windows"
+	},
+	{
+		name: "window-close",
+		severity: "boundary",
+		description: "Close windows"
+	},
+	{
+		name: "homelink",
+		severity: "boundary",
+		description: "Trigger HomeLink"
+	},
+	{
+		name: "remote-start",
+		severity: "critical",
+		description: "Remote start drive"
+	},
+	{
+		name: "schedule-update",
+		severity: "boundary",
+		description: "Schedule software update"
+	},
+	{
+		name: "cancel-update",
+		severity: "ambient",
+		description: "Cancel software update"
+	}
+];
+const ENERGY_ACTIONS = [
+	{
+		name: "set-backup-reserve",
+		severity: "boundary",
+		description: "Set backup reserve percent"
+	},
+	{
+		name: "set-operation-mode",
+		severity: "boundary",
+		description: "Set operation mode"
+	},
+	{
+		name: "storm-mode-on",
+		severity: "boundary",
+		description: "Enable storm watch"
+	},
+	{
+		name: "storm-mode-off",
+		severity: "boundary",
+		description: "Disable storm watch"
+	}
+];
+const VEHICLE_SUB_PATHS = [
+	"state",
+	"charge",
+	"climate",
+	"location",
+	"drive",
+	"vehicle",
+	"nearby-chargers",
+	"release-notes"
+];
+const VEHICLE_COMMAND_MAP = {
+	lock: "door_lock",
+	unlock: "door_unlock",
+	trunk: "actuate_trunk",
+	frunk: "actuate_trunk",
+	horn: "honk_horn",
+	flash: "flash_lights",
+	"climate-on": "auto_conditioning_start",
+	"climate-off": "auto_conditioning_stop",
+	"set-temp": "set_temps",
+	"charge-start": "charge_start",
+	"charge-stop": "charge_stop",
+	"set-charge-limit": "set_charge_limit",
+	"sentry-on": "set_sentry_mode",
+	"sentry-off": "set_sentry_mode",
+	"set-charging-amps": "set_charging_amps",
+	"seat-heater": "remote_seat_heater_request",
+	"charge-port-open": "charge_port_door_open",
+	"charge-port-close": "charge_port_door_close",
+	navigate: "navigation_request",
+	share: "share",
+	"window-vent": "window_control",
+	"window-close": "window_control",
+	homelink: "trigger_homelink",
+	"remote-start": "remote_start_drive",
+	"schedule-update": "schedule_software_update",
+	"cancel-update": "cancel_software_update"
+};
+var AFSTesla = class AFSTesla extends _aigne_afs_provider.AFSBaseProvider {
+	static securityProfiles() {
+		return {
+			admin: {
+				actionPolicy: "full",
+				sensitivity: "full"
+			},
+			user: {
+				actionPolicy: "standard",
+				sensitiveFields: [
+					"latitude",
+					"longitude",
+					"native_latitude",
+					"native_longitude",
+					"vin",
+					"odometer"
+				],
+				sensitivity: "redacted"
+			},
+			guest: {
+				actionPolicy: "safe",
+				accessMode: "readonly",
+				blockedActions: [
+					"unlock",
+					"remote-start",
+					"navigate"
+				],
+				sensitiveFields: [
+					"latitude",
+					"longitude",
+					"native_latitude",
+					"native_longitude",
+					"vin",
+					"odometer"
+				],
+				sensitivity: "redacted"
+			}
+		};
+	}
+	name;
+	description;
+	accessMode = "readwrite";
+	client;
+	options;
+	constructor(input) {
+		super();
+		const options = afsTeslaOptionsSchema.parse(input);
+		this.options = options;
+		this.name = options.name ?? "tesla";
+		this.description = options.description ?? "Tesla Fleet API";
+		const token = options._testToken || input.token || input.auth?.token || input._token || "";
+		if (!token) throw new _aigne_afs.AFSError("Tesla access token is required. Provide OAuth credentials output token or _testToken for tests.", "AFS_AUTH_ERROR");
+		this.client = new require_client.FleetClient({
+			token,
+			region: options.region,
+			baseUrl: options._testBaseUrl,
+			cacheTtl: options.cacheTtl,
+			cacheTtlStatic: options.cacheTtlStatic
+		});
+	}
+	static schema() {
+		return afsTeslaOptionsSchema;
+	}
+	static auth() {
+		return require_auth.TeslaAuth;
+	}
+	static manifest() {
+		return {
+			name: "tesla",
+			description: "Tesla Fleet API — vehicles and energy products as filesystem.\n- Browse vehicle state (charge, climate, location, drive)\n- Execute commands (lock, unlock, climate, charging)\n- Monitor energy sites (Powerwall, Solar)\n- Path structure: `/vehicles/{vin}/{state}` and `/energy/{siteId}/{data}`",
+			uriTemplate: "tesla://{region}",
+			category: "iot",
+			schema: afsTeslaOptionsSchema,
+			tags: [
+				"tesla",
+				"vehicle",
+				"ev",
+				"energy",
+				"powerwall",
+				"solar"
+			],
+			capabilityTags: [
+				"read-write",
+				"crud",
+				"search",
+				"auth:oauth",
+				"remote",
+				"http",
+				"rate-limited"
+			],
+			security: {
+				riskLevel: "external",
+				resourceAccess: ["internet"],
+				dataSensitivity: ["personal-data"],
+				notes: ["Controls physical vehicles — lock/unlock, climate, charging", "Exposes vehicle location and driving data"]
+			},
+			capabilities: {
+				network: {
+					egress: true,
+					allowedDomains: ["fleet-api.prd.*.vn.cloud.tesla.com", "fleet-auth.prd.vn.cloud.tesla.com"]
+				},
+				secrets: ["tesla/access-token"]
+			}
+		};
+	}
+	static treeSchema() {
+		return {
+			operations: [
+				"list",
+				"read",
+				"search",
+				"exec",
+				"stat",
+				"explain"
+			],
+			tree: {
+				"/": { kind: "tesla:account" },
+				"/vehicles": {
+					kind: "tesla:vehicle-group",
+					operations: [
+						"list",
+						"read",
+						"search"
+					]
+				},
+				"/vehicles/{vin}": {
+					kind: "tesla:vehicle",
+					operations: [
+						"list",
+						"read",
+						"exec"
+					],
+					actions: [
+						"wake",
+						"lock",
+						"unlock",
+						"trunk",
+						"frunk",
+						"horn",
+						"flash",
+						"climate-on",
+						"climate-off",
+						"set-temp",
+						"charge-start",
+						"charge-stop",
+						"set-charge-limit",
+						"sentry-on",
+						"sentry-off",
+						"set-charging-amps",
+						"seat-heater",
+						"charge-port-open",
+						"charge-port-close",
+						"navigate",
+						"share",
+						"window-vent",
+						"window-close",
+						"homelink",
+						"remote-start",
+						"schedule-update",
+						"cancel-update"
+					],
+					destructive: ["unlock", "remote-start"]
+				},
+				"/vehicles/{vin}/state": {
+					kind: "tesla:vehicle-state",
+					operations: ["read"]
+				},
+				"/vehicles/{vin}/charge": {
+					kind: "tesla:vehicle-state",
+					operations: ["read"]
+				},
+				"/vehicles/{vin}/climate": {
+					kind: "tesla:vehicle-state",
+					operations: ["read"]
+				},
+				"/vehicles/{vin}/location": {
+					kind: "tesla:vehicle-state",
+					operations: ["read"]
+				},
+				"/vehicles/{vin}/drive": {
+					kind: "tesla:vehicle-state",
+					operations: ["read"]
+				},
+				"/vehicles/{vin}/vehicle": {
+					kind: "tesla:vehicle-state",
+					operations: ["read"]
+				},
+				"/vehicles/{vin}/nearby-chargers": {
+					kind: "tesla:charger-list",
+					operations: ["read"]
+				},
+				"/vehicles/{vin}/release-notes": {
+					kind: "tesla:release-notes",
+					operations: ["read"]
+				},
+				"/energy": {
+					kind: "tesla:energy-group",
+					operations: [
+						"list",
+						"read",
+						"search"
+					]
+				},
+				"/energy/{siteId}": {
+					kind: "tesla:energy-site",
+					operations: [
+						"list",
+						"read",
+						"exec"
+					],
+					actions: [
+						"set-backup-reserve",
+						"set-operation-mode",
+						"storm-mode-on",
+						"storm-mode-off"
+					]
+				},
+				"/energy/{siteId}/live": {
+					kind: "tesla:energy-state",
+					operations: ["read"]
+				},
+				"/energy/{siteId}/history": {
+					kind: "tesla:energy-state",
+					operations: ["read"]
+				}
+			},
+			auth: {
+				type: "oauth",
+				env: ["TESLA_CLIENT_ID", "TESLA_CLIENT_SECRET"]
+			},
+			bestFor: [
+				"vehicle monitoring",
+				"energy management",
+				"EV charging"
+			],
+			notFor: ["file storage", "database queries"]
+		};
+	}
+	static async load({ config } = {}) {
+		return new AFSTesla(config ?? {});
+	}
+	async listRoot() {
+		return { data: [this.buildEntry("/vehicles", {
+			id: "vehicles",
+			meta: {
+				kind: "tesla:vehicle-group",
+				childrenCount: -1,
+				description: "Vehicles"
+			}
+		}), this.buildEntry("/energy", {
+			id: "energy",
+			meta: {
+				kind: "tesla:energy-group",
+				childrenCount: -1,
+				description: "Energy sites"
+			}
+		})] };
+	}
+	async readRoot() {
+		return this.buildEntry("/", {
+			id: "tesla",
+			content: {
+				type: "tesla:account",
+				region: this.options.region
+			},
+			meta: {
+				kind: "tesla:account",
+				childrenCount: 2,
+				description: "Tesla account"
+			}
+		});
+	}
+	async metaRoot() {
+		return this.buildEntry("/.meta", {
+			id: "meta",
+			content: {
+				kind: "tesla:account",
+				region: this.options.region,
+				provider: "tesla"
+			},
+			meta: {
+				kind: "tesla:account",
+				childrenCount: 2,
+				description: "Tesla account"
+			}
+		});
+	}
+	async readCapabilities() {
+		const manifest = {
+			schemaVersion: 1,
+			provider: "tesla",
+			description: "Tesla Fleet API provider",
+			tools: [],
+			actions: [{
+				kind: "tesla:vehicle",
+				description: "Vehicle commands",
+				catalog: VEHICLE_ACTIONS.map((a) => ({
+					name: a.name,
+					description: a.description
+				})),
+				discovery: { pathTemplate: "/vehicles/:vin/.actions" }
+			}, {
+				kind: "tesla:energy-site",
+				description: "Energy site commands",
+				catalog: ENERGY_ACTIONS.map((a) => ({
+					name: a.name,
+					description: a.description
+				})),
+				discovery: { pathTemplate: "/energy/:siteId/.actions" }
+			}],
+			operations: this.getOperationsDeclaration()
+		};
+		return this.buildEntry("/.meta/.capabilities", {
+			id: "capabilities",
+			content: manifest,
+			meta: { kind: "afs:capabilities" }
+		});
+	}
+	async statRoot() {
+		return { data: this.buildEntry("/", {
+			id: "tesla",
+			meta: {
+				kind: "tesla:account",
+				childrenCount: 2,
+				description: "Tesla account"
+			}
+		}) };
+	}
+	async explainRoot() {
+		const vehicles = await this.client.getVehicles();
+		const energySites = await this.client.getEnergySites();
+		return {
+			content: [
+				`# Tesla Account`,
+				``,
+				`- **Region**: ${this.options.region}`,
+				`- **Vehicles**: ${vehicles.length}`,
+				`- **Energy sites**: ${energySites.length}`,
+				``,
+				`## Vehicles`,
+				...vehicles.map((v) => `- ${v.display_name} (${v.vin}) — ${v.state}`),
+				``,
+				`## Energy Sites`,
+				...energySites.map((s) => `- ${s.site_name} (${s.energy_site_id}) — ${s.resource_type}`)
+			].join("\n"),
+			format: "markdown"
+		};
+	}
+	async searchRoot(_ctx, query, options) {
+		const results = [];
+		const lowerQuery = query.toLowerCase();
+		const limit = options?.limit ?? 1e3;
+		if (!query) return { data: [] };
+		const vehicles = await this.client.getVehicles();
+		for (const v of vehicles) {
+			if (results.length >= limit) break;
+			if (v.display_name.toLowerCase().includes(lowerQuery) || v.vin.toLowerCase().includes(lowerQuery)) results.push(this.buildEntry((0, ufo.joinURL)("/vehicles", v.vin), {
+				id: v.vin,
+				meta: {
+					kind: "tesla:vehicle",
+					childrenCount: 8,
+					description: v.display_name,
+					state: v.state
+				}
+			}));
+		}
+		if (results.length < limit) {
+			const sites = await this.client.getEnergySites();
+			for (const s of sites) {
+				if (results.length >= limit) break;
+				if (s.site_name.toLowerCase().includes(lowerQuery)) results.push(this.buildEntry((0, ufo.joinURL)("/energy", String(s.energy_site_id)), {
+					id: String(s.energy_site_id),
+					meta: {
+						kind: "tesla:energy-site",
+						childrenCount: 2,
+						description: s.site_name
+					}
+				}));
+			}
+		}
+		return { data: results };
+	}
+	async listRootActions() {
+		const entry = this.buildEntry("/.actions/refresh", {
+			id: "refresh",
+			meta: {
+				kind: "afs:executable",
+				childrenCount: 0,
+				description: "Force refresh all cached data",
+				name: "refresh"
+			}
+		});
+		entry.summary = "refresh";
+		return { data: [entry] };
+	}
+	async execRefresh() {
+		this.client.clearAllCaches();
+		return {
+			success: true,
+			data: { message: "All caches cleared" }
+		};
+	}
+	async listVehicles() {
+		return { data: (await this.client.getVehicles()).map((v) => this.buildEntry((0, ufo.joinURL)("/vehicles", v.vin), {
+			id: v.vin,
+			meta: {
+				kind: "tesla:vehicle",
+				childrenCount: 8,
+				description: v.display_name,
+				state: v.state
+			}
+		})) };
+	}
+	async readVehiclesGroup() {
+		const vehicles = await this.client.getVehicles();
+		return this.buildEntry("/vehicles", {
+			id: "vehicles",
+			content: { vehicles: vehicles.map((v) => ({
+				vin: v.vin,
+				name: v.display_name,
+				state: v.state
+			})) },
+			meta: {
+				kind: "tesla:vehicle-group",
+				childrenCount: vehicles.length,
+				description: "Vehicles"
+			}
+		});
+	}
+	async metaVehicles() {
+		const vehicles = await this.client.getVehicles();
+		return this.buildEntry("/vehicles/.meta", {
+			id: "meta",
+			content: {
+				kind: "tesla:vehicle-group",
+				vehicleCount: vehicles.length
+			},
+			meta: {
+				kind: "tesla:vehicle-group",
+				childrenCount: vehicles.length,
+				description: "Vehicles"
+			}
+		});
+	}
+	async statVehicles() {
+		const vehicles = await this.client.getVehicles();
+		return { data: this.buildEntry("/vehicles", {
+			id: "vehicles",
+			meta: {
+				kind: "tesla:vehicle-group",
+				childrenCount: vehicles.length,
+				description: "Vehicles"
+			}
+		}) };
+	}
+	async searchVehicles(_ctx, query, options) {
+		if (!query) return { data: [] };
+		const vehicles = await this.client.getVehicles();
+		const lowerQuery = query.toLowerCase();
+		const results = [];
+		const limit = options?.limit ?? 1e3;
+		for (const v of vehicles) {
+			if (results.length >= limit) break;
+			if (v.display_name.toLowerCase().includes(lowerQuery) || v.vin.toLowerCase().includes(lowerQuery)) results.push(this.buildEntry((0, ufo.joinURL)("/vehicles", v.vin), {
+				id: v.vin,
+				meta: {
+					kind: "tesla:vehicle",
+					childrenCount: 8,
+					description: v.display_name,
+					state: v.state
+				}
+			}));
+		}
+		return { data: results };
+	}
+	async explainVehicles() {
+		const vehicles = await this.client.getVehicles();
+		return {
+			content: [
+				`# Vehicles`,
+				``,
+				`Total: ${vehicles.length}`,
+				``,
+				...vehicles.map((v) => `- **${v.display_name}** (${v.vin}) — ${v.state}`)
+			].join("\n"),
+			format: "markdown"
+		};
+	}
+	async listVehicleSubPaths(ctx) {
+		const vin = ctx.params.vin;
+		await this.client.resolveVIN(vin);
+		return { data: VEHICLE_SUB_PATHS.map((name) => {
+			const kind = name === "nearby-chargers" ? "tesla:charger-list" : name === "release-notes" ? "tesla:release-notes" : "tesla:vehicle-state";
+			return this.buildEntry((0, ufo.joinURL)("/vehicles", vin, name), {
+				id: name,
+				meta: {
+					kind,
+					childrenCount: 0
+				}
+			});
+		}) };
+	}
+	async readVehicle(ctx) {
+		const vin = ctx.params.vin;
+		const vehicleData = await this.client.getVehicleData(vin);
+		return this.buildEntry((0, ufo.joinURL)("/vehicles", vin), {
+			id: vin,
+			content: {
+				name: vehicleData.display_name,
+				model: vehicleData.vehicle_config?.car_type,
+				color: vehicleData.vehicle_config?.exterior_color,
+				firmware: vehicleData.vehicle_state?.car_version,
+				state: vehicleData.state
+			},
+			meta: {
+				kind: "tesla:vehicle",
+				childrenCount: 8,
+				description: vehicleData.display_name,
+				state: vehicleData.state
+			}
+		});
+	}
+	async metaVehicle(ctx) {
+		const vin = ctx.params.vin;
+		const vehicle = (await this.client.getVehicles()).find((v) => v.vin === vin);
+		if (!vehicle) throw new _aigne_afs.AFSNotFoundError((0, ufo.joinURL)("/vehicles", vin));
+		let vehicleData;
+		try {
+			vehicleData = await this.client.getVehicleData(vin);
+		} catch {}
+		return this.buildEntry((0, ufo.joinURL)("/vehicles", vin, ".meta"), {
+			id: "meta",
+			content: {
+				vin: vehicle.vin,
+				name: vehicle.display_name,
+				model: vehicleData?.vehicle_config?.car_type ?? "unknown",
+				optionCodes: vehicle.option_codes,
+				state: vehicle.state
+			},
+			meta: {
+				kind: "tesla:vehicle",
+				childrenCount: 8,
+				description: vehicle.display_name,
+				state: vehicle.state
+			}
+		});
+	}
+	async statVehicle(ctx) {
+		const vin = ctx.params.vin;
+		const vehicle = (await this.client.getVehicles()).find((v) => v.vin === vin);
+		if (!vehicle) throw new _aigne_afs.AFSNotFoundError((0, ufo.joinURL)("/vehicles", vin));
+		const lastUpdated = this.client.getVehicleDataTimestamp(vin);
+		return { data: this.buildEntry((0, ufo.joinURL)("/vehicles", vin), {
+			id: vin,
+			meta: {
+				kind: "tesla:vehicle",
+				childrenCount: 8,
+				description: vehicle.display_name,
+				state: vehicle.state,
+				lastUpdated: lastUpdated ? new Date(lastUpdated).toISOString() : void 0
+			}
+		}) };
+	}
+	async explainVehicle(ctx) {
+		const vin = ctx.params.vin;
+		const vehicleData = await this.client.getVehicleData(vin);
+		const chargeState = vehicleData.charge_state;
+		const vehicleState = vehicleData.vehicle_state;
+		return {
+			content: [
+				`# ${vehicleData.display_name}`,
+				``,
+				`- **VIN**: ${vin}`,
+				`- **Model**: ${vehicleData.vehicle_config?.car_type}`,
+				`- **State**: ${vehicleData.state}`,
+				`- **Firmware**: ${vehicleState?.car_version}`,
+				`- **Battery**: ${chargeState?.battery_level}%`,
+				`- **Range**: ${chargeState?.battery_range} mi`,
+				`- **Locked**: ${vehicleState?.locked}`,
+				`- **Sentry**: ${vehicleState?.sentry_mode}`,
+				`- **Odometer**: ${vehicleState?.odometer} mi`
+			].join("\n"),
+			format: "markdown"
+		};
+	}
+	async readVehicleState(ctx) {
+		const vin = ctx.params.vin;
+		const data = await this.client.getVehicleData(vin);
+		return this.buildEntry((0, ufo.joinURL)("/vehicles", vin, "state"), {
+			id: "state",
+			content: data,
+			meta: {
+				kind: "tesla:vehicle-state",
+				childrenCount: 0
+			}
+		});
+	}
+	async readVehicleCharge(ctx) {
+		const vin = ctx.params.vin;
+		const data = await this.client.getVehicleData(vin);
+		return this.buildEntry((0, ufo.joinURL)("/vehicles", vin, "charge"), {
+			id: "charge",
+			content: data.charge_state,
+			meta: {
+				kind: "tesla:vehicle-state",
+				childrenCount: 0
+			}
+		});
+	}
+	async readVehicleClimate(ctx) {
+		const vin = ctx.params.vin;
+		const data = await this.client.getVehicleData(vin);
+		return this.buildEntry((0, ufo.joinURL)("/vehicles", vin, "climate"), {
+			id: "climate",
+			content: data.climate_state,
+			meta: {
+				kind: "tesla:vehicle-state",
+				childrenCount: 0
+			}
+		});
+	}
+	async readVehicleLocation(ctx) {
+		const vin = ctx.params.vin;
+		const data = await this.client.getVehicleData(vin);
+		return this.buildEntry((0, ufo.joinURL)("/vehicles", vin, "location"), {
+			id: "location",
+			content: data.drive_state,
+			meta: {
+				kind: "tesla:vehicle-state",
+				childrenCount: 0
+			}
+		});
+	}
+	async readVehicleDrive(ctx) {
+		const vin = ctx.params.vin;
+		const data = await this.client.getVehicleData(vin);
+		return this.buildEntry((0, ufo.joinURL)("/vehicles", vin, "drive"), {
+			id: "drive",
+			content: data.drive_state,
+			meta: {
+				kind: "tesla:vehicle-state",
+				childrenCount: 0
+			}
+		});
+	}
+	async readVehicleVehicle(ctx) {
+		const vin = ctx.params.vin;
+		const data = await this.client.getVehicleData(vin);
+		return this.buildEntry((0, ufo.joinURL)("/vehicles", vin, "vehicle"), {
+			id: "vehicle",
+			content: {
+				...data.vehicle_state,
+				firmware: data.vehicle_state?.car_version
+			},
+			meta: {
+				kind: "tesla:vehicle-state",
+				childrenCount: 0
+			}
+		});
+	}
+	async readVehicleNearbyChargers(ctx) {
+		const vin = ctx.params.vin;
+		const data = await this.client.getNearbyChargers(vin);
+		return this.buildEntry((0, ufo.joinURL)("/vehicles", vin, "nearby-chargers"), {
+			id: "nearby-chargers",
+			content: data,
+			meta: {
+				kind: "tesla:charger-list",
+				childrenCount: 0
+			}
+		});
+	}
+	async readVehicleReleaseNotes(ctx) {
+		const vin = ctx.params.vin;
+		const data = await this.client.getReleaseNotes(vin);
+		return this.buildEntry((0, ufo.joinURL)("/vehicles", vin, "release-notes"), {
+			id: "release-notes",
+			content: data,
+			meta: {
+				kind: "tesla:release-notes",
+				childrenCount: 0
+			}
+		});
+	}
+	async statVehicleState(ctx) {
+		const vin = ctx.params.vin;
+		await this.client.resolveVIN(vin);
+		return { data: this.buildEntry((0, ufo.joinURL)("/vehicles", vin, "state"), {
+			id: "state",
+			meta: {
+				kind: "tesla:vehicle-state",
+				childrenCount: 0
+			}
+		}) };
+	}
+	async statVehicleCharge(ctx) {
+		const vin = ctx.params.vin;
+		await this.client.resolveVIN(vin);
+		return { data: this.buildEntry((0, ufo.joinURL)("/vehicles", vin, "charge"), {
+			id: "charge",
+			meta: {
+				kind: "tesla:vehicle-state",
+				childrenCount: 0
+			}
+		}) };
+	}
+	async statVehicleClimate(ctx) {
+		const vin = ctx.params.vin;
+		await this.client.resolveVIN(vin);
+		return { data: this.buildEntry((0, ufo.joinURL)("/vehicles", vin, "climate"), {
+			id: "climate",
+			meta: {
+				kind: "tesla:vehicle-state",
+				childrenCount: 0
+			}
+		}) };
+	}
+	async statVehicleLocation(ctx) {
+		const vin = ctx.params.vin;
+		await this.client.resolveVIN(vin);
+		return { data: this.buildEntry((0, ufo.joinURL)("/vehicles", vin, "location"), {
+			id: "location",
+			meta: {
+				kind: "tesla:vehicle-state",
+				childrenCount: 0
+			}
+		}) };
+	}
+	async statVehicleDrive(ctx) {
+		const vin = ctx.params.vin;
+		await this.client.resolveVIN(vin);
+		return { data: this.buildEntry((0, ufo.joinURL)("/vehicles", vin, "drive"), {
+			id: "drive",
+			meta: {
+				kind: "tesla:vehicle-state",
+				childrenCount: 0
+			}
+		}) };
+	}
+	async statVehicleVehicle(ctx) {
+		const vin = ctx.params.vin;
+		await this.client.resolveVIN(vin);
+		return { data: this.buildEntry((0, ufo.joinURL)("/vehicles", vin, "vehicle"), {
+			id: "vehicle",
+			meta: {
+				kind: "tesla:vehicle-state",
+				childrenCount: 0
+			}
+		}) };
+	}
+	async statVehicleNearbyChargers(ctx) {
+		const vin = ctx.params.vin;
+		await this.client.resolveVIN(vin);
+		return { data: this.buildEntry((0, ufo.joinURL)("/vehicles", vin, "nearby-chargers"), {
+			id: "nearby-chargers",
+			meta: {
+				kind: "tesla:charger-list",
+				childrenCount: 0
+			}
+		}) };
+	}
+	async statVehicleReleaseNotes(ctx) {
+		const vin = ctx.params.vin;
+		await this.client.resolveVIN(vin);
+		return { data: this.buildEntry((0, ufo.joinURL)("/vehicles", vin, "release-notes"), {
+			id: "release-notes",
+			meta: {
+				kind: "tesla:release-notes",
+				childrenCount: 0
+			}
+		}) };
+	}
+	async metaVehicleState(ctx) {
+		const vin = ctx.params.vin;
+		await this.client.resolveVIN(vin);
+		return this.buildEntry((0, ufo.joinURL)("/vehicles", vin, "state", ".meta"), {
+			id: "meta",
+			content: {
+				kind: "tesla:vehicle-state",
+				description: "Full vehicle data snapshot"
+			},
+			meta: {
+				kind: "tesla:vehicle-state",
+				childrenCount: 0
+			}
+		});
+	}
+	async metaVehicleCharge(ctx) {
+		const vin = ctx.params.vin;
+		await this.client.resolveVIN(vin);
+		return this.buildEntry((0, ufo.joinURL)("/vehicles", vin, "charge", ".meta"), {
+			id: "meta",
+			content: {
+				kind: "tesla:vehicle-state",
+				description: "Charge state"
+			},
+			meta: {
+				kind: "tesla:vehicle-state",
+				childrenCount: 0
+			}
+		});
+	}
+	async metaVehicleClimate(ctx) {
+		const vin = ctx.params.vin;
+		await this.client.resolveVIN(vin);
+		return this.buildEntry((0, ufo.joinURL)("/vehicles", vin, "climate", ".meta"), {
+			id: "meta",
+			content: {
+				kind: "tesla:vehicle-state",
+				description: "Climate state"
+			},
+			meta: {
+				kind: "tesla:vehicle-state",
+				childrenCount: 0
+			}
+		});
+	}
+	async metaVehicleLocation(ctx) {
+		const vin = ctx.params.vin;
+		await this.client.resolveVIN(vin);
+		return this.buildEntry((0, ufo.joinURL)("/vehicles", vin, "location", ".meta"), {
+			id: "meta",
+			content: {
+				kind: "tesla:vehicle-state",
+				description: "Location data"
+			},
+			meta: {
+				kind: "tesla:vehicle-state",
+				childrenCount: 0
+			}
+		});
+	}
+	async metaVehicleDrive(ctx) {
+		const vin = ctx.params.vin;
+		await this.client.resolveVIN(vin);
+		return this.buildEntry((0, ufo.joinURL)("/vehicles", vin, "drive", ".meta"), {
+			id: "meta",
+			content: {
+				kind: "tesla:vehicle-state",
+				description: "Drive state"
+			},
+			meta: {
+				kind: "tesla:vehicle-state",
+				childrenCount: 0
+			}
+		});
+	}
+	async metaVehicleVehicle(ctx) {
+		const vin = ctx.params.vin;
+		await this.client.resolveVIN(vin);
+		return this.buildEntry((0, ufo.joinURL)("/vehicles", vin, "vehicle", ".meta"), {
+			id: "meta",
+			content: {
+				kind: "tesla:vehicle-state",
+				description: "Vehicle state"
+			},
+			meta: {
+				kind: "tesla:vehicle-state",
+				childrenCount: 0
+			}
+		});
+	}
+	async metaVehicleNearbyChargers(ctx) {
+		const vin = ctx.params.vin;
+		await this.client.resolveVIN(vin);
+		return this.buildEntry((0, ufo.joinURL)("/vehicles", vin, "nearby-chargers", ".meta"), {
+			id: "meta",
+			content: {
+				kind: "tesla:charger-list",
+				description: "Nearby chargers"
+			},
+			meta: {
+				kind: "tesla:charger-list",
+				childrenCount: 0
+			}
+		});
+	}
+	async metaVehicleReleaseNotes(ctx) {
+		const vin = ctx.params.vin;
+		await this.client.resolveVIN(vin);
+		return this.buildEntry((0, ufo.joinURL)("/vehicles", vin, "release-notes", ".meta"), {
+			id: "meta",
+			content: {
+				kind: "tesla:release-notes",
+				description: "Release notes"
+			},
+			meta: {
+				kind: "tesla:release-notes",
+				childrenCount: 0
+			}
+		});
+	}
+	async listVehicleState() {
+		return { data: [] };
+	}
+	async listVehicleCharge() {
+		return { data: [] };
+	}
+	async listVehicleClimate() {
+		return { data: [] };
+	}
+	async listVehicleLocation() {
+		return { data: [] };
+	}
+	async listVehicleDrive() {
+		return { data: [] };
+	}
+	async listVehicleVehicle() {
+		return { data: [] };
+	}
+	async listVehicleNearbyChargers() {
+		return { data: [] };
+	}
+	async listVehicleReleaseNotes() {
+		return { data: [] };
+	}
+	async listVehicleActions(ctx) {
+		const vin = ctx.params.vin;
+		await this.client.resolveVIN(vin);
+		return { data: VEHICLE_ACTIONS.map((action) => {
+			const entry = this.buildEntry((0, ufo.joinURL)("/vehicles", vin, ".actions", action.name), {
+				id: action.name,
+				meta: {
+					kind: "afs:executable",
+					childrenCount: 0,
+					description: action.description,
+					name: action.name,
+					severity: action.severity
+				}
+			});
+			entry.summary = action.name;
+			return entry;
+		}) };
+	}
+	async execVehicleAction(ctx, args) {
+		const vin = ctx.params.vin;
+		const action = ctx.params.action;
+		if (!VEHICLE_ACTIONS.find((a) => a.name === action)) throw new _aigne_afs.AFSNotFoundError((0, ufo.joinURL)("/vehicles", vin, ".actions", action), `Unknown vehicle action: ${action}`);
+		if (action === "wake") {
+			this.assertNoArgs(action, args);
+			await this.client.wakeVehicle(vin);
+			return {
+				success: true,
+				data: { message: "Vehicle waking up" }
+			};
+		}
+		const apiCommand = VEHICLE_COMMAND_MAP[action];
+		if (!apiCommand) throw new _aigne_afs.AFSNotFoundError((0, ufo.joinURL)("/vehicles", vin, ".actions", action), `Unknown vehicle command: ${action}`);
+		await this.buildAndSendVehicleCommand(vin, action, apiCommand, args);
+		return {
+			success: true,
+			data: {
+				command: action,
+				vin
+			}
+		};
+	}
+	/**
+	* Validate arguments and build the body for a vehicle command.
+	* Throws AFSError for invalid arguments.
+	*/
+	async buildVehicleCommandBody(vin, action, args) {
+		switch (action) {
+			case "frunk":
+				this.assertNoArgs(action, args);
+				return { which_trunk: "front" };
+			case "trunk":
+				this.assertNoArgs(action, args);
+				return { which_trunk: "rear" };
+			case "set-temp": {
+				const driver = args.driver;
+				const passenger = args.passenger;
+				if (typeof driver !== "number") throw new _aigne_afs.AFSError("set-temp requires 'driver' as a number", "AFS_INVALID_ARGUMENT");
+				return {
+					driver_temp: driver,
+					passenger_temp: typeof passenger === "number" ? passenger : driver
+				};
+			}
+			case "set-charge-limit": {
+				const percent = args.percent;
+				if (typeof percent !== "number") throw new _aigne_afs.AFSError("set-charge-limit requires 'percent' as a number", "AFS_INVALID_ARGUMENT");
+				if (percent < 0 || percent > 100) throw new _aigne_afs.AFSError("set-charge-limit 'percent' must be between 0 and 100", "AFS_INVALID_ARGUMENT");
+				return { percent };
+			}
+			case "sentry-on":
+				this.assertNoArgs(action, args);
+				return { on: true };
+			case "sentry-off":
+				this.assertNoArgs(action, args);
+				return { on: false };
+			case "set-charging-amps": {
+				const amps = args.amps;
+				if (typeof amps !== "number") throw new _aigne_afs.AFSError("set-charging-amps requires 'amps' as a number", "AFS_INVALID_ARGUMENT");
+				if (amps < 0 || amps > 48) throw new _aigne_afs.AFSError("set-charging-amps 'amps' must be between 0 and 48", "AFS_INVALID_ARGUMENT");
+				return { charging_amps: amps };
+			}
+			case "seat-heater": {
+				const seat = args.seat;
+				const level = args.level;
+				if (typeof seat !== "number" || typeof level !== "number") throw new _aigne_afs.AFSError("seat-heater requires 'seat' and 'level' as numbers", "AFS_INVALID_ARGUMENT");
+				if (seat < 0 || seat > 5) throw new _aigne_afs.AFSError("seat-heater 'seat' must be between 0 and 5", "AFS_INVALID_ARGUMENT");
+				if (level < 0 || level > 3) throw new _aigne_afs.AFSError("seat-heater 'level' must be between 0 and 3", "AFS_INVALID_ARGUMENT");
+				return {
+					heater: seat,
+					level
+				};
+			}
+			case "charge-port-open":
+			case "charge-port-close":
+				this.assertNoArgs(action, args);
+				return;
+			case "navigate": {
+				const address = args.address;
+				if (typeof address !== "string" || address.length === 0) throw new _aigne_afs.AFSError("navigate requires a non-empty 'address' string", "AFS_INVALID_ARGUMENT");
+				return {
+					type: "share_ext_content_raw",
+					value: { "android.intent.extra.TEXT": address },
+					locale: "en-US",
+					timestamp_ms: String(Date.now())
+				};
+			}
+			case "share": {
+				const value = args.value;
+				const type = args.type;
+				if (typeof value !== "string") throw new _aigne_afs.AFSError("share requires 'value' as a string", "AFS_INVALID_ARGUMENT");
+				if (typeof type !== "string" || !["url", "text"].includes(type)) throw new _aigne_afs.AFSError("share requires 'type' as 'url' or 'text'", "AFS_INVALID_ARGUMENT");
+				return {
+					type: "share_ext_content_raw",
+					value: { "android.intent.extra.TEXT": value },
+					locale: "en-US",
+					timestamp_ms: String(Date.now())
+				};
+			}
+			case "window-vent":
+			case "window-close": {
+				this.assertNoArgs(action, args);
+				const { lat, lon } = await this.getVehicleCoordinates(vin);
+				return {
+					command: action === "window-vent" ? "vent" : "close",
+					lat,
+					lon
+				};
+			}
+			case "homelink": {
+				this.assertNoArgs(action, args);
+				const { lat, lon } = await this.getVehicleCoordinates(vin);
+				return {
+					lat,
+					lon
+				};
+			}
+			case "remote-start":
+				this.assertNoArgs(action, args);
+				return;
+			case "schedule-update": {
+				const offsetSec = args.offset_sec;
+				if (typeof offsetSec !== "number") throw new _aigne_afs.AFSError("schedule-update requires 'offset_sec' as a number", "AFS_INVALID_ARGUMENT");
+				if (offsetSec < 0) throw new _aigne_afs.AFSError("schedule-update 'offset_sec' must be >= 0", "AFS_INVALID_ARGUMENT");
+				return { offset_sec: offsetSec };
+			}
+			case "cancel-update":
+				this.assertNoArgs(action, args);
+				return;
+			case "lock":
+			case "unlock":
+			case "horn":
+			case "flash":
+			case "climate-on":
+			case "climate-off":
+			case "charge-start":
+			case "charge-stop":
+			case "wake":
+				this.assertNoArgs(action, args);
+				return;
+			default: throw new _aigne_afs.AFSError(`Unknown vehicle command: ${action}`, "AFS_INVALID_ARGUMENT");
+		}
+	}
+	assertNoArgs(action, args) {
+		if (Object.keys(args).length > 0) throw new _aigne_afs.AFSError(`${action} does not accept arguments`, "AFS_INVALID_ARGUMENT");
+	}
+	async getVehicleCoordinates(vin) {
+		const driveState = (await this.client.getVehicleData(vin)).drive_state;
+		const lat = driveState?.latitude;
+		const lon = driveState?.longitude;
+		if (typeof lat !== "number" || typeof lon !== "number") throw new _aigne_afs.AFSError("Vehicle location unavailable for this command", "AFS_INVALID_ARGUMENT");
+		return {
+			lat,
+			lon
+		};
+	}
+	isVehicleAsleepError(error) {
+		if (!(error instanceof _aigne_afs.AFSError) || error.code !== "AFS_TIMEOUT") return false;
+		const message = error.message.toLowerCase();
+		return message.includes("asleep") || message.includes("vehicle unavailable") || message.includes("offline");
+	}
+	async buildAndSendVehicleCommand(vin, action, apiCommand, args) {
+		try {
+			const body$1 = await this.buildVehicleCommandBody(vin, action, args);
+			await this.client.sendVehicleCommand(vin, apiCommand, body$1);
+			return;
+		} catch (error) {
+			if (!this.options.autoWake || !this.isVehicleAsleepError(error)) throw error;
+		}
+		await this.client.wakeVehicle(vin);
+		const body = await this.buildVehicleCommandBody(vin, action, args);
+		await this.client.sendVehicleCommand(vin, apiCommand, body);
+	}
+	async listEnergySites() {
+		return { data: (await this.client.getEnergySites()).map((s) => this.buildEntry((0, ufo.joinURL)("/energy", String(s.energy_site_id)), {
+			id: String(s.energy_site_id),
+			meta: {
+				kind: "tesla:energy-site",
+				childrenCount: 2,
+				description: s.site_name
+			}
+		})) };
+	}
+	async readEnergyGroup() {
+		const sites = await this.client.getEnergySites();
+		return this.buildEntry("/energy", {
+			id: "energy",
+			content: { sites: sites.map((s) => ({
+				id: s.energy_site_id,
+				name: s.site_name,
+				type: s.resource_type
+			})) },
+			meta: {
+				kind: "tesla:energy-group",
+				childrenCount: sites.length,
+				description: "Energy sites"
+			}
+		});
+	}
+	async metaEnergy() {
+		const sites = await this.client.getEnergySites();
+		return this.buildEntry("/energy/.meta", {
+			id: "meta",
+			content: {
+				kind: "tesla:energy-group",
+				siteCount: sites.length
+			},
+			meta: {
+				kind: "tesla:energy-group",
+				childrenCount: sites.length,
+				description: "Energy sites"
+			}
+		});
+	}
+	async statEnergy() {
+		const sites = await this.client.getEnergySites();
+		return { data: this.buildEntry("/energy", {
+			id: "energy",
+			meta: {
+				kind: "tesla:energy-group",
+				childrenCount: sites.length,
+				description: "Energy sites"
+			}
+		}) };
+	}
+	async searchEnergy(_ctx, query, options) {
+		if (!query) return { data: [] };
+		const sites = await this.client.getEnergySites();
+		const lowerQuery = query.toLowerCase();
+		const results = [];
+		const limit = options?.limit ?? 1e3;
+		for (const s of sites) {
+			if (results.length >= limit) break;
+			if (s.site_name.toLowerCase().includes(lowerQuery)) results.push(this.buildEntry((0, ufo.joinURL)("/energy", String(s.energy_site_id)), {
+				id: String(s.energy_site_id),
+				meta: {
+					kind: "tesla:energy-site",
+					childrenCount: 2,
+					description: s.site_name
+				}
+			}));
+		}
+		return { data: results };
+	}
+	async explainEnergy() {
+		const sites = await this.client.getEnergySites();
+		return {
+			content: [
+				`# Energy Sites`,
+				``,
+				`Total: ${sites.length}`,
+				``,
+				...sites.map((s) => `- **${s.site_name}** (${s.energy_site_id}) — ${s.resource_type}`)
+			].join("\n"),
+			format: "markdown"
+		};
+	}
+	async listEnergySiteSubPaths(ctx) {
+		const siteId = ctx.params.siteId;
+		await this.client.resolveEnergySiteId(siteId);
+		return { data: [this.buildEntry((0, ufo.joinURL)("/energy", siteId, "live"), {
+			id: "live",
+			meta: {
+				kind: "tesla:energy-state",
+				childrenCount: 0
+			}
+		}), this.buildEntry((0, ufo.joinURL)("/energy", siteId, "history"), {
+			id: "history",
+			meta: {
+				kind: "tesla:energy-state",
+				childrenCount: 0
+			}
+		})] };
+	}
+	async readEnergySite(ctx) {
+		const siteId = ctx.params.siteId;
+		const siteInfo = await this.client.getEnergySiteInfo(siteId);
+		const site = (await this.client.getEnergySites()).find((s) => s.energy_site_id === Number.parseInt(siteId, 10));
+		return this.buildEntry((0, ufo.joinURL)("/energy", siteId), {
+			id: siteId,
+			content: siteInfo,
+			meta: {
+				kind: "tesla:energy-site",
+				childrenCount: 2,
+				description: site?.site_name ?? `Energy site ${siteId}`
+			}
+		});
+	}
+	async metaEnergySite(ctx) {
+		const siteId = ctx.params.siteId;
+		const site = (await this.client.getEnergySites()).find((s) => s.energy_site_id === Number.parseInt(siteId, 10));
+		if (!site) throw new _aigne_afs.AFSNotFoundError((0, ufo.joinURL)("/energy", siteId));
+		return this.buildEntry((0, ufo.joinURL)("/energy", siteId, ".meta"), {
+			id: "meta",
+			content: {
+				siteId: site.energy_site_id,
+				name: site.site_name,
+				resourceType: site.resource_type,
+				backupCapable: site.backup_capable
+			},
+			meta: {
+				kind: "tesla:energy-site",
+				childrenCount: 2,
+				description: site.site_name
+			}
+		});
+	}
+	async statEnergySite(ctx) {
+		const siteId = ctx.params.siteId;
+		const site = (await this.client.getEnergySites()).find((s) => s.energy_site_id === Number.parseInt(siteId, 10));
+		if (!site) throw new _aigne_afs.AFSNotFoundError((0, ufo.joinURL)("/energy", siteId));
+		return { data: this.buildEntry((0, ufo.joinURL)("/energy", siteId), {
+			id: siteId,
+			meta: {
+				kind: "tesla:energy-site",
+				childrenCount: 2,
+				description: site.site_name,
+				resourceType: site.resource_type
+			}
+		}) };
+	}
+	async explainEnergySite(ctx) {
+		const siteId = ctx.params.siteId;
+		const siteInfo = await this.client.getEnergySiteInfo(siteId);
+		const site = (await this.client.getEnergySites()).find((s) => s.energy_site_id === Number.parseInt(siteId, 10));
+		return {
+			content: [
+				`# ${site?.site_name ?? `Energy Site ${siteId}`}`,
+				``,
+				`- **Site ID**: ${siteId}`,
+				`- **Type**: ${site?.resource_type}`,
+				`- **Backup capable**: ${siteInfo?.backup_capable}`,
+				`- **Storm mode**: ${siteInfo?.storm_mode_enabled}`,
+				`- **Battery**: ${siteInfo?.percentage_charged}%`
+			].join("\n"),
+			format: "markdown"
+		};
+	}
+	async readEnergySiteLive(ctx) {
+		const siteId = ctx.params.siteId;
+		const data = await this.client.getEnergySiteLiveStatus(siteId);
+		return this.buildEntry((0, ufo.joinURL)("/energy", siteId, "live"), {
+			id: "live",
+			content: data,
+			meta: {
+				kind: "tesla:energy-state",
+				childrenCount: 0
+			}
+		});
+	}
+	async readEnergySiteHistory(ctx) {
+		const siteId = ctx.params.siteId;
+		const data = await this.client.getEnergySiteHistory(siteId);
+		return this.buildEntry((0, ufo.joinURL)("/energy", siteId, "history"), {
+			id: "history",
+			content: data,
+			meta: {
+				kind: "tesla:energy-state",
+				childrenCount: 0
+			}
+		});
+	}
+	async listEnergySiteLive() {
+		return { data: [] };
+	}
+	async listEnergySiteHistory() {
+		return { data: [] };
+	}
+	async metaEnergySiteLive(ctx) {
+		const siteId = ctx.params.siteId;
+		await this.client.resolveEnergySiteId(siteId);
+		return this.buildEntry((0, ufo.joinURL)("/energy", siteId, "live", ".meta"), {
+			id: "meta",
+			content: {
+				kind: "tesla:energy-state",
+				description: "Real-time power flow"
+			},
+			meta: {
+				kind: "tesla:energy-state",
+				childrenCount: 0
+			}
+		});
+	}
+	async metaEnergySiteHistory(ctx) {
+		const siteId = ctx.params.siteId;
+		await this.client.resolveEnergySiteId(siteId);
+		return this.buildEntry((0, ufo.joinURL)("/energy", siteId, "history", ".meta"), {
+			id: "meta",
+			content: {
+				kind: "tesla:energy-state",
+				description: "Historical energy data"
+			},
+			meta: {
+				kind: "tesla:energy-state",
+				childrenCount: 0
+			}
+		});
+	}
+	async statEnergySiteLive(ctx) {
+		const siteId = ctx.params.siteId;
+		await this.client.resolveEnergySiteId(siteId);
+		return { data: this.buildEntry((0, ufo.joinURL)("/energy", siteId, "live"), {
+			id: "live",
+			meta: {
+				kind: "tesla:energy-state",
+				childrenCount: 0
+			}
+		}) };
+	}
+	async statEnergySiteHistory(ctx) {
+		const siteId = ctx.params.siteId;
+		await this.client.resolveEnergySiteId(siteId);
+		return { data: this.buildEntry((0, ufo.joinURL)("/energy", siteId, "history"), {
+			id: "history",
+			meta: {
+				kind: "tesla:energy-state",
+				childrenCount: 0
+			}
+		}) };
+	}
+	async listEnergySiteActions(ctx) {
+		const siteId = ctx.params.siteId;
+		await this.client.resolveEnergySiteId(siteId);
+		return { data: ENERGY_ACTIONS.map((action) => {
+			const entry = this.buildEntry((0, ufo.joinURL)("/energy", siteId, ".actions", action.name), {
+				id: action.name,
+				meta: {
+					kind: "afs:executable",
+					childrenCount: 0,
+					description: action.description,
+					name: action.name,
+					severity: action.severity
+				}
+			});
+			entry.summary = action.name;
+			return entry;
+		}) };
+	}
+	async execEnergySiteAction(ctx, args) {
+		const siteId = ctx.params.siteId;
+		const action = ctx.params.action;
+		if (!ENERGY_ACTIONS.find((a) => a.name === action)) throw new _aigne_afs.AFSNotFoundError((0, ufo.joinURL)("/energy", siteId, ".actions", action), `Unknown energy site action: ${action}`);
+		let apiCommand;
+		let body;
+		switch (action) {
+			case "set-backup-reserve": {
+				const percent = args.percent;
+				if (typeof percent !== "number") throw new _aigne_afs.AFSError("set-backup-reserve requires 'percent' as a number", "AFS_INVALID_ARGUMENT");
+				if (percent < 0 || percent > 100) throw new _aigne_afs.AFSError("set-backup-reserve 'percent' must be between 0 and 100", "AFS_INVALID_ARGUMENT");
+				apiCommand = "backup";
+				body = { backup_reserve_percent: percent };
+				break;
+			}
+			case "set-operation-mode": {
+				const mode = args.mode;
+				if (typeof mode !== "string" || ![
+					"autonomous",
+					"self_consumption",
+					"time_based"
+				].includes(mode)) throw new _aigne_afs.AFSError("set-operation-mode requires 'mode' as one of: autonomous, self_consumption, time_based", "AFS_INVALID_ARGUMENT");
+				apiCommand = "operation";
+				body = { default_real_mode: mode };
+				break;
+			}
+			case "storm-mode-on":
+				apiCommand = "storm_mode";
+				body = { enabled: true };
+				break;
+			case "storm-mode-off":
+				apiCommand = "storm_mode";
+				body = { enabled: false };
+				break;
+			default: throw new _aigne_afs.AFSNotFoundError((0, ufo.joinURL)("/energy", siteId, ".actions", action), `Unknown energy site action: ${action}`);
+		}
+		await this.client.sendEnergySiteCommand(siteId, apiCommand, body);
+		return {
+			success: true,
+			data: {
+				command: action,
+				siteId
+			}
+		};
+	}
+};
+require_decorate.__decorate([(0, _aigne_afs_provider.List)("/")], AFSTesla.prototype, "listRoot", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/")], AFSTesla.prototype, "readRoot", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Meta)("/")], AFSTesla.prototype, "metaRoot", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/.meta/.capabilities")], AFSTesla.prototype, "readCapabilities", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Stat)("/")], AFSTesla.prototype, "statRoot", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Explain)("/")], AFSTesla.prototype, "explainRoot", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Search)("/")], AFSTesla.prototype, "searchRoot", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Actions)("/")], AFSTesla.prototype, "listRootActions", null);
+require_decorate.__decorate([_aigne_afs_provider.Actions.Exec("/", "refresh")], AFSTesla.prototype, "execRefresh", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.List)("/vehicles")], AFSTesla.prototype, "listVehicles", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/vehicles")], AFSTesla.prototype, "readVehiclesGroup", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Meta)("/vehicles")], AFSTesla.prototype, "metaVehicles", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Stat)("/vehicles")], AFSTesla.prototype, "statVehicles", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Search)("/vehicles")], AFSTesla.prototype, "searchVehicles", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Explain)("/vehicles")], AFSTesla.prototype, "explainVehicles", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.List)("/vehicles/:vin")], AFSTesla.prototype, "listVehicleSubPaths", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/vehicles/:vin")], AFSTesla.prototype, "readVehicle", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Meta)("/vehicles/:vin")], AFSTesla.prototype, "metaVehicle", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Stat)("/vehicles/:vin")], AFSTesla.prototype, "statVehicle", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Explain)("/vehicles/:vin")], AFSTesla.prototype, "explainVehicle", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/vehicles/:vin/state")], AFSTesla.prototype, "readVehicleState", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/vehicles/:vin/charge")], AFSTesla.prototype, "readVehicleCharge", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/vehicles/:vin/climate")], AFSTesla.prototype, "readVehicleClimate", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/vehicles/:vin/location")], AFSTesla.prototype, "readVehicleLocation", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/vehicles/:vin/drive")], AFSTesla.prototype, "readVehicleDrive", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/vehicles/:vin/vehicle")], AFSTesla.prototype, "readVehicleVehicle", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/vehicles/:vin/nearby-chargers")], AFSTesla.prototype, "readVehicleNearbyChargers", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/vehicles/:vin/release-notes")], AFSTesla.prototype, "readVehicleReleaseNotes", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Stat)("/vehicles/:vin/state")], AFSTesla.prototype, "statVehicleState", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Stat)("/vehicles/:vin/charge")], AFSTesla.prototype, "statVehicleCharge", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Stat)("/vehicles/:vin/climate")], AFSTesla.prototype, "statVehicleClimate", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Stat)("/vehicles/:vin/location")], AFSTesla.prototype, "statVehicleLocation", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Stat)("/vehicles/:vin/drive")], AFSTesla.prototype, "statVehicleDrive", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Stat)("/vehicles/:vin/vehicle")], AFSTesla.prototype, "statVehicleVehicle", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Stat)("/vehicles/:vin/nearby-chargers")], AFSTesla.prototype, "statVehicleNearbyChargers", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Stat)("/vehicles/:vin/release-notes")], AFSTesla.prototype, "statVehicleReleaseNotes", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Meta)("/vehicles/:vin/state")], AFSTesla.prototype, "metaVehicleState", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Meta)("/vehicles/:vin/charge")], AFSTesla.prototype, "metaVehicleCharge", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Meta)("/vehicles/:vin/climate")], AFSTesla.prototype, "metaVehicleClimate", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Meta)("/vehicles/:vin/location")], AFSTesla.prototype, "metaVehicleLocation", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Meta)("/vehicles/:vin/drive")], AFSTesla.prototype, "metaVehicleDrive", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Meta)("/vehicles/:vin/vehicle")], AFSTesla.prototype, "metaVehicleVehicle", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Meta)("/vehicles/:vin/nearby-chargers")], AFSTesla.prototype, "metaVehicleNearbyChargers", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Meta)("/vehicles/:vin/release-notes")], AFSTesla.prototype, "metaVehicleReleaseNotes", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.List)("/vehicles/:vin/state")], AFSTesla.prototype, "listVehicleState", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.List)("/vehicles/:vin/charge")], AFSTesla.prototype, "listVehicleCharge", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.List)("/vehicles/:vin/climate")], AFSTesla.prototype, "listVehicleClimate", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.List)("/vehicles/:vin/location")], AFSTesla.prototype, "listVehicleLocation", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.List)("/vehicles/:vin/drive")], AFSTesla.prototype, "listVehicleDrive", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.List)("/vehicles/:vin/vehicle")], AFSTesla.prototype, "listVehicleVehicle", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.List)("/vehicles/:vin/nearby-chargers")], AFSTesla.prototype, "listVehicleNearbyChargers", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.List)("/vehicles/:vin/release-notes")], AFSTesla.prototype, "listVehicleReleaseNotes", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Actions)("/vehicles/:vin")], AFSTesla.prototype, "listVehicleActions", null);
+require_decorate.__decorate([_aigne_afs_provider.Actions.Exec("/vehicles/:vin")], AFSTesla.prototype, "execVehicleAction", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.List)("/energy")], AFSTesla.prototype, "listEnergySites", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/energy")], AFSTesla.prototype, "readEnergyGroup", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Meta)("/energy")], AFSTesla.prototype, "metaEnergy", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Stat)("/energy")], AFSTesla.prototype, "statEnergy", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Search)("/energy")], AFSTesla.prototype, "searchEnergy", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Explain)("/energy")], AFSTesla.prototype, "explainEnergy", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.List)("/energy/:siteId")], AFSTesla.prototype, "listEnergySiteSubPaths", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/energy/:siteId")], AFSTesla.prototype, "readEnergySite", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Meta)("/energy/:siteId")], AFSTesla.prototype, "metaEnergySite", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Stat)("/energy/:siteId")], AFSTesla.prototype, "statEnergySite", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Explain)("/energy/:siteId")], AFSTesla.prototype, "explainEnergySite", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/energy/:siteId/live")], AFSTesla.prototype, "readEnergySiteLive", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/energy/:siteId/history")], AFSTesla.prototype, "readEnergySiteHistory", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.List)("/energy/:siteId/live")], AFSTesla.prototype, "listEnergySiteLive", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.List)("/energy/:siteId/history")], AFSTesla.prototype, "listEnergySiteHistory", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Meta)("/energy/:siteId/live")], AFSTesla.prototype, "metaEnergySiteLive", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Meta)("/energy/:siteId/history")], AFSTesla.prototype, "metaEnergySiteHistory", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Stat)("/energy/:siteId/live")], AFSTesla.prototype, "statEnergySiteLive", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Stat)("/energy/:siteId/history")], AFSTesla.prototype, "statEnergySiteHistory", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Actions)("/energy/:siteId")], AFSTesla.prototype, "listEnergySiteActions", null);
+require_decorate.__decorate([_aigne_afs_provider.Actions.Exec("/energy/:siteId")], AFSTesla.prototype, "execEnergySiteAction", null);
+
+//#endregion
+exports.AFSTesla = AFSTesla;
+exports.afsTeslaOptionsSchema = afsTeslaOptionsSchema;