bambu-printer-mcp 1.0.8 → 1.1.4

package/dist/index.js

@@ -10,30 +10,348 @@ import { createServer as createHttpServer } from "node:http";
 import { randomUUID } from "node:crypto";
 import { STLManipulator, SLICER_TYPES, normalizeSlicerType, } from "./stl/stl-manipulator.js";
 import { BambuNetworkBridge } from "./bambu-network-bridge.js";
-import { parse3MF } from './3mf_parser.js';
+import { hasAmsMappingInput, normalizeAmsMappingObject, normalizeBridgeAmsTrayValue } from "./ams-mapping.js";
+import { analyze3MFAmsRequirements, analyze3MFPlateObjects, analyzeCollarCharm3MF, extractBambuTemplateSettings, getCollarCharmRolePolicy, parse3MF } from './3mf_parser.js';
 import { BambuImplementation } from "./printers/bambu.js";
 dotenv.config();
-const DEFAULT_HOST = process.env.PRINTER_HOST || "localhost";
-const DEFAULT_BAMBU_SERIAL = process.env.BAMBU_SERIAL || "";
-const DEFAULT_BAMBU_TOKEN = process.env.BAMBU_TOKEN || "";
+const DEFAULT_HOST = process.env.BAMBU_PRINTER_HOST || process.env.PRINTER_HOST || "localhost";
+const DEFAULT_BAMBU_SERIAL = process.env.BAMBU_PRINTER_SERIAL || process.env.BAMBU_SERIAL || "";
+const DEFAULT_BAMBU_TOKEN = process.env.BAMBU_PRINTER_ACCESS_TOKEN || process.env.BAMBU_TOKEN || "";
 const DEFAULT_BAMBU_DEV_ID = process.env.BAMBU_DEV_ID || DEFAULT_BAMBU_SERIAL;
 const TEMP_DIR = process.env.TEMP_DIR || path.join(process.cwd(), "temp");
 // Printer model and bed type
-const DEFAULT_BAMBU_MODEL = process.env.BAMBU_MODEL?.trim().toLowerCase() || "";
+const DEFAULT_BAMBU_MODEL = process.env.BAMBU_PRINTER_MODEL?.trim().toLowerCase() ||
+    process.env.BAMBU_MODEL?.trim().toLowerCase() ||
+    "";
 const DEFAULT_BED_TYPE = process.env.BED_TYPE?.trim().toLowerCase() || "textured_plate";
 const DEFAULT_NOZZLE_DIAMETER = process.env.NOZZLE_DIAMETER?.trim() || "0.4";
-const VALID_BAMBU_MODELS = ["p1s", "p1p", "x1c", "x1e", "a1", "a1mini", "h2d"];
-const VALID_BED_TYPES = ["textured_plate", "cool_plate", "engineering_plate", "hot_plate"];
+const VALID_BAMBU_MODELS = ["p1s", "p1p", "p2s", "x1c", "x1e", "a1", "a1mini", "h2d", "h2s", "h2c"];
+const H2_BAMBU_MODELS = new Set(["h2d", "h2s", "h2c"]);
+const VALID_BED_TYPES = ["textured_plate", "cool_plate", "engineering_plate", "hot_plate", "supertack_plate"];
+const VALID_BAMBUSTUDIO_CLI_BED_TYPES = ["textured_plate", "cool_plate", "engineering_plate", "hot_plate"];
 // Map model IDs to BambuStudio --load-machine preset names
 const BAMBU_MODEL_PRESETS = {
     p1s: (n) => `Bambu Lab P1S ${n} nozzle`,
     p1p: (n) => `Bambu Lab P1P ${n} nozzle`,
+    p2s: (n) => `Bambu Lab P2S ${n} nozzle`,
     x1c: (n) => `Bambu Lab X1 Carbon ${n} nozzle`,
     x1e: (n) => `Bambu Lab X1E ${n} nozzle`,
     a1: (n) => `Bambu Lab A1 ${n} nozzle`,
     a1mini: (n) => `Bambu Lab A1 mini ${n} nozzle`,
     h2d: (n) => `Bambu Lab H2D ${n} nozzle`,
+    h2s: (n) => `Bambu Lab H2S ${n} nozzle`,
+    h2c: (n) => `Bambu Lab H2C ${n} nozzle`,
 };
+const FILAMENT_PROFILE_DIR = "/Applications/BambuStudio.app/Contents/Resources/profiles/BBL/filament";
+const FILAMENT_MODEL_CODES = {
+    p1s: "P1S",
+    p1p: "P1P",
+    p2s: "P2S",
+    x1c: "X1C",
+    x1e: "X1E",
+    a1: "A1",
+    a1mini: "A1M",
+    h2d: "H2D",
+    h2s: "H2S",
+    h2c: "H2C",
+};
+const COLLAR_CHARM_POLICY = getCollarCharmRolePolicy();
+let filamentProfileIndexCache = null;
+function buildFilamentProfileIndex() {
+    const byName = new Map();
+    const baseNameByFilamentId = new Map();
+    if (!fs.existsSync(FILAMENT_PROFILE_DIR)) {
+        return { byName, baseNameByFilamentId };
+    }
+    for (const entry of fs.readdirSync(FILAMENT_PROFILE_DIR)) {
+        if (!entry.endsWith(".json"))
+            continue;
+        const filePath = path.join(FILAMENT_PROFILE_DIR, entry);
+        try {
+            const raw = fs.readFileSync(filePath, "utf8");
+            const parsed = JSON.parse(raw);
+            const name = typeof parsed?.name === "string" ? parsed.name.trim() : "";
+            const filamentId = typeof parsed?.filament_id === "string" ? parsed.filament_id.trim() : "";
+            if (name) {
+                byName.set(name, filePath);
+            }
+            if (name && filamentId) {
+                baseNameByFilamentId.set(filamentId, name);
+            }
+        }
+        catch {
+            // Ignore malformed or non-profile JSON files.
+        }
+    }
+    return { byName, baseNameByFilamentId };
+}
+function getFilamentProfileIndex() {
+    if (!filamentProfileIndexCache) {
+        filamentProfileIndexCache = buildFilamentProfileIndex();
+    }
+    return filamentProfileIndexCache;
+}
+function resolveFilamentProfileCandidates(trayInfoIdx, bambuModel, nozzleDiameter) {
+    const index = getFilamentProfileIndex();
+    const baseName = index.baseNameByFilamentId.get(trayInfoIdx) || null;
+    if (!baseName) {
+        return { baseName: null, paths: [], resolution: "unresolved" };
+    }
+    const bareName = baseName.replace(/\s*@base$/, "");
+    const modelCode = bambuModel ? FILAMENT_MODEL_CODES[bambuModel] : undefined;
+    const candidateNames = [];
+    if (modelCode && nozzleDiameter) {
+        candidateNames.push(`${bareName} @BBL ${modelCode} ${nozzleDiameter} nozzle`);
+    }
+    if (modelCode) {
+        candidateNames.push(`${bareName} @BBL ${modelCode}`);
+    }
+    candidateNames.push(bareName, baseName);
+    const resolvedPaths = [];
+    let resolution = "unresolved";
+    for (const [candidateIndex, candidateName] of candidateNames.entries()) {
+        const candidatePath = index.byName.get(candidateName);
+        if (!candidatePath || resolvedPaths.includes(candidatePath))
+            continue;
+        resolvedPaths.push(candidatePath);
+        if (resolution === "unresolved") {
+            if (candidateIndex === 0 && modelCode && nozzleDiameter) {
+                resolution = "exact-model-nozzle";
+            }
+            else if ((candidateIndex === 0 && modelCode && !nozzleDiameter) ||
+                (candidateIndex === 1 && modelCode && nozzleDiameter)) {
+                resolution = "model";
+            }
+            else {
+                resolution = "generic";
+            }
+        }
+    }
+    return { baseName, paths: resolvedPaths, resolution };
+}
+function parseIntegerOrNull(value) {
+    if (value === undefined || value === null || value === "")
+        return null;
+    const parsed = Number.parseInt(String(value), 10);
+    return Number.isFinite(parsed) ? parsed : null;
+}
+function normalizePrinterFilamentInventory(status, bambuModel, nozzleDiameter) {
+    const rawAms = status?.raw?.ams || status?.ams || {};
+    const trayNow = parseIntegerOrNull(rawAms?.tray_now);
+    const trays = [];
+    const amsArray = Array.isArray(rawAms?.ams) ? rawAms.ams : [];
+    for (const [amsIndex, amsUnit] of amsArray.entries()) {
+        const trayArray = Array.isArray(amsUnit?.tray) ? amsUnit.tray : [];
+        for (const [trayIndex, tray] of trayArray.entries()) {
+            const amsId = parseIntegerOrNull(amsUnit?.id) ?? amsIndex;
+            const trayId = parseIntegerOrNull(tray?.id) ?? trayIndex;
+            const slot = amsId !== null && trayId !== null ? amsId * 4 + trayId : null;
+            const state = parseIntegerOrNull(tray?.state) ?? 0;
+            const trayInfoIdx = typeof tray?.tray_info_idx === "string" ? tray.tray_info_idx : null;
+            const profileResolution = trayInfoIdx
+                ? resolveFilamentProfileCandidates(trayInfoIdx, bambuModel, nozzleDiameter)
+                : { baseName: null, paths: [], resolution: "unresolved" };
+            const resolvedProfilePath = profileResolution.paths[0] || null;
+            const matchConfidence = profileResolution.resolution === "exact-model-nozzle" ? "high" :
+                profileResolution.resolution === "model" ? "medium" :
+                    profileResolution.resolution === "generic" ? "low" :
+                        "none";
+            const trayType = typeof tray?.tray_type === "string" ? tray.tray_type : null;
+            const traySubBrands = typeof tray?.tray_sub_brands === "string" ? tray.tray_sub_brands : null;
+            const trayColor = typeof tray?.tray_color === "string" ? tray.tray_color : null;
+            const displayParts = [
+                traySubBrands && traySubBrands !== trayType ? traySubBrands : null,
+                trayType,
+                trayColor ? `#${normalizeRgbColor(trayColor) ?? trayColor.replace(/^#/, "").slice(0, 6)}` : null,
+            ].filter(Boolean);
+            trays.push({
+                ams_id: amsId,
+                tray_id: trayId,
+                slot,
+                state,
+                loaded: state !== 0 && Boolean(trayInfoIdx),
+                tray_info_idx: trayInfoIdx,
+                tray_type: trayType,
+                tray_sub_brands: traySubBrands,
+                tray_color: trayColor,
+                remain_percent: typeof tray?.remain === "number" && tray.remain >= 0 ? tray.remain : null,
+                nozzle_temp_min: parseIntegerOrNull(tray?.nozzle_temp_min),
+                nozzle_temp_max: parseIntegerOrNull(tray?.nozzle_temp_max),
+                resolved_base_profile_name: profileResolution.baseName,
+                resolved_profile_path: resolvedProfilePath,
+                profile_resolution: profileResolution.resolution,
+                match_confidence: matchConfidence,
+                display_name: displayParts.length > 0 ? displayParts.join(" ") : "empty/unknown",
+                profile_candidates: profileResolution.paths,
+            });
+        }
+    }
+    const loadedTrays = trays.filter((tray) => tray.loaded);
+    const recommendedTray = loadedTrays.find((tray) => tray.slot === trayNow && tray.resolved_profile_path) ||
+        loadedTrays.find((tray) => tray.resolved_profile_path) ||
+        null;
+    const recommendedReason = recommendedTray?.slot === trayNow
+        ? "current AMS slot with resolved slicer profile"
+        : recommendedTray
+            ? "first loaded AMS slot with resolved slicer profile"
+            : null;
+    const allProfilePaths = Array.from(new Set(loadedTrays
+        .map((tray) => tray.resolved_profile_path)
+        .filter((candidate) => Boolean(candidate))));
+    const emptySlots = trays.filter((tray) => !tray.loaded).length;
+    const resolvedProfileSlots = loadedTrays.filter((tray) => tray.resolved_profile_path).length;
+    return {
+        current_slot: trayNow !== null && trayNow >= 0 && trayNow < 254 ? trayNow : null,
+        current_source: trayNow === 254 ? "external" : trayNow !== null && trayNow >= 0 && trayNow < 254 ? "ams" : null,
+        summary: {
+            loaded_slots: loadedTrays.length,
+            resolved_profile_slots: resolvedProfileSlots,
+            unresolved_loaded_slots: loadedTrays.length - resolvedProfileSlots,
+            empty_slots: emptySlots,
+            current_slot: trayNow !== null && trayNow >= 0 && trayNow < 254 ? trayNow : null,
+            current_source: trayNow === 254 ? "external" : trayNow !== null && trayNow >= 0 && trayNow < 254 ? "ams" : null,
+            recommended_slot: recommendedTray?.slot ?? null,
+            recommended_reason: recommendedReason,
+        },
+        trays,
+        recommended: recommendedTray
+            ? {
+                slot: recommendedTray.slot,
+                tray_info_idx: recommendedTray.tray_info_idx,
+                tray_type: recommendedTray.tray_type,
+                resolved_profile_path: recommendedTray.resolved_profile_path,
+                load_filaments: recommendedTray.resolved_profile_path,
+                reason: recommendedReason ?? "resolved slicer profile",
+            }
+            : null,
+        load_filaments_all: allProfilePaths.length > 0 ? allProfilePaths.join(";") : null,
+    };
+}
+/**
+ * Normalize a hex color string to lowercase 6-char RGB (drop leading "#"
+ * and any trailing alpha bytes). Returns null if the input doesn't look
+ * like a hex color.
+ *
+ * Bambu mixes formats: 3MF project_settings stores `#FFFFFF` or
+ * `#FF911A80` (RGB or RGBA with leading #). AMS push_status reports
+ * `FFFFFFFF` (RGBA without #). Comparing alpha is risky -- the same
+ * filament can show up as `#000000` in one place and `000000FF` in
+ * another. RGB-only is the right key.
+ */
+function normalizeRgbColor(color) {
+    if (!color)
+        return null;
+    const hex = color.replace(/^#/, "").toLowerCase();
+    if (!/^[0-9a-f]{6}([0-9a-f]{2})?$/.test(hex))
+        return null;
+    return hex.slice(0, 6);
+}
+function resolveAmsSlotsFromRequirements(requirements, inventory) {
+    const matches = [];
+    const missing = [];
+    const amsSlots = [];
+    // Track which AMS slots have already been claimed by an earlier
+    // requirement so two filaments with the same SKU don't collapse onto
+    // the same physical slot.
+    const claimedSlots = new Set();
+    for (const filament of requirements.filaments) {
+        if (!filament.tray_info_idx) {
+            missing.push({
+                filament_position: filament.filamentPosition,
+                tray_info_idx: null,
+                required_color: filament.color ?? null,
+                reason: "no_sku",
+            });
+            continue;
+        }
+        const requiredColor = normalizeRgbColor(filament.color);
+        // Pool of trays loaded with the required SKU that aren't already claimed.
+        const skuPool = inventory.trays.filter((candidate) => candidate.loaded &&
+            candidate.slot !== null &&
+            candidate.tray_info_idx === filament.tray_info_idx &&
+            !claimedSlots.has(candidate.slot));
+        if (skuPool.length === 0) {
+            // No trays of this SKU loaded at all (or all already claimed).
+            const reason = inventory.trays.some((t) => t.tray_info_idx === filament.tray_info_idx)
+                ? "exhausted"
+                : "no_loaded_match";
+            missing.push({
+                filament_position: filament.filamentPosition,
+                tray_info_idx: filament.tray_info_idx,
+                required_color: filament.color ?? null,
+                reason,
+            });
+            continue;
+        }
+        // Prefer an exact RGB color match. This is what disambiguates
+        // same-SKU different-color cases (e.g. two GFG02 PETG HF trays
+        // loaded -- one black, one white).
+        let chosen = skuPool.find((candidate) => normalizeRgbColor(candidate.tray_color) === requiredColor && requiredColor !== null);
+        let strategy = "color";
+        // Fall back to SKU-only when the requirement has no color (legacy
+        // 3MF) or when only one tray of this SKU is loaded (no ambiguity).
+        if (!chosen) {
+            if (!requiredColor || skuPool.length === 1) {
+                chosen = skuPool[0];
+                strategy = "sku-only";
+            }
+            else {
+                // Color was specified, multiple SKU candidates loaded, none
+                // match the requested color. Surface clearly rather than pick
+                // a wrong color silently.
+                missing.push({
+                    filament_position: filament.filamentPosition,
+                    tray_info_idx: filament.tray_info_idx,
+                    required_color: filament.color ?? null,
+                    reason: "color_mismatch",
+                });
+                continue;
+            }
+        }
+        if (chosen.slot === null) {
+            // Defensive: shouldn't happen because of the filter above, but
+            // keep the type contract honest.
+            missing.push({
+                filament_position: filament.filamentPosition,
+                tray_info_idx: filament.tray_info_idx,
+                required_color: filament.color ?? null,
+                reason: "no_loaded_match",
+            });
+            continue;
+        }
+        claimedSlots.add(chosen.slot);
+        amsSlots.push(chosen.slot);
+        matches.push({
+            filament_position: filament.filamentPosition,
+            tray_info_idx: filament.tray_info_idx,
+            slot: chosen.slot,
+            matched_color: chosen.tray_color ?? null,
+            match_strategy: strategy,
+        });
+    }
+    return { ams_slots: amsSlots, matches, missing };
+}
+function extractPrinterDiagnostics(status) {
+    const raw = status?.raw && typeof status.raw === "object" ? status.raw : {};
+    const diagnosticFields = {};
+    for (const [key, value] of Object.entries(raw)) {
+        if (/(hms|error|fail|warn)/i.test(key)) {
+            diagnosticFields[key] = value;
+        }
+    }
+    return {
+        connected: Boolean(status?.connected),
+        serial: status?.serial ?? null,
+        printer_status: status?.status ?? null,
+        active_error: raw.print_error ??
+            raw.print_error_code ??
+            raw.mc_print_error_code ??
+            raw.fail_reason ??
+            null,
+        hms: raw.hms ?? raw.hms_info ?? raw.hms_list ?? null,
+        diagnostic_fields: diagnosticFields,
+    };
+}
 function validateBambuModel(model) {
     const normalized = model.trim().toLowerCase();
     if (!VALID_BAMBU_MODELS.includes(normalized)) {
@@ -48,9 +366,19 @@ function resolveBedType(argsBedType) {
     }
     return bedType;
 }
+function resolveBambuStudioCliBedType(argsBedType) {
+    const bedType = resolveBedType(argsBedType);
+    if (!VALID_BAMBUSTUDIO_CLI_BED_TYPES.includes(bedType)) {
+        throw new Error(`BambuStudio CLI bed_type "${bedType}" is not verified. Use a pre-sliced 3MF for SuperTack, or choose one of: ${VALID_BAMBUSTUDIO_CLI_BED_TYPES.join(", ")}`);
+    }
+    return bedType;
+}
 // Slicer configuration (defaults to bambustudio)
 const DEFAULT_SLICER_TYPE = process.env.SLICER_TYPE || "bambustudio";
-const DEFAULT_SLICER_PROFILE = process.env.SLICER_PROFILE || "";
+const DEFAULT_SLICER_PROFILE = process.env.BAMBU_SLICER_PROFILE || process.env.SLICER_PROFILE || "";
+const DEFAULT_TEMPLATE_3MF_PATH = process.env.BAMBU_TEMPLATE_3MF_PATH || "";
+const DEFAULT_TEMPLATE_DIR = process.env.BAMBU_TEMPLATE_DIR ||
+    path.join(process.env.HOME || process.cwd(), "Sync", "bambu", "templates");
 const SLICER_SCHEMA_VALUES = [
     ...SLICER_TYPES,
     "fulu-orca",
@@ -76,6 +404,9 @@ function defaultSlicerPathFor(slicerType) {
         return "OrcaSlicer";
     }
     if (slicerType === "bambustudio") {
+        if (process.env.BAMBU_STUDIO_PATH) {
+            return process.env.BAMBU_STUDIO_PATH;
+        }
         if (process.platform === "darwin") {
             return "/Applications/BambuStudio.app/Contents/MacOS/BambuStudio";
         }
@@ -122,6 +453,37 @@ function parseCsvEnv(value) {
         return new Set();
     return new Set(value.split(",").map((e) => e.trim()).filter((e) => e.length > 0));
 }
+async function resolveSlicerProfilePath(requestedProfile, templatePath, tempDir) {
+    if (requestedProfile) {
+        return requestedProfile;
+    }
+    if (templatePath) {
+        return resolveTemplateSlicerProfilePath(templatePath, tempDir);
+    }
+    return undefined;
+}
+async function resolveTemplateSlicerProfilePath(templatePath, tempDir) {
+    const extension = path.extname(templatePath).toLowerCase();
+    if (extension === ".3mf") {
+        return extractBambuTemplateSettings(templatePath, tempDir);
+    }
+    if (extension === ".json" || extension === ".config") {
+        return templatePath;
+    }
+    throw new Error(`Template profile must be a .3mf, .json, or .config file: ${templatePath}`);
+}
+function hasExplicitSlicerProfile(args) {
+    return typeof args?.slicer_profile === "string" && args.slicer_profile.trim().length > 0;
+}
+async function resolveTemplateFirstSlicerProfilePath(args, configuredProfile, template3mfPath, tempDir) {
+    if (hasExplicitSlicerProfile(args)) {
+        return configuredProfile || undefined;
+    }
+    if (template3mfPath) {
+        return resolveTemplateSlicerProfilePath(template3mfPath, tempDir);
+    }
+    return configuredProfile || undefined;
+}
 function readRuntimeConfig() {
     const rawTransport = process.env.MCP_TRANSPORT?.trim().toLowerCase();
     const transport = rawTransport === "streamable-http" || rawTransport === "http"
@@ -248,6 +610,131 @@ function redactPrintParams(params) {
         password: params.password ? "[redacted]" : "",
     };
 }
+function parseLooseSlicerConfig(content) {
+    try {
+        return JSON.parse(content);
+    }
+    catch {
+        const config = {};
+        for (const line of content.split(/\r?\n/)) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith("#") || trimmed.startsWith(";"))
+                continue;
+            const separatorIndex = trimmed.indexOf("=");
+            if (separatorIndex === -1)
+                continue;
+            const key = trimmed.slice(0, separatorIndex).trim();
+            const value = trimmed.slice(separatorIndex + 1).trim();
+            if (key) {
+                config[key] = value;
+            }
+        }
+        return config;
+    }
+}
+function summarizeSliceSettings(config) {
+    return {
+        printer_settings_id: typeof config.printer_settings_id === "string" ? config.printer_settings_id : null,
+        default_print_profile: typeof config.default_print_profile === "string" ? config.default_print_profile : null,
+        default_filament_profile: Array.isArray(config.default_filament_profile)
+            ? config.default_filament_profile
+            : typeof config.default_filament_profile === "string"
+                ? [config.default_filament_profile]
+                : [],
+        filament_settings_id: Array.isArray(config.filament_settings_id)
+            ? config.filament_settings_id.filter((value) => typeof value === "string" && value.length > 0)
+            : [],
+        filament_type: Array.isArray(config.filament_type)
+            ? config.filament_type.filter((value) => typeof value === "string" && value.length > 0)
+            : [],
+        inherits: typeof config.inherits === "string" ? config.inherits : null,
+        print_settings_id: typeof config.print_settings_id === "string" ? config.print_settings_id : null,
+        compatible_printers: Array.isArray(config.compatible_printers)
+            ? config.compatible_printers.filter((value) => typeof value === "string" && value.length > 0)
+            : [],
+        layer_height: config.layer_height !== undefined && config.layer_height !== null
+            ? Number(config.layer_height)
+            : null,
+        first_layer_height: config.initial_layer_print_height !== undefined && config.initial_layer_print_height !== null
+            ? Number(config.initial_layer_print_height)
+            : config.first_layer_height !== undefined && config.first_layer_height !== null
+                ? Number(config.first_layer_height)
+                : null,
+        sparse_infill_density: config.sparse_infill_density !== undefined && config.sparse_infill_density !== null
+            ? String(config.sparse_infill_density)
+            : null,
+        wall_loops: config.wall_loops !== undefined && config.wall_loops !== null
+            ? Number(config.wall_loops)
+            : null,
+        top_shell_layers: config.top_shell_layers !== undefined && config.top_shell_layers !== null
+            ? Number(config.top_shell_layers)
+            : null,
+        bottom_shell_layers: config.bottom_shell_layers !== undefined && config.bottom_shell_layers !== null
+            ? Number(config.bottom_shell_layers)
+            : null,
+        brim_width: config.brim_width !== undefined && config.brim_width !== null
+            ? Number(config.brim_width)
+            : null,
+        support_enabled: config.enable_support !== undefined
+            ? String(config.enable_support) === "1" || String(config.enable_support).toLowerCase() === "true"
+            : config.support_enabled !== undefined
+                ? Boolean(config.support_enabled)
+                : null,
+        support_type: typeof config.support_type === "string" ? config.support_type : null,
+        bed_type: typeof config.curr_bed_type === "string"
+            ? config.curr_bed_type
+            : typeof config.bed_type === "string"
+                ? config.bed_type
+                : null,
+        nozzle_temperature: Array.isArray(config.nozzle_temperature)
+            ? config.nozzle_temperature
+            : config.nozzle_temperature !== undefined
+                ? [config.nozzle_temperature]
+                : [],
+    };
+}
+function sanitizeTemplateName(templateName) {
+    return templateName
+        .trim()
+        .replace(/\\/g, "/")
+        .replace(/^\/+|\/+$/g, "")
+        .replace(/\s+/g, "_")
+        .replace(/[^A-Za-z0-9/_-]/g, "_");
+}
+function scanTemplateRegistry(templateDir) {
+    if (!fs.existsSync(templateDir)) {
+        return [];
+    }
+    const allowedExtensions = new Set([".3mf", ".json", ".config"]);
+    const entries = [];
+    const stack = [templateDir];
+    while (stack.length > 0) {
+        const currentDir = stack.pop();
+        for (const entry of fs.readdirSync(currentDir, { withFileTypes: true })) {
+            const fullPath = path.join(currentDir, entry.name);
+            if (entry.isDirectory()) {
+                stack.push(fullPath);
+                continue;
+            }
+            const extension = path.extname(entry.name).toLowerCase();
+            if (!allowedExtensions.has(extension)) {
+                continue;
+            }
+            const relativePath = path.relative(templateDir, fullPath);
+            const templateName = relativePath
+                .replace(/\\/g, "/")
+                .replace(/(\.gcode)?\.3mf$/i, "")
+                .replace(/\.(json|config)$/i, "");
+            entries.push({
+                name: templateName,
+                path: fullPath,
+                source_type: extension === ".3mf" ? "3mf" : extension === ".json" ? "json" : "config",
+                relative_path: relativePath,
+            });
+        }
+    }
+    return entries.sort((a, b) => a.name.localeCompare(b.name));
+}
 if (!fs.existsSync(TEMP_DIR)) {
     fs.mkdirSync(TEMP_DIR, { recursive: true });
 }
@@ -287,7 +774,7 @@ class BambuPrinterMCPServer {
         if (fromArgs) {
             return validateBambuModel(fromArgs);
         }
-        // No model from args or env - ask the user via elicitation
+        // No model from args or env — ask the user via elicitation
         try {
             const result = await this.server.elicitInput({
                 mode: "form",
@@ -303,11 +790,14 @@ class BambuPrinterMCPServer {
                             oneOf: [
                                 { const: "p1s", title: "P1S" },
                                 { const: "p1p", title: "P1P" },
+                                { const: "p2s", title: "P2S" },
                                 { const: "x1c", title: "X1 Carbon" },
                                 { const: "x1e", title: "X1E" },
                                 { const: "a1", title: "A1" },
                                 { const: "a1mini", title: "A1 Mini" },
                                 { const: "h2d", title: "H2D" },
+                                { const: "h2s", title: "H2S" },
+                                { const: "h2c", title: "H2C" },
                             ],
                         },
                     },
@@ -320,7 +810,7 @@ class BambuPrinterMCPServer {
             throw new Error("Printer model selection was cancelled. Cannot proceed without knowing the printer model.");
         }
         catch (elicitError) {
-            // Elicitation not supported by this client - fall back to a clear error
+            // Elicitation not supported by this client — fall back to a clear error
             const msg = elicitError?.message || String(elicitError);
             if (elicitError?.code === -32601 || elicitError?.code === -32600 ||
                 msg.includes("does not support") || msg.includes("elicitation")) {
@@ -340,7 +830,7 @@ class BambuPrinterMCPServer {
             timeoutMs: args?.timeout_ms !== undefined ? Number(args.timeout_ms) : undefined,
         };
     }
-    async ensurePrintableThreeMFPath(args, printModel, printPreset) {
+    async ensurePrintableThreeMFPath(args, printModel, printPreset, bedType) {
         const { slicerType, slicerPath, slicerProfile } = resolveSlicerConfig(args);
         let threeMFPath = String(args.three_mf_path);
         const JSZip = (await import('jszip')).default;
@@ -350,53 +840,75 @@ class BambuPrinterMCPServer {
         if (hasGcode) {
             return { threeMFPath, autoSliced: false };
         }
+        if (bedType === "supertack_plate") {
+            throw new Error('BambuStudio CLI SuperTack bed type is not verified; use a pre-sliced 3MF for SuperTack or choose textured_plate, cool_plate, engineering_plate, or hot_plate.');
+        }
         console.log(`3MF has no gcode - auto-slicing with ${slicerType} for ${printModel}`);
         const autoSliceOptions = {
             uptodate: true,
             ensureOnBed: true,
             minSave: true,
             skipModifiedGcodes: true,
+            bedType: bedType ? resolveBambuStudioCliBedType(bedType) : undefined,
         };
         threeMFPath = await this.stlManipulator.sliceSTL(threeMFPath, slicerType, slicerPath, slicerProfile || undefined, undefined, printPreset, autoSliceOptions);
         console.log("Auto-sliced to: " + threeMFPath);
         return { threeMFPath, autoSliced: true };
     }
-    async resolveAmsPrintSettings(threeMFPath, args) {
+    async resolveAmsPrintSettings(threeMFPath, args, host, bambuSerial, bambuToken, printModel, printNozzle) {
         const parsed3MFData = await parse3MF(threeMFPath);
         let parsedAmsMapping;
         if (parsed3MFData.slicerConfig?.ams_mapping) {
-            const slots = Object.values(parsed3MFData.slicerConfig.ams_mapping)
-                .filter(v => typeof v === 'number');
+            const slots = normalizeAmsMappingObject(parsed3MFData.slicerConfig.ams_mapping);
             if (slots.length > 0) {
-                parsedAmsMapping = slots.sort((a, b) => a - b);
+                parsedAmsMapping = slots;
             }
         }
         let finalAmsMapping = parsedAmsMapping;
-        const explicitUseAMS = args?.use_ams !== undefined;
-        let useAMS = explicitUseAMS ? Boolean(args.use_ams) : (!!finalAmsMapping && finalAmsMapping.length > 0);
-        if (args?.ams_mapping) {
+        let finalAmsSlots;
+        let useAMS = args?.use_ams !== undefined ? Boolean(args.use_ams) : (!!finalAmsMapping && finalAmsMapping.length > 0);
+        const hasUserAmsMapping = hasAmsMappingInput(args?.ams_mapping);
+        const hasUserAmsSlots = Array.isArray(args?.ams_slots);
+        if (hasUserAmsMapping) {
             let userMappingOverride;
             if (Array.isArray(args.ams_mapping)) {
-                userMappingOverride = args.ams_mapping.filter((v) => typeof v === 'number');
+                userMappingOverride = args.ams_mapping.map((v, i) => normalizeBridgeAmsTrayValue(v, `ams_mapping[${i}]`));
             }
-            else if (typeof args.ams_mapping === 'object') {
-                userMappingOverride = Object.values(args.ams_mapping)
-                    .filter((v) => typeof v === 'number')
-                    .sort((a, b) => a - b);
+            else if (args.ams_mapping && typeof args.ams_mapping === 'object') {
+                userMappingOverride = normalizeAmsMappingObject(args.ams_mapping);
             }
             if (userMappingOverride && userMappingOverride.length > 0) {
                 finalAmsMapping = userMappingOverride;
+                finalAmsSlots = undefined;
                 useAMS = true;
             }
         }
+        if (!hasUserAmsMapping && hasUserAmsSlots) {
+            const userSlots = args.ams_slots.map((slot, i) => normalizeBridgeAmsTrayValue(slot, `ams_slots[${i}]`));
+            finalAmsSlots = userSlots;
+            finalAmsMapping = undefined;
+            useAMS = userSlots.length > 0;
+        }
+        if (!hasUserAmsMapping && !hasUserAmsSlots && args?.auto_match_ams) {
+            const requirements = await analyze3MFAmsRequirements(threeMFPath, args?.plate_index !== undefined ? Number(args.plate_index) : 0);
+            const inventory = await this.getResolvedPrinterFilamentInventory(host, bambuSerial, bambuToken, printModel, printNozzle);
+            const resolved = resolveAmsSlotsFromRequirements(requirements, inventory);
+            if (resolved.missing.length > 0) {
+                throw new Error(`Could not auto-match AMS slots: ${JSON.stringify(resolved.missing)}`);
+            }
+            finalAmsSlots = resolved.ams_slots;
+            finalAmsMapping = undefined;
+            useAMS = true;
+        }
         if (args?.use_ams === false) {
             finalAmsMapping = undefined;
+            finalAmsSlots = undefined;
             useAMS = false;
         }
-        if ((!finalAmsMapping || finalAmsMapping.length === 0) && !explicitUseAMS) {
+        if ((!finalAmsMapping || finalAmsMapping.length === 0) && (!finalAmsSlots || finalAmsSlots.length === 0)) {
             useAMS = false;
         }
-        return { useAMS, finalAmsMapping };
+        return { useAMS, finalAmsMapping, finalAmsSlots };
     }
     async print3mfViaBambuNetwork(args, host, bambuSerial, bambuToken) {
         if (!args?.three_mf_path) {
@@ -430,13 +942,13 @@ class BambuPrinterMCPServer {
         if (isLocalBridgePrint && !password) {
             throw new Error("bambu_token/access code is required for FULU BambuNetwork LAN/local print methods.");
         }
-        const { threeMFPath, autoSliced } = await this.ensurePrintableThreeMFPath(args, printModel, printPreset);
-        const { useAMS, finalAmsMapping } = await this.resolveAmsPrintSettings(threeMFPath, args);
+        const { threeMFPath, autoSliced } = await this.ensurePrintableThreeMFPath(args, printModel, printPreset, printBedType);
+        const { useAMS, finalAmsMapping, finalAmsSlots } = await this.resolveAmsPrintSettings(threeMFPath, args, host, bambuSerial, bambuToken, printModel, printNozzle);
         const threeMfFilename = path.basename(threeMFPath);
         const projectName = String(args?.project_name || threeMfFilename.replace(/\.3mf$/i, ''));
         const presetName = String(args?.preset_name || `${projectName}_plate_${plateIndex + 1}`);
         const clientJobId = args?.client_job_id !== undefined ? Number(args.client_job_id) : Date.now();
-        const amsMapping = stringifyBridgeJson(args?.ams_mapping_bridge ?? finalAmsMapping);
+        const amsMapping = stringifyBridgeJson(args?.ams_mapping_bridge ?? finalAmsMapping ?? finalAmsSlots);
         const params = {
             dev_id: devId,
             task_name: String(args?.task_name || projectName),
@@ -503,10 +1015,175 @@ class BambuPrinterMCPServer {
             plateIndex,
             bridgePlateIndex: plateIndex + 1,
             useAMS,
-            amsMapping: finalAmsMapping,
+            amsMapping: finalAmsMapping ?? finalAmsSlots,
             params: redactPrintParams(params),
         };
     }
+    async getResolvedPrinterFilamentInventory(host, bambuSerial, bambuToken, bambuModel, nozzleDiameter) {
+        const status = await this.bambu.getStatus(host, bambuSerial, bambuToken);
+        let inventory = normalizePrinterFilamentInventory(status, bambuModel, nozzleDiameter);
+        // The first MQTT push from an idle printer is sparse (model/modules
+        // only). AMS data arrives on a second push a short while later. If
+        // we have a live connection but no loaded trays, wait for the follow-
+        // up push and retry.
+        if (inventory.trays.length === 0 && status.connected) {
+            await new Promise((r) => setTimeout(r, 1500));
+            const retryStatus = await this.bambu.getStatus(host, bambuSerial, bambuToken);
+            inventory = normalizePrinterFilamentInventory(retryStatus, bambuModel, nozzleDiameter);
+        }
+        return inventory;
+    }
+    async inspectSliceSettings(sourcePath) {
+        if (!fs.existsSync(sourcePath)) {
+            throw new Error(`Slice settings source not found: ${sourcePath}`);
+        }
+        const extension = path.extname(sourcePath).toLowerCase();
+        const tempDir = path.join(TEMP_DIR, "slice-settings");
+        fs.mkdirSync(tempDir, { recursive: true });
+        if (extension === ".3mf") {
+            const parsed = await parse3MF(sourcePath);
+            const extractedSettingsPath = await extractBambuTemplateSettings(sourcePath, tempDir);
+            const config = (parsed.slicerConfig || {});
+            return {
+                source_path: sourcePath,
+                source_type: "3mf",
+                extracted_settings_path: extractedSettingsPath,
+                object_count: parsed.objects.length,
+                build_item_count: parsed.build.items.length,
+                metadata_keys: Object.keys(parsed.metadata),
+                summary: summarizeSliceSettings(config),
+                raw_key_count: Object.keys(config).length,
+            };
+        }
+        const content = fs.readFileSync(sourcePath, "utf8");
+        const config = parseLooseSlicerConfig(content);
+        return {
+            source_path: sourcePath,
+            source_type: extension === ".json" ? "json" : extension === ".config" ? "config" : "text",
+            extracted_settings_path: sourcePath,
+            summary: summarizeSliceSettings(config),
+            raw_key_count: Object.keys(config).length,
+        };
+    }
+    async resolveCollarCharmPrepared3MF(sourcePath, template3mfPath, slicerType, slicerPath, slicerProfile, printModel, printNozzle, bedType, host, bambuSerial, bambuToken) {
+        if (!sourcePath.toLowerCase().endsWith(".3mf")) {
+            throw new Error("print_collar_charm requires a prepared .3mf project or sliced 3MF.");
+        }
+        try {
+            const JSZip = (await import('jszip')).default;
+            const zipData = fs.readFileSync(sourcePath);
+            const zip = await JSZip.loadAsync(zipData);
+            const hasGcode = Object.keys(zip.files).some((fileName) => fileName.match(/Metadata\/plate_\d+\.gcode/i) || fileName.endsWith('.gcode'));
+            if (hasGcode) {
+                return sourcePath;
+            }
+        }
+        catch (error) {
+            throw new Error(`Failed to inspect collar charm 3MF before slicing: ${error.message}`);
+        }
+        const printPreset = BAMBU_MODEL_PRESETS[printModel]?.(printNozzle);
+        if (bedType === "supertack_plate") {
+            throw new Error('BambuStudio CLI SuperTack bed type is not verified; use a pre-sliced 3MF for SuperTack or choose textured_plate, cool_plate, engineering_plate, or hot_plate.');
+        }
+        const autoSliceOptions = {
+            uptodate: true,
+            ensureOnBed: true,
+            minSave: true,
+            skipModifiedGcodes: true,
+            bedType,
+        };
+        try {
+            const liveFilaments = await this.getResolvedPrinterFilamentInventory(host, bambuSerial, bambuToken, printModel, printNozzle);
+            if (liveFilaments.recommended?.load_filaments) {
+                autoSliceOptions.loadFilaments = liveFilaments.recommended.load_filaments;
+            }
+        }
+        catch (filamentError) {
+            console.warn("Could not resolve live printer filaments for collar charm auto-slicing:", filamentError);
+        }
+        return this.stlManipulator.sliceSTL(sourcePath, slicerType, slicerPath, slicerProfile || template3mfPath || undefined, undefined, printPreset, autoSliceOptions);
+    }
+    async preflightCollarCharmPolicy(host, bambuSerial, bambuToken, bambuModel, nozzleDiameter) {
+        const inventory = await this.getResolvedPrinterFilamentInventory(host, bambuSerial, bambuToken, bambuModel, nozzleDiameter);
+        const requiredSlots = [COLLAR_CHARM_POLICY.amsSlots.inner, COLLAR_CHARM_POLICY.amsSlots.outer];
+        for (const slot of requiredSlots) {
+            const tray = inventory.trays.find((candidate) => candidate.slot === slot);
+            if (!tray) {
+                throw new Error(`Collar charm wrapper requires AMS tray ${slot}, but that tray is not reported by the printer.`);
+            }
+            if (!tray.loaded) {
+                throw new Error(`Collar charm wrapper requires AMS tray ${slot} to be loaded, but it is currently empty or unavailable.`);
+            }
+        }
+        return inventory;
+    }
+    listTemplateRegistry(templateDir) {
+        const resolvedTemplateDir = templateDir && templateDir.trim().length > 0
+            ? templateDir
+            : DEFAULT_TEMPLATE_DIR;
+        return {
+            template_dir: resolvedTemplateDir,
+            templates: scanTemplateRegistry(resolvedTemplateDir),
+        };
+    }
+    resolveTemplatePath(templateName, templateDir, sourceTypes) {
+        if (!templateName || templateName.trim().length === 0) {
+            return undefined;
+        }
+        const registry = this.listTemplateRegistry(templateDir);
+        const normalizedName = sanitizeTemplateName(templateName).toLowerCase();
+        const requestedName = templateName.trim().replace(/\\/g, "/").replace(/^\/+|\/+$/g, "").toLowerCase();
+        const nameMatches = registry.templates.filter((entry) => entry.name.toLowerCase() === requestedName ||
+            sanitizeTemplateName(entry.name).toLowerCase() === normalizedName);
+        const searchTypes = sourceTypes && sourceTypes.length > 0
+            ? sourceTypes
+            : ["3mf", "json", "config"];
+        const match = searchTypes
+            .map((sourceType) => nameMatches.find((entry) => entry.source_type === sourceType))
+            .find((entry) => Boolean(entry));
+        if (!match) {
+            const typeHint = sourceTypes && sourceTypes.length > 0
+                ? ` with source type ${sourceTypes.join("/")}`
+                : "";
+            const availableTypes = nameMatches.length > 0
+                ? ` Available source types: ${Array.from(new Set(nameMatches.map((entry) => entry.source_type))).join(", ")}.`
+                : "";
+            throw new Error(`Template "${templateName}"${typeHint} not found in ${registry.template_dir}.${availableTypes}`);
+        }
+        return match.path;
+    }
+    saveTemplate(sourcePath, templateName, templateDir) {
+        if (!fs.existsSync(sourcePath)) {
+            throw new Error(`Template source not found: ${sourcePath}`);
+        }
+        const resolvedTemplateDir = templateDir && templateDir.trim().length > 0
+            ? templateDir
+            : DEFAULT_TEMPLATE_DIR;
+        fs.mkdirSync(resolvedTemplateDir, { recursive: true });
+        const sourceBaseName = path.basename(sourcePath);
+        const extension = path.extname(sourceBaseName).toLowerCase();
+        if (![".3mf", ".json", ".config"].includes(extension)) {
+            throw new Error("Templates must be .3mf, .json, or .config files.");
+        }
+        const baseName = templateName && templateName.trim().length > 0
+            ? sanitizeTemplateName(templateName)
+            : sanitizeTemplateName(sourceBaseName
+                .replace(/(\.gcode)?\.3mf$/i, "")
+                .replace(/\.(json|config)$/i, ""));
+        const destinationPath = path.join(resolvedTemplateDir, `${baseName}${extension}`);
+        fs.mkdirSync(path.dirname(destinationPath), { recursive: true });
+        fs.copyFileSync(sourcePath, destinationPath);
+        const sourceType = extension === ".3mf" ? "3mf" : extension === ".json" ? "json" : "config";
+        const registryEntry = this.resolveTemplatePath(baseName, resolvedTemplateDir, [sourceType]);
+        return {
+            saved: true,
+            template_name: baseName,
+            source_path: sourcePath,
+            destination_path: destinationPath,
+            template_dir: resolvedTemplateDir,
+            resolved_path: registryEntry,
+        };
+    }
     setupResourceHandlers() {
         this.server.setRequestHandler(ListResourcesRequestSchema, async () => {
             return {
@@ -522,6 +1199,12 @@ class BambuPrinterMCPServer {
                         name: "Bambu Printer Files",
                         mimeType: "application/json",
                         description: "List of files on the Bambu Lab printer"
+                    },
+                    {
+                        uri: `printer://${DEFAULT_HOST}/hms`,
+                        name: "Bambu Printer HMS Diagnostics",
+                        mimeType: "application/json",
+                        description: "HMS and error-related fields from the latest printer status"
                     }
                 ],
                 templates: [
@@ -534,6 +1217,11 @@ class BambuPrinterMCPServer {
                         uriTemplate: "printer://{host}/files",
                         name: "Bambu Printer Files",
                         mimeType: "application/json"
+                    },
+                    {
+                        uriTemplate: "printer://{host}/hms",
+                        name: "Bambu Printer HMS Diagnostics",
+                        mimeType: "application/json"
                     }
                 ]
             };
@@ -554,6 +1242,20 @@ class BambuPrinterMCPServer {
             else if (resource === "files") {
                 content = await this.bambu.getFiles(host || DEFAULT_HOST, bambuSerial, bambuToken);
             }
+            else if (resource === "hms") {
+                const status = await this.bambu.getStatus(host || DEFAULT_HOST, bambuSerial, bambuToken);
+                let diagnostics = extractPrinterDiagnostics(status);
+                // The first MQTT status push may not include HMS data — the printer
+                // sends basic state first, then pushes HMS/error fields on a subsequent
+                // report. If we got a connection but no HMS data, wait briefly and
+                // retry so the incremental merge has time to arrive.
+                if (!diagnostics.hms && status.connected) {
+                    await new Promise((r) => setTimeout(r, 1500));
+                    const retryStatus = await this.bambu.getStatus(host || DEFAULT_HOST, bambuSerial, bambuToken);
+                    diagnostics = extractPrinterDiagnostics(retryStatus);
+                }
+                content = diagnostics;
+            }
             else {
                 throw new McpError(ErrorCode.InvalidRequest, `Unknown resource: ${resource}`);
             }
@@ -593,6 +1295,69 @@ class BambuPrinterMCPServer {
                             }
                         }
                     },
+                    {
+                        name: "get_printer_filaments",
+                        description: "Get the live AMS/external filament inventory from the printer over MQTT, including loaded/empty slot summary, resolved slicer profile paths, match confidence, and recommended load_filaments when the printer model is known.",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                host: {
+                                    type: "string",
+                                    description: "Hostname or IP address of the printer (default: value from env)"
+                                },
+                                bambu_serial: {
+                                    type: "string",
+                                    description: "Serial number for the Bambu Lab printer (default: value from env)"
+                                },
+                                bambu_token: {
+                                    type: "string",
+                                    description: "Access token for the Bambu Lab printer (default: value from env)"
+                                },
+                                bambu_model: {
+                                    type: "string",
+                                    enum: [...VALID_BAMBU_MODELS],
+                                    description: "Optional model hint used to resolve Bambu/Orca filament profile JSONs for each tray."
+                                },
+                                nozzle_diameter: {
+                                    type: "string",
+                                    description: "Optional nozzle diameter used when resolving model-specific filament profile JSONs (default: 0.4)."
+                                }
+                            }
+                        }
+                    },
+                    {
+                        name: "resolve_3mf_ams_slots",
+                        description: "Inspect a sliced 3MF and match its tray_info_idx filament requirements against the live AMS inventory. Does not upload or start a print.",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                three_mf_path: { type: "string", description: "Path to a sliced 3MF/.gcode.3mf file" },
+                                plate_index: { type: "number", description: "0-based plate index to inspect (default: 0)" },
+                                bambu_model: {
+                                    type: "string",
+                                    enum: [...VALID_BAMBU_MODELS],
+                                    description: "Optional model hint used to resolve Bambu/Orca filament profile JSONs for each tray."
+                                },
+                                nozzle_diameter: { type: "string", description: "Nozzle diameter in mm (default: 0.4)" },
+                                host: { type: "string", description: "Hostname or IP of the printer (default: value from env)" },
+                                bambu_serial: { type: "string", description: "Serial number (default: value from env)" },
+                                bambu_token: { type: "string", description: "Access token (default: value from env)" }
+                            },
+                            required: ["three_mf_path"]
+                        }
+                    },
+                    {
+                        name: "list_3mf_plate_objects",
+                        description: "List object IDs from a sliced 3MF plate. Use these IDs with skip_objects during a running print.",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                three_mf_path: { type: "string", description: "Path to a sliced 3MF/.gcode.3mf file" },
+                                plate_index: { type: "number", description: "0-based plate index to inspect (default: 0)" }
+                            },
+                            required: ["three_mf_path"]
+                        }
+                    },
                     {
                         name: "extend_stl_base",
                         description: "Extend the base of an STL file by a specified amount",
@@ -644,6 +1409,110 @@ class BambuPrinterMCPServer {
                             required: ["stl_path"]
                         }
                     },
+                    {
+                        name: "list_templates",
+                        description: "List saved slicing templates from the local template registry directory.",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                template_dir: {
+                                    type: "string",
+                                    description: "Optional template directory override. Defaults to BAMBU_TEMPLATE_DIR or the server's configured local template registry."
+                                }
+                            }
+                        }
+                    },
+                    {
+                        name: "save_template",
+                        description: "Copy a 3MF, JSON, or config file into the local template registry and register it under a template name.",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                source_path: {
+                                    type: "string",
+                                    description: "Path to a local .3mf, .json, or .config file to save into the template registry."
+                                },
+                                template_name: {
+                                    type: "string",
+                                    description: "Optional template name. Defaults to the source filename without extension."
+                                },
+                                template_dir: {
+                                    type: "string",
+                                    description: "Optional template directory override. Defaults to BAMBU_TEMPLATE_DIR or the server's configured local template registry."
+                                }
+                            },
+                            required: ["source_path"]
+                        }
+                    },
+                    {
+                        name: "get_slice_settings",
+                        description: "Inspect slicer settings from a saved 3MF template or a JSON/config slicer profile without slicing anything.",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                source_path: {
+                                    type: "string",
+                                    description: "Path to a 3MF template, extracted project_settings.config, or slicer profile JSON."
+                                },
+                                template_name: {
+                                    type: "string",
+                                    description: "Optional named template from the local registry. If provided, resolves source_path automatically."
+                                },
+                                template_dir: {
+                                    type: "string",
+                                    description: "Optional template directory override when resolving template_name."
+                                }
+                            }
+                        }
+                    },
+                    {
+                        name: "slice_with_template",
+                        description: "Slice an STL or 3MF using a named template from the local registry. This is a higher-level wrapper around slice_stl for template-based workflows.",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                stl_path: { type: "string", description: "Path to the STL or 3MF file to slice" },
+                                template_name: { type: "string", description: "Named template from the local registry." },
+                                template_dir: { type: "string", description: "Optional template directory override when resolving template_name." },
+                                bambu_model: {
+                                    type: "string",
+                                    enum: [...VALID_BAMBU_MODELS],
+                                    description: "REQUIRED: Bambu Lab printer model. Ask the user if not known. Using the wrong model can damage the printer."
+                                },
+                                slicer_type: {
+                                    type: "string",
+                                    enum: SLICER_SCHEMA_VALUES,
+                                    description: "Type of slicer to use. Bambu-compatible choices (bambustudio, orcaslicer, orcaslicer-bambulab) export sliced 3MF; aliases such as fulu-orca and orca-studio are accepted."
+                                },
+                                slicer_path: { type: "string", description: "Path to the slicer executable (default: value from env)" },
+                                slicer_profile: { type: "string", description: "Explicit slicer profile/config file. Overrides the named template only when provided in the tool call." },
+                                nozzle_diameter: { type: "string", description: "Nozzle diameter in mm (default: 0.4)" },
+                                bed_type: {
+                                    type: "string",
+                                    enum: ["textured_plate", "cool_plate", "engineering_plate", "hot_plate", "supertack_plate"],
+                                    description: "Bed plate type for slicing (default: textured_plate). SuperTack is accepted only for pre-sliced print jobs until the BambuStudio CLI identifier is verified."
+                                },
+                                use_printer_filaments: { type: "boolean", description: "When true, and no explicit slicer profile or load_filaments override is provided, use the printer's current or first loaded AMS filament as the slicer filament profile." },
+                                host: { type: "string", description: "Hostname or IP of the printer (default: value from env)" },
+                                bambu_serial: { type: "string", description: "Serial number (default: value from env)" },
+                                bambu_token: { type: "string", description: "Access token (default: value from env)" },
+                                load_filaments: { type: "string", description: "Override filament profiles. Semicolon-separated paths to filament JSON configs." },
+                                load_filament_ids: { type: "string", description: "Optional filament-to-object mapping string." },
+                                ensure_on_bed: { type: "boolean", description: "Lift floating models onto the bed." },
+                                arrange: { type: "boolean", description: "Auto-arrange objects on the build plate." },
+                                orient: { type: "boolean", description: "Auto-orient model for optimal printability." },
+                                repetitions: { type: "number", description: "Number of copies to print." },
+                                scale: { type: "number", description: "Uniform scale factor." },
+                                rotate: { type: "number", description: "Z-axis rotation in degrees." },
+                                rotate_x: { type: "number", description: "X-axis rotation in degrees." },
+                                rotate_y: { type: "number", description: "Y-axis rotation in degrees." },
+                                min_save: { type: "boolean", description: "Produce smaller output 3MF." },
+                                skip_modified_gcodes: { type: "boolean", description: "Ignore stale custom gcodes in the 3MF." },
+                                slice_plate: { type: "number", description: "Which plate index to slice. 0 = all plates." }
+                            },
+                            required: ["stl_path", "template_name", "bambu_model"]
+                        }
+                    },
                     {
                         name: "slice_stl",
                         description: "Slice an STL or 3MF file using a slicer to generate printable G-code or sliced 3MF. IMPORTANT: bambu_model must be specified to ensure the slicer generates safe G-code for the correct printer.",
@@ -653,7 +1522,7 @@ class BambuPrinterMCPServer {
                                 stl_path: { type: "string", description: "Path to the STL or 3MF file to slice" },
                                 bambu_model: {
                                     type: "string",
-                                    enum: ["p1s", "p1p", "x1c", "x1e", "a1", "a1mini", "h2d"],
+                                    enum: [...VALID_BAMBU_MODELS],
                                     description: "REQUIRED: Bambu Lab printer model. Ask the user if not known. Using the wrong model can damage the printer."
                                 },
                                 slicer_type: {
@@ -661,10 +1530,19 @@ class BambuPrinterMCPServer {
                                     enum: SLICER_SCHEMA_VALUES,
                                     description: "Type of slicer to use. Bambu-compatible choices (bambustudio, orcaslicer, orcaslicer-bambulab) export sliced 3MF; aliases such as fulu-orca and orca-studio are accepted."
                                 },
-                                slicer_path: { type: "string", description: "Path to the slicer executable (default: value from env or a platform default)" },
+                                slicer_path: { type: "string", description: "Path to the slicer executable (default: value from env)" },
                                 slicer_profile: { type: "string", description: "Path to the slicer profile/config file (optional, overrides bambu_model preset)" },
+                                template_3mf_path: { type: "string", description: "Optional template 3MF whose embedded Bambu slicer settings should be reused when slicing a new STL or 3MF." },
+                                template_name: { type: "string", description: "Optional named template from the local registry. Resolves to template_3mf_path automatically." },
+                                template_dir: { type: "string", description: "Optional template directory override when resolving template_name." },
                                 nozzle_diameter: { type: "string", description: "Nozzle diameter in mm (default: 0.4)" },
-                                uptodate: { type: "boolean", description: "Refresh 3MF preset configs to match the latest Bambu-compatible slicer presets. Use when slicing downloaded or older 3MF files to prevent stale-config failures." },
+                                bed_type: {
+                                    type: "string",
+                                    enum: ["textured_plate", "cool_plate", "engineering_plate", "hot_plate", "supertack_plate"],
+                                    description: "Bed plate type for slicing (default: textured_plate). SuperTack is accepted only for pre-sliced print jobs until the BambuStudio CLI identifier is verified."
+                                },
+                                use_printer_filaments: { type: "boolean", description: "When true, and no explicit slicer profile or load_filaments override is provided, use the printer's current or first loaded AMS filament as the slicer filament profile. Template 3MF process settings can still be used at the same time." },
+                                uptodate: { type: "boolean", description: "Refresh 3MF preset configs to match the latest BambuStudio version. Use when slicing downloaded or older 3MF files to prevent stale-config failures." },
                                 repetitions: { type: "number", description: "Print N identical copies of the model. Each copy gets its own plate placement. Example: 3 prints three copies." },
                                 orient: { type: "boolean", description: "Auto-orient the model for optimal printability (minimize supports, maximize bed adhesion). Recommended for raw STL imports that lack a pre-set orientation." },
                                 arrange: { type: "boolean", description: "Auto-arrange all objects on the build plate with optimal spacing. Recommended when importing STLs or adding multiple objects. Set false to preserve existing plate layout." },
@@ -672,7 +1550,7 @@ class BambuPrinterMCPServer {
                                 clone_objects: { type: "string", description: "Duplicate specific objects on the plate. Comma-separated clone counts per object index, e.g. '1,3,1,10' clones object 0 once, object 1 three times, etc." },
                                 skip_objects: { type: "string", description: "Skip specific objects during slicing by index. Comma-separated, e.g. '3,5,10'. Useful for multi-object 3MFs where you only want to print some parts." },
                                 load_filaments: { type: "string", description: "Override filament profiles. Semicolon-separated paths to filament JSON configs, e.g. 'pla_basic.json;petg_cf.json'." },
-                                filament_profile: { type: "string", description: "Compatibility alias for load_filaments. Semicolon-separated Orca/Bambu filament profile JSON paths; flat self-contained profiles are safest because Orca does not resolve every inherited system filament setting from arbitrary file paths." },
+                                filament_profile: { type: "string", description: "Compatibility alias for load_filaments. Semicolon-separated Orca/Bambu filament profile JSON paths." },
                                 load_filament_ids: { type: "string", description: "Map filaments to objects/parts. Comma-separated IDs matching load_filaments order, e.g. '1,2,3,1' assigns filament 1 to objects 0 and 3." },
                                 enable_timelapse: { type: "boolean", description: "Insert timelapse parking moves into gcode. The toolhead parks at a fixed position each layer for camera capture. Adds ~10% print time." },
                                 allow_mix_temp: { type: "boolean", description: "Allow filaments with different temperature requirements on the same plate. Required for multi-material prints mixing e.g. PLA and PETG." },
@@ -741,7 +1619,7 @@ class BambuPrinterMCPServer {
                                 three_mf_path: { type: "string", description: "Path to the 3MF file to print; unsliced 3MFs are auto-sliced before sending." },
                                 bambu_model: {
                                     type: "string",
-                                    enum: ["p1s", "p1p", "x1c", "x1e", "a1", "a1mini", "h2d"],
+                                    enum: [...VALID_BAMBU_MODELS],
                                     description: "REQUIRED: Bambu Lab printer model. Ask the user if not known. Using the wrong model can damage the printer."
                                 },
                                 connection_type: { type: "string", enum: ["cloud", "lan"], description: "BambuNetwork connection type to put in FULU PrintParams; cloud uses restored internet printing, lan uses local bridge printing." },
@@ -753,7 +1631,7 @@ class BambuPrinterMCPServer {
                                 bambu_token: { type: "string", description: "Printer access code/password for LAN/local bridge methods." },
                                 username: { type: "string", description: "Printer username for LAN/local bridge methods; defaults to bblp." },
                                 password: { type: "string", description: "Printer password/access code override for LAN/local bridge methods." },
-                                bed_type: { type: "string", enum: ["textured_plate", "cool_plate", "engineering_plate", "hot_plate"], description: "Bed plate type currently installed (default: textured_plate)." },
+                                bed_type: { type: "string", enum: ["textured_plate", "cool_plate", "engineering_plate", "hot_plate", "supertack_plate"], description: "Bed plate type currently installed (default: textured_plate)." },
                                 plate_index: { type: "number", description: "Zero-based plate index to print from the sliced 3MF; converted to FULU's one-based PrintParams plate_index." },
                                 project_name: { type: "string", description: "Optional project name sent in FULU PrintParams; defaults to the 3MF filename without extension." },
                                 preset_name: { type: "string", description: "Optional preset name sent in FULU PrintParams; defaults to project plus one-based plate index." },
@@ -770,6 +1648,7 @@ class BambuPrinterMCPServer {
                                 nozzle_diameter: { type: "string", description: "Nozzle diameter in mm for auto-slicing (default: 0.4)." },
                                 use_ams: { type: "boolean", description: "Whether to use the AMS; defaults to auto-detect from the 3MF mapping." },
                                 ams_mapping: { type: "array", description: "AMS slot mapping array used by both local MCP printing and FULU PrintParams.", items: { type: "number" } },
+                                ams_slots: { type: "array", description: "Per-used-filament AMS slot list, matching the local LAN print path.", items: { type: "number" } },
                                 ams_mapping_bridge: { type: "string", description: "Raw JSON string override for FULU PrintParams ams_mapping when the automatic array is not enough." },
                                 ams_mapping2: { type: "string", description: "Raw JSON string for FULU PrintParams ams_mapping2, matching OrcaSlicer-bambulab's v1 AMS mapping field." },
                                 ams_mapping_info: { type: "string", description: "Raw JSON string for FULU PrintParams ams_mapping_info, matching OrcaSlicer-bambulab's detailed AMS mapping field." },
@@ -791,38 +1670,72 @@ class BambuPrinterMCPServer {
                         }
                     },
                     {
-                        name: "upload_gcode",
-                        description: "Upload a G-code file to the Bambu Lab printer",
+                        name: "camera_snapshot",
+                        description: "Capture a single JPEG frame from the printer's chamber camera. A1/P1 use TCP-on-6000; X1/P2S/H2 use RTSP via ffmpeg. Returns JPEG as base64; pass save_path to also write the bytes to disk.",
                         inputSchema: {
                             type: "object",
                             properties: {
-                                filename: { type: "string", description: "Name for the file on the printer" },
-                                gcode: { type: "string", description: "G-code content to upload, or a readable local .gcode path. For large files, prefer gcode_path." },
-                                gcode_path: { type: "string", description: "Local path to a .gcode file to upload. This avoids sending large G-code bodies through the MCP request." },
+                                save_path: { type: "string", description: "Optional absolute path to write the JPEG to disk. If omitted, only the base64 payload is returned." },
+                                timeout_ms: { type: "number", description: "Max ms to wait for a full frame (default 8000). Camera may take a few seconds on cold start." },
+                                bambu_model: { type: "string", description: "Printer model. Used to route to the correct protocol or fail fast on unsupported models. Defaults to BAMBU_MODEL." },
+                                experimental: { type: "boolean", description: "Deprecated and ignored. Earlier this flag let callers probe H2 series via the A1/P1 TCP-on-6000 path; live testing on an H2S confirmed H2 uses RTSP instead, so the flag has no effect now." },
+                                ffmpeg_path: { type: "string", description: "Override path to the ffmpeg binary used by the RTSP path. Defaults to ffmpeg via $PATH. Required only for the RTSP transport (X1, P2S, H2 series)." },
                                 host: { type: "string", description: "Hostname or IP of the printer (default: value from env)" },
                                 bambu_serial: { type: "string", description: "Serial number (default: value from env)" },
                                 bambu_token: { type: "string", description: "Access token (default: value from env)" }
-                            },
-                            required: ["filename"],
-                            anyOf: [
-                                { required: ["gcode"] },
-                                { required: ["gcode_path"] }
-                            ]
+                            }
                         }
                     },
                     {
-                        name: "upload_file",
-                        description: "Upload a local file to the Bambu Lab printer",
+                        name: "delete_printer_file",
+                        description: "Delete a file from the Bambu Lab printer's SD card via FTPS. Destructive: requires confirm:true. Restricted to cache/, timelapse/, and logs/ directories. Path traversal segments (..) are rejected.",
                         inputSchema: {
                             type: "object",
                             properties: {
-                                file_path: { type: "string", description: "Local path to the file to upload" },
-                                filename: { type: "string", description: "Name for the file on the printer" },
-                                print: { type: "boolean", description: "Start printing after upload (default: false)" },
-                                bambu_model: {
+                                filename: {
                                     type: "string",
-                                    enum: ["p1s", "p1p", "x1c", "x1e", "a1", "a1mini", "h2d"],
-                                    description: "Required when print is true. Bambu Lab printer model used as a safety confirmation before starting the uploaded file."
+                                    description: "File to delete. Bare names default to cache/<name>; pass a relative path like timelapse/foo.mp4 to target other allowed directories."
+                                },
+                                confirm: {
+                                    type: "boolean",
+                                    description: "Must be true to actually delete. When false or omitted the call returns without sending an FTP request."
+                                },
+                                host: { type: "string", description: "Hostname or IP of the printer (default: value from env)" },
+                                bambu_serial: { type: "string", description: "Serial number (default: value from env)" },
+                                bambu_token: { type: "string", description: "Access token (default: value from env)" }
+                            },
+                            required: ["filename"]
+                        }
+                    },
+                    {
+                        name: "upload_gcode",
+                        description: "Upload a G-code file to the Bambu Lab printer",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                filename: { type: "string", description: "Name for the file on the printer" },
+                                gcode: { type: "string", description: "G-code content to upload, or a readable local .gcode path. Required unless gcode_path is provided. For large files, prefer gcode_path." },
+                                gcode_path: { type: "string", description: "Local path to a .gcode file to upload. Required unless gcode is provided. This avoids sending large G-code bodies through the MCP request." },
+                                host: { type: "string", description: "Hostname or IP of the printer (default: value from env)" },
+                                bambu_serial: { type: "string", description: "Serial number (default: value from env)" },
+                                bambu_token: { type: "string", description: "Access token (default: value from env)" }
+                            },
+                            required: ["filename"]
+                        }
+                    },
+                    {
+                        name: "upload_file",
+                        description: "Upload a local file to the Bambu Lab printer",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                file_path: { type: "string", description: "Local path to the file to upload" },
+                                filename: { type: "string", description: "Name for the file on the printer" },
+                                print: { type: "boolean", description: "Start printing after upload (default: false)" },
+                                bambu_model: {
+                                    type: "string",
+                                    enum: [...VALID_BAMBU_MODELS],
+                                    description: "Required when print is true. Bambu Lab printer model used as a safety confirmation before starting the uploaded file."
                                 },
                                 host: { type: "string", description: "Hostname or IP of the printer (default: value from env)" },
                                 bambu_serial: { type: "string", description: "Serial number (default: value from env)" },
@@ -840,7 +1753,7 @@ class BambuPrinterMCPServer {
                                 filename: { type: "string", description: "Name of the file to print" },
                                 bambu_model: {
                                     type: "string",
-                                    enum: ["p1s", "p1p", "x1c", "x1e", "a1", "a1mini", "h2d"],
+                                    enum: [...VALID_BAMBU_MODELS],
                                     description: "REQUIRED: Bambu Lab printer model. Ask the user if not known. Starting G-code for the wrong model can damage the printer."
                                 },
                                 host: { type: "string", description: "Hostname or IP of the printer (default: value from env)" },
@@ -859,7 +1772,7 @@ class BambuPrinterMCPServer {
                                 filename: { type: "string", description: "Name of the file to print" },
                                 bambu_model: {
                                     type: "string",
-                                    enum: ["p1s", "p1p", "x1c", "x1e", "a1", "a1mini", "h2d"],
+                                    enum: [...VALID_BAMBU_MODELS],
                                     description: "REQUIRED: Bambu Lab printer model. Ask the user if not known. Starting G-code for the wrong model can damage the printer."
                                 },
                                 host: { type: "string", description: "Hostname or IP of the printer (default: value from env)" },
@@ -881,6 +1794,93 @@ class BambuPrinterMCPServer {
                             }
                         }
                     },
+                    {
+                        name: "pause_print",
+                        description: "Pause the current print job on the Bambu Lab printer (resumable via resume_print)",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                host: { type: "string", description: "Hostname or IP of the printer (default: value from env)" },
+                                bambu_serial: { type: "string", description: "Serial number (default: value from env)" },
+                                bambu_token: { type: "string", description: "Access token (default: value from env)" }
+                            }
+                        }
+                    },
+                    {
+                        name: "resume_print",
+                        description: "Resume a paused print job on the Bambu Lab printer",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                host: { type: "string", description: "Hostname or IP of the printer (default: value from env)" },
+                                bambu_serial: { type: "string", description: "Serial number (default: value from env)" },
+                                bambu_token: { type: "string", description: "Access token (default: value from env)" }
+                            }
+                        }
+                    },
+                    {
+                        name: "clear_hms_errors",
+                        description: "Clear HMS or print error state on the Bambu Lab printer using the clean_print_error MQTT command.",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                host: { type: "string", description: "Hostname or IP of the printer (default: value from env)" },
+                                bambu_serial: { type: "string", description: "Serial number (default: value from env)" },
+                                bambu_token: { type: "string", description: "Access token (default: value from env)" }
+                            }
+                        }
+                    },
+                    {
+                        name: "set_print_speed",
+                        description: "Set the active print speed mode: silent, standard, sport, or ludicrous.",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                mode: {
+                                    type: "string",
+                                    enum: ["silent", "standard", "sport", "ludicrous", "1", "2", "3", "4"],
+                                    description: "Speed mode to apply: silent/1, standard/2, sport/3, or ludicrous/4"
+                                },
+                                host: { type: "string", description: "Hostname or IP of the printer (default: value from env)" },
+                                bambu_serial: { type: "string", description: "Serial number (default: value from env)" },
+                                bambu_token: { type: "string", description: "Access token (default: value from env)" }
+                            },
+                            required: ["mode"]
+                        }
+                    },
+                    {
+                        name: "set_airduct_mode",
+                        description: "Set H2/P2 airduct mode to cooling or heating.",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                mode: {
+                                    type: "string",
+                                    enum: ["cooling", "heating"],
+                                    description: "Airduct mode to apply"
+                                },
+                                host: { type: "string", description: "Hostname or IP of the printer (default: value from env)" },
+                                bambu_serial: { type: "string", description: "Serial number (default: value from env)" },
+                                bambu_token: { type: "string", description: "Access token (default: value from env)" }
+                            },
+                            required: ["mode"]
+                        }
+                    },
+                    {
+                        name: "reread_ams_rfid",
+                        description: "Trigger a Bambu AMS RFID re-read for one AMS slot. This can move AMS filament; use only when the printer is idle and unloaded.",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                ams_id: { type: "number", description: "AMS unit index from 0 to 3" },
+                                slot_id: { type: "number", description: "Slot index within that AMS, from 0 to 3" },
+                                host: { type: "string", description: "Hostname or IP of the printer (default: value from env)" },
+                                bambu_serial: { type: "string", description: "Serial number (default: value from env)" },
+                                bambu_token: { type: "string", description: "Access token (default: value from env)" }
+                            },
+                            required: ["ams_id", "slot_id"]
+                        }
+                    },
                     {
                         name: "set_temperature",
                         description: "Set the temperature of a printer component (bed, nozzle)",
@@ -896,6 +1896,86 @@ class BambuPrinterMCPServer {
                             required: ["component", "temperature"]
                         }
                     },
+                    {
+                        name: "set_fan_speed",
+                        description: "Set a Bambu printer fan speed percentage using the printer's MQTT fan command",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                fan: {
+                                    type: "string",
+                                    description: "Fan to control: part, auxiliary, chamber, 1, 2, or 3"
+                                },
+                                speed: { type: "number", description: "Fan speed percentage from 0 to 100" },
+                                host: { type: "string", description: "Hostname or IP of the printer (default: value from env)" },
+                                bambu_serial: { type: "string", description: "Serial number (default: value from env)" },
+                                bambu_token: { type: "string", description: "Access token (default: value from env)" }
+                            },
+                            required: ["fan", "speed"]
+                        }
+                    },
+                    {
+                        name: "set_light",
+                        description: "Set a Bambu printer light node mode using the printer's MQTT LED command",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                light: {
+                                    type: "string",
+                                    description: "Light node to control, for example chamber_light"
+                                },
+                                mode: {
+                                    type: "string",
+                                    enum: ["on", "off", "flashing"],
+                                    description: "Light mode to apply"
+                                },
+                                host: { type: "string", description: "Hostname or IP of the printer (default: value from env)" },
+                                bambu_serial: { type: "string", description: "Serial number (default: value from env)" },
+                                bambu_token: { type: "string", description: "Access token (default: value from env)" }
+                            },
+                            required: ["light", "mode"]
+                        }
+                    },
+                    {
+                        name: "skip_objects",
+                        description: "Skip specific object IDs during a running multi-object print using the printer's MQTT skip_objects command",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                object_ids: {
+                                    type: "array",
+                                    description: "Object IDs to skip. Use list_3mf_plate_objects on the sliced 3MF to find IDs.",
+                                    items: { type: "number" }
+                                },
+                                host: { type: "string", description: "Hostname or IP of the printer (default: value from env)" },
+                                bambu_serial: { type: "string", description: "Serial number (default: value from env)" },
+                                bambu_token: { type: "string", description: "Access token (default: value from env)" }
+                            },
+                            required: ["object_ids"]
+                        }
+                    },
+                    {
+                        name: "set_ams_drying",
+                        description: "Start or stop the AMS filament drying cycle. Available on AMS units with heating capability (AMS Pro / AMS-HT). Sends an ams_control MQTT command to the printer.",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                action: {
+                                    type: "string",
+                                    enum: ["start", "stop"],
+                                    description: "Whether to start or stop the drying cycle"
+                                },
+                                ams_id: {
+                                    type: "number",
+                                    description: "AMS unit index from 0 to 3"
+                                },
+                                host: { type: "string", description: "Hostname or IP of the printer (default: value from env)" },
+                                bambu_serial: { type: "string", description: "Serial number (default: value from env)" },
+                                bambu_token: { type: "string", description: "Access token (default: value from env)" }
+                            },
+                            required: ["action", "ams_id"]
+                        }
+                    },
                     {
                         name: "print_3mf",
                         description: "Print a 3MF file on a Bambu Lab printer. Auto-slices if the 3MF has no gcode. IMPORTANT: bambu_model must be specified to ensure safe printer operation.",
@@ -905,13 +1985,13 @@ class BambuPrinterMCPServer {
                                 three_mf_path: { type: "string", description: "Path to the 3MF file to print" },
                                 bambu_model: {
                                     type: "string",
-                                    enum: ["p1s", "p1p", "x1c", "x1e", "a1", "a1mini", "h2d"],
+                                    enum: [...VALID_BAMBU_MODELS],
                                     description: "REQUIRED: Bambu Lab printer model. Ask the user if not known. Using the wrong model can damage the printer."
                                 },
                                 connection_mode: {
                                     type: "string",
                                     enum: ["lan_mqtt_ftps", "bambu_network"],
-                                    description: "Print path to use: lan_mqtt_ftps uses this MCP's direct local MQTT/FTPS path; bambu_network uses FULU OrcaSlicer-bambulab's restored BambuNetwork bridge."
+                                    description: "Print path to use: lan_mqtt_ftps uses this MCP's direct local MQTT/FTPS path; bambu_network uses the restored FULU BambuNetwork bridge."
                                 },
                                 connection_type: { type: "string", enum: ["cloud", "lan"], description: "BambuNetwork connection type when connection_mode is bambu_network; cloud uses restored internet printing, lan uses local bridge printing." },
                                 bambu_network_method: { type: "string", enum: BAMBU_NETWORK_PRINT_METHODS, description: "FULU print method when connection_mode is bambu_network; defaults to start_print for cloud and start_local_print for lan." },
@@ -923,36 +2003,79 @@ class BambuPrinterMCPServer {
                                 user_info: { type: "string", description: "Optional BambuNetwork user_info JSON string passed to net.change_user for the FULU bridge." },
                                 bed_type: {
                                     type: "string",
-                                    enum: ["textured_plate", "cool_plate", "engineering_plate", "hot_plate"],
+                                    enum: ["textured_plate", "cool_plate", "engineering_plate", "hot_plate", "supertack_plate"],
                                     description: "Bed plate type currently installed (default: textured_plate)"
                                 },
-                                plate_index: { type: "number", description: "Zero-based plate index to print from the sliced 3MF (default: 0)" },
                                 host: { type: "string", description: "Hostname or IP of the printer (default: value from env)" },
                                 bambu_serial: { type: "string", description: "Serial number (default: value from env)" },
                                 bambu_token: { type: "string", description: "Access token (default: value from env)" },
+                                plate_index: { type: "number", description: "Zero-based plate index to print from the sliced 3MF (default: 0)" },
                                 slicer_type: {
                                     type: "string",
                                     enum: SLICER_SCHEMA_VALUES,
-                                    description: "Slicer to use only if auto-slicing an unsliced 3MF. Use orcaslicer-bambulab for FULU's OrcaSlicer-bambulab fork; aliases such as fulu-orca and orca-studio are accepted."
+                                    description: "Slicer to use only if auto-slicing an unsliced 3MF. Bambu-compatible slicer aliases such as fulu-orca and orca-studio are accepted."
                                 },
                                 slicer_path: { type: "string", description: "Path to the slicer executable for auto-slicing (default: value from env or a platform default)" },
-                                slicer_profile: { type: "string", description: "Path to an optional slicer profile/config file for auto-slicing" },
                                 use_ams: { type: "boolean", description: "Whether to use the AMS (default: auto-detect from 3MF)" },
                                 ams_mapping: {
                                     type: "array",
-                                    description: "AMS slot mapping array, e.g. [0, 2] maps filaments to AMS slots 0 and 2",
+                                    description: "Project-level AMS mapping array. Position = project filament index, value = absolute AMS tray (0-3=AMS 0, 4-7=AMS 1, 8-11=AMS 2, 128+=AMS-HT, 254=external, -1=unused). Prefer ams_slots unless you know the project-level layout.",
                                     items: { type: "number" }
                                 },
+                                ams_slots: {
+                                    type: "array",
+                                    description: "Preferred AMS input: one absolute tray index per USED filament in plate order, e.g. [1] for a single-filament print pulling from AMS 0 slot 1. Expanded to project-level ams_mapping automatically from the 3MF's plate_N.json and gcode header.",
+                                    items: { type: "number" }
+                                },
+                                auto_match_ams: {
+                                    type: "boolean",
+                                    description: "When true, match the sliced 3MF's tray_info_idx requirements against live AMS inventory and use the resulting ams_slots. Ignored when ams_mapping or ams_slots is provided."
+                                },
                                 bed_leveling: { type: "boolean", description: "Enable auto bed leveling (default: true)" },
                                 flow_calibration: { type: "boolean", description: "Enable flow calibration (default: true)" },
                                 vibration_calibration: { type: "boolean", description: "Enable vibration calibration (default: true)" },
-                                layer_inspect: { type: "boolean", description: "Enable first-layer inspection where supported (default: printer/profile behavior)" },
                                 timelapse: { type: "boolean", description: "Enable timelapse recording (default: false)" },
+                                slicer_profile: { type: "string", description: "Path to the slicer profile/config file for auto-slicing (optional)." },
+                                template_3mf_path: { type: "string", description: "Optional template 3MF whose embedded Bambu slicer settings should be reused when auto-slicing this print job." },
+                                template_name: { type: "string", description: "Optional named template from the local registry. Resolves to template_3mf_path automatically." },
+                                template_dir: { type: "string", description: "Optional template directory override when resolving template_name." },
                                 nozzle_diameter: { type: "string", description: "Nozzle diameter in mm for auto-slicing (default: 0.4)" }
                             },
                             required: ["three_mf_path", "bambu_model"]
                         }
                     },
+                    {
+                        name: "print_collar_charm",
+                        description: "Print a prepared two-part dog collar charm project using the fixed tray policy: inner/smaller object -> black on AMS 1 slot 1, outer/larger object -> white on AMS 2 slot 1.",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                source_path: { type: "string", description: "Path to a prepared collar charm .3mf project or sliced 3MF. Required unless template_name is provided." },
+                                template_name: { type: "string", description: "Named collar charm template from the local registry. Required unless source_path is provided; resolves source_path automatically." },
+                                template_dir: { type: "string", description: "Optional template directory override when resolving template_name." },
+                                bambu_model: {
+                                    type: "string",
+                                    enum: [...VALID_BAMBU_MODELS],
+                                    description: "REQUIRED: Bambu Lab printer model. H2D, H2S, and H2C are the primary intended paths."
+                                },
+                                host: { type: "string", description: "Hostname or IP of the printer (default: value from env)" },
+                                bambu_serial: { type: "string", description: "Serial number (default: value from env)" },
+                                bambu_token: { type: "string", description: "Access token (default: value from env)" },
+                                bed_type: {
+                                    type: "string",
+                                    enum: ["textured_plate", "cool_plate", "engineering_plate", "hot_plate", "supertack_plate"],
+                                    description: "Bed plate type currently installed (default: textured_plate)"
+                                },
+                                bed_leveling: { type: "boolean", description: "Enable auto bed leveling (default: true)" },
+                                flow_calibration: { type: "boolean", description: "Enable flow calibration (default: true)" },
+                                vibration_calibration: { type: "boolean", description: "Enable vibration calibration (default: true)" },
+                                timelapse: { type: "boolean", description: "Enable timelapse recording (default: false)" },
+                                slicer_profile: { type: "string", description: "Path to the slicer profile/config file for auto-slicing (optional)." },
+                                nozzle_diameter: { type: "string", description: "Nozzle diameter in mm for auto-slicing (default: 0.4)" }
+                            },
+                            required: ["bambu_model"]
+                        }
+                    },
                     {
                         name: "merge_vertices",
                         description: "Merge vertices in an STL file closer than the specified tolerance",
@@ -1013,12 +2136,60 @@ class BambuPrinterMCPServer {
             const host = String(args?.host || DEFAULT_HOST);
             const bambuSerial = String(args?.bambu_serial || DEFAULT_BAMBU_SERIAL);
             const bambuToken = String(args?.bambu_token || DEFAULT_BAMBU_TOKEN);
+            const requestedTemplateDir = typeof args?.template_dir === "string" && args.template_dir.trim().length > 0
+                ? String(args.template_dir)
+                : undefined;
+            const requestedTemplateName = typeof args?.template_name === "string" ? String(args.template_name) : undefined;
+            const resolveTemplatePathFromName = (sourceTypes) => this.resolveTemplatePath(requestedTemplateName, requestedTemplateDir, sourceTypes);
+            const explicitTemplatePath = String(args?.template_3mf_path || DEFAULT_TEMPLATE_3MF_PATH);
             try {
                 let result;
                 switch (name) {
                     case "get_printer_status":
                         result = await this.bambu.getStatus(host, bambuSerial, bambuToken);
                         break;
+                    case "get_printer_filaments": {
+                        const requestedModel = (String(args?.bambu_model ?? DEFAULT_BAMBU_MODEL ?? "")).trim().toLowerCase();
+                        const normalizedModel = requestedModel ? validateBambuModel(requestedModel) : undefined;
+                        const nozzleDiam = String(args?.nozzle_diameter || DEFAULT_NOZZLE_DIAMETER);
+                        result = await this.getResolvedPrinterFilamentInventory(host, bambuSerial, bambuToken, normalizedModel, nozzleDiam);
+                        break;
+                    }
+                    case "resolve_3mf_ams_slots": {
+                        if (!args?.three_mf_path) {
+                            throw new Error("Missing required parameter: three_mf_path");
+                        }
+                        const requestedModel = (String(args?.bambu_model ?? DEFAULT_BAMBU_MODEL ?? "")).trim().toLowerCase();
+                        const normalizedModel = requestedModel ? validateBambuModel(requestedModel) : undefined;
+                        const nozzleDiam = String(args?.nozzle_diameter || DEFAULT_NOZZLE_DIAMETER);
+                        const requirements = await analyze3MFAmsRequirements(String(args.three_mf_path), args?.plate_index !== undefined ? Number(args.plate_index) : 0);
+                        const inventory = await this.getResolvedPrinterFilamentInventory(host, bambuSerial, bambuToken, normalizedModel, nozzleDiam);
+                        const resolved = resolveAmsSlotsFromRequirements(requirements, inventory);
+                        result = {
+                            status: resolved.missing.length === 0 ? "matched" : "missing",
+                            requirements,
+                            ams_slots: resolved.ams_slots,
+                            matches: resolved.matches,
+                            missing: resolved.missing,
+                        };
+                        break;
+                    }
+                    case "list_3mf_plate_objects": {
+                        if (!args?.three_mf_path) {
+                            throw new Error("Missing required parameter: three_mf_path");
+                        }
+                        result = await analyze3MFPlateObjects(String(args.three_mf_path), args?.plate_index !== undefined ? Number(args.plate_index) : 0);
+                        break;
+                    }
+                    case "list_templates":
+                        result = this.listTemplateRegistry(requestedTemplateDir);
+                        break;
+                    case "save_template":
+                        if (!args?.source_path) {
+                            throw new Error("Missing required parameter: source_path");
+                        }
+                        result = this.saveTemplate(String(args.source_path), typeof args?.template_name === "string" ? String(args.template_name) : undefined, requestedTemplateDir);
+                        break;
                     case "list_printer_files":
                         result = await this.bambu.getFiles(host, bambuSerial, bambuToken);
                         break;
@@ -1055,6 +2226,23 @@ class BambuPrinterMCPServer {
                         result = await this.print3mfViaBambuNetwork(args, host, bambuSerial, bambuToken);
                         break;
                     }
+                    case "camera_snapshot": {
+                        const snapshotModel = args?.bambu_model ?? process.env.BAMBU_MODEL ?? process.env.BAMBU_PRINTER_MODEL;
+                        result = await this.bambu.cameraSnapshot(host, bambuSerial, bambuToken, {
+                            savePath: args?.save_path ? String(args.save_path) : undefined,
+                            timeoutMs: args?.timeout_ms !== undefined ? Number(args.timeout_ms) : undefined,
+                            bambuModel: snapshotModel ? String(snapshotModel) : undefined,
+                            experimental: Boolean(args?.experimental),
+                            ffmpegPath: args?.ffmpeg_path ? String(args.ffmpeg_path) : undefined,
+                        });
+                        break;
+                    }
+                    case "delete_printer_file":
+                        if (!args?.filename) {
+                            throw new Error("Missing required parameter: filename");
+                        }
+                        result = await this.bambu.deleteFile(host, bambuSerial, bambuToken, String(args.filename), args.confirm);
+                        break;
                     case "upload_gcode": {
                         if (!args?.filename) {
                             throw new Error("Missing required parameter: filename");
@@ -1090,12 +2278,63 @@ class BambuPrinterMCPServer {
                     case "cancel_print":
                         result = await this.bambu.cancelJob(host, bambuSerial, bambuToken);
                         break;
+                    case "pause_print":
+                        result = await this.bambu.pauseJob(host, bambuSerial, bambuToken);
+                        break;
+                    case "resume_print":
+                        result = await this.bambu.resumeJob(host, bambuSerial, bambuToken);
+                        break;
+                    case "clear_hms_errors":
+                        result = await this.bambu.clearHmsErrors(host, bambuSerial, bambuToken);
+                        break;
+                    case "set_print_speed":
+                        if (!args?.mode) {
+                            throw new Error("Missing required parameter: mode");
+                        }
+                        result = await this.bambu.setPrintSpeed(host, bambuSerial, bambuToken, String(args.mode));
+                        break;
+                    case "set_airduct_mode":
+                        if (!args?.mode) {
+                            throw new Error("Missing required parameter: mode");
+                        }
+                        result = await this.bambu.setAirductMode(host, bambuSerial, bambuToken, String(args.mode));
+                        break;
+                    case "reread_ams_rfid":
+                        if (args?.ams_id === undefined || args?.slot_id === undefined) {
+                            throw new Error("Missing required parameters: ams_id and slot_id");
+                        }
+                        result = await this.bambu.rereadAmsRfid(host, bambuSerial, bambuToken, Number(args.ams_id), Number(args.slot_id));
+                        break;
                     case "set_temperature":
                         if (!args?.component || args?.temperature === undefined) {
                             throw new Error("Missing required parameters: component and temperature");
                         }
                         result = await this.bambu.setTemperature(host, bambuSerial, bambuToken, String(args.component), Number(args.temperature));
                         break;
+                    case "set_fan_speed":
+                        if (!args?.fan || args?.speed === undefined) {
+                            throw new Error("Missing required parameters: fan and speed");
+                        }
+                        result = await this.bambu.setFanSpeed(host, bambuSerial, bambuToken, String(args.fan), Number(args.speed));
+                        break;
+                    case "set_light":
+                        if (!args?.light || !args?.mode) {
+                            throw new Error("Missing required parameters: light and mode");
+                        }
+                        result = await this.bambu.setLight(host, bambuSerial, bambuToken, String(args.light), String(args.mode));
+                        break;
+                    case "skip_objects":
+                        if (!Array.isArray(args?.object_ids)) {
+                            throw new Error("Missing required parameter: object_ids");
+                        }
+                        result = await this.bambu.skipObjects(host, bambuSerial, bambuToken, args.object_ids.map((id) => Number(id)));
+                        break;
+                    case "set_ams_drying":
+                        if (!args?.action || args?.ams_id === undefined) {
+                            throw new Error("Missing required parameters: action and ams_id");
+                        }
+                        result = await this.bambu.setAmsDrying(host, bambuSerial, bambuToken, String(args.action), Number(args.ams_id));
+                        break;
                     case "extend_stl_base":
                         if (!args?.stl_path || args?.extension_height === undefined) {
                             throw new Error("Missing required parameters: stl_path and extension_height");
@@ -1128,6 +2367,91 @@ class BambuPrinterMCPServer {
                         }
                         result = await this.stlManipulator.getSTLInfo(String(args.stl_path));
                         break;
+                    case "get_slice_settings":
+                        if (!args?.source_path && !args?.template_name) {
+                            throw new Error("Missing required parameter: source_path or template_name");
+                        }
+                        result = await this.inspectSliceSettings(String(args?.source_path || resolveTemplatePathFromName(["3mf", "json", "config"])));
+                        break;
+                    case "slice_with_template": {
+                        if (!args?.stl_path) {
+                            throw new Error("Missing required parameter: stl_path");
+                        }
+                        if (!args?.template_name) {
+                            throw new Error("Missing required parameter: template_name");
+                        }
+                        const { slicerType, slicerPath, slicerProfile } = resolveSlicerConfig(args);
+                        const sliceModel = await this.resolveBambuModel(args?.bambu_model);
+                        const nozzleDiam = String(args?.nozzle_diameter || DEFAULT_NOZZLE_DIAMETER);
+                        const activeSlicerProfile = await resolveTemplateFirstSlicerProfilePath(args, slicerProfile || undefined, resolveTemplatePathFromName(["json", "config", "3mf"]) || explicitTemplatePath || undefined, TEMP_DIR);
+                        const explicitSlicerProfile = hasExplicitSlicerProfile(args);
+                        const printerPreset = BAMBU_MODEL_PRESETS[sliceModel]?.(nozzleDiam);
+                        const sliceBambuOptions = {};
+                        if (args?.uptodate !== undefined)
+                            sliceBambuOptions.uptodate = Boolean(args.uptodate);
+                        if (args?.repetitions !== undefined)
+                            sliceBambuOptions.repetitions = Number(args.repetitions);
+                        if (args?.orient !== undefined)
+                            sliceBambuOptions.orient = Boolean(args.orient);
+                        if (args?.arrange !== undefined)
+                            sliceBambuOptions.arrange = Boolean(args.arrange);
+                        if (args?.ensure_on_bed !== undefined)
+                            sliceBambuOptions.ensureOnBed = Boolean(args.ensure_on_bed);
+                        if (args?.clone_objects !== undefined)
+                            sliceBambuOptions.cloneObjects = String(args.clone_objects);
+                        if (args?.skip_objects !== undefined)
+                            sliceBambuOptions.skipObjects = String(args.skip_objects);
+                        if (args?.load_filaments !== undefined &&
+                            args?.filament_profile !== undefined &&
+                            String(args.load_filaments) !== String(args.filament_profile)) {
+                            throw new Error("Provide either load_filaments or filament_profile, not conflicting values.");
+                        }
+                        if (args?.load_filaments !== undefined) {
+                            sliceBambuOptions.loadFilaments = String(args.load_filaments);
+                        }
+                        else if (args?.filament_profile !== undefined) {
+                            sliceBambuOptions.loadFilaments = String(args.filament_profile);
+                        }
+                        if (args?.load_filament_ids !== undefined)
+                            sliceBambuOptions.loadFilamentIds = String(args.load_filament_ids);
+                        sliceBambuOptions.bedType = resolveBambuStudioCliBedType(args?.bed_type);
+                        if (args?.enable_timelapse !== undefined)
+                            sliceBambuOptions.enableTimelapse = Boolean(args.enable_timelapse);
+                        if (args?.allow_mix_temp !== undefined)
+                            sliceBambuOptions.allowMixTemp = Boolean(args.allow_mix_temp);
+                        if (args?.scale !== undefined)
+                            sliceBambuOptions.scale = Number(args.scale);
+                        if (args?.rotate !== undefined)
+                            sliceBambuOptions.rotate = Number(args.rotate);
+                        if (args?.rotate_x !== undefined)
+                            sliceBambuOptions.rotateX = Number(args.rotate_x);
+                        if (args?.rotate_y !== undefined)
+                            sliceBambuOptions.rotateY = Number(args.rotate_y);
+                        if (args?.min_save !== undefined)
+                            sliceBambuOptions.minSave = Boolean(args.min_save);
+                        if (args?.skip_modified_gcodes !== undefined)
+                            sliceBambuOptions.skipModifiedGcodes = Boolean(args.skip_modified_gcodes);
+                        if (args?.slice_plate !== undefined)
+                            sliceBambuOptions.slicePlate = Number(args.slice_plate);
+                        const usePrinterFilaments = args?.use_printer_filaments !== undefined ? Boolean(args.use_printer_filaments) : true;
+                        if (usePrinterFilaments &&
+                            !explicitSlicerProfile &&
+                            !sliceBambuOptions.loadFilaments &&
+                            bambuSerial &&
+                            bambuToken) {
+                            try {
+                                const liveFilaments = await this.getResolvedPrinterFilamentInventory(host, bambuSerial, bambuToken, sliceModel, nozzleDiam);
+                                if (liveFilaments.recommended?.load_filaments) {
+                                    sliceBambuOptions.loadFilaments = liveFilaments.recommended.load_filaments;
+                                }
+                            }
+                            catch (filamentError) {
+                                console.warn("Could not resolve live printer filaments for slicing:", filamentError);
+                            }
+                        }
+                        result = await this.stlManipulator.sliceSTL(String(args.stl_path), slicerType, slicerPath, activeSlicerProfile, undefined, printerPreset, sliceBambuOptions);
+                        break;
+                    }
                     case "slice_stl": {
                         if (!args?.stl_path) {
                             throw new Error("Missing required parameter: stl_path");
@@ -1135,6 +2459,8 @@ class BambuPrinterMCPServer {
                         const { slicerType, slicerPath, slicerProfile } = resolveSlicerConfig(args);
                         const sliceModel = await this.resolveBambuModel(args?.bambu_model);
                         const nozzleDiam = String(args?.nozzle_diameter || DEFAULT_NOZZLE_DIAMETER);
+                        const activeSlicerProfile = await resolveSlicerProfilePath(slicerProfile || undefined, resolveTemplatePathFromName(["json", "config", "3mf"]) || explicitTemplatePath || undefined, TEMP_DIR);
+                        const explicitSlicerProfile = hasExplicitSlicerProfile(args);
                         // Resolve printer preset for BambuStudio slicer
                         const printerPreset = BAMBU_MODEL_PRESETS[sliceModel]?.(nozzleDiam);
                         const sliceBambuOptions = {};
@@ -1165,6 +2491,7 @@ class BambuPrinterMCPServer {
                         }
                         if (args?.load_filament_ids !== undefined)
                             sliceBambuOptions.loadFilamentIds = String(args.load_filament_ids);
+                        sliceBambuOptions.bedType = resolveBambuStudioCliBedType(args?.bed_type);
                         if (args?.enable_timelapse !== undefined)
                             sliceBambuOptions.enableTimelapse = Boolean(args.enable_timelapse);
                         if (args?.allow_mix_temp !== undefined)
@@ -1183,7 +2510,23 @@ class BambuPrinterMCPServer {
                             sliceBambuOptions.skipModifiedGcodes = Boolean(args.skip_modified_gcodes);
                         if (args?.slice_plate !== undefined)
                             sliceBambuOptions.slicePlate = Number(args.slice_plate);
-                        result = await this.stlManipulator.sliceSTL(String(args.stl_path), slicerType, slicerPath, slicerProfile || undefined, undefined, // progressCallback
+                        const usePrinterFilaments = args?.use_printer_filaments !== undefined ? Boolean(args.use_printer_filaments) : true;
+                        if (usePrinterFilaments &&
+                            !explicitSlicerProfile &&
+                            !sliceBambuOptions.loadFilaments &&
+                            bambuSerial &&
+                            bambuToken) {
+                            try {
+                                const liveFilaments = await this.getResolvedPrinterFilamentInventory(host, bambuSerial, bambuToken, sliceModel, nozzleDiam);
+                                if (liveFilaments.recommended?.load_filaments) {
+                                    sliceBambuOptions.loadFilaments = liveFilaments.recommended.load_filaments;
+                                }
+                            }
+                            catch (filamentError) {
+                                console.warn("Could not resolve live printer filaments for slicing:", filamentError);
+                            }
+                        }
+                        result = await this.stlManipulator.sliceSTL(String(args.stl_path), slicerType, slicerPath, activeSlicerProfile, undefined, // progressCallback
                         printerPreset, sliceBambuOptions);
                         break;
                     }
@@ -1202,6 +2545,8 @@ class BambuPrinterMCPServer {
                         const printModel = await this.resolveBambuModel(args?.bambu_model);
                         const printBedType = resolveBedType(args?.bed_type);
                         const printNozzle = String(args?.nozzle_diameter || DEFAULT_NOZZLE_DIAMETER);
+                        const activeSlicerProfile = await resolveTemplateFirstSlicerProfilePath(args, slicerProfile || undefined, resolveTemplatePathFromName(["json", "config", "3mf"]) || explicitTemplatePath || undefined, TEMP_DIR);
+                        const explicitSlicerProfile = hasExplicitSlicerProfile(args);
                         const printPreset = BAMBU_MODEL_PRESETS[printModel]?.(printNozzle);
                         const plateIndex = args?.plate_index !== undefined ? Number(args.plate_index) : 0;
                         if (!Number.isInteger(plateIndex) || plateIndex < 0) {
@@ -1215,53 +2560,104 @@ class BambuPrinterMCPServer {
                             const zip = await JSZip.loadAsync(zipData);
                             const hasGcode = Object.keys(zip.files).some(f => f.match(/Metadata\/plate_\d+\.gcode/i) || f.endsWith('.gcode'));
                             if (!hasGcode) {
-                                console.log(`3MF has no gcode - auto-slicing with ${slicerType} for ${printModel}`);
+                                if (printBedType === "supertack_plate") {
+                                    throw new Error('BambuStudio CLI SuperTack bed type is not verified; use a pre-sliced 3MF for SuperTack or choose textured_plate, cool_plate, engineering_plate, or hot_plate.');
+                                }
+                                console.log(`3MF has no gcode — auto-slicing with ${slicerType} for ${printModel}`);
                                 const autoSliceOptions = {
                                     uptodate: true,
                                     ensureOnBed: true,
                                     minSave: true,
                                     skipModifiedGcodes: true,
+                                    bedType: printBedType,
                                 };
-                                threeMFPath = await this.stlManipulator.sliceSTL(threeMFPath, slicerType, slicerPath, slicerProfile || undefined, undefined, // progressCallback
+                                if (!explicitSlicerProfile) {
+                                    try {
+                                        const liveFilaments = await this.getResolvedPrinterFilamentInventory(host, bambuSerial, bambuToken, printModel, printNozzle);
+                                        if (liveFilaments.recommended?.load_filaments) {
+                                            autoSliceOptions.loadFilaments = liveFilaments.recommended.load_filaments;
+                                        }
+                                    }
+                                    catch (filamentError) {
+                                        console.warn("Could not resolve live printer filaments for auto-slicing:", filamentError);
+                                    }
+                                }
+                                threeMFPath = await this.stlManipulator.sliceSTL(threeMFPath, slicerType, slicerPath, activeSlicerProfile, undefined, // progressCallback
                                 printPreset, autoSliceOptions);
                                 console.log("Auto-sliced to: " + threeMFPath);
                             }
                         }
                         catch (sliceCheckErr) {
+                            if (String(sliceCheckErr?.message || "").includes("SuperTack")) {
+                                throw sliceCheckErr;
+                            }
                             console.warn("Could not check/slice 3MF, proceeding with original:", sliceCheckErr.message);
                         }
                         const parsed3MFData = await parse3MF(threeMFPath);
+                        const isH2Print = H2_BAMBU_MODELS.has(printModel);
                         let parsedAmsMapping;
-                        if (parsed3MFData.slicerConfig?.ams_mapping) {
-                            const slots = Object.values(parsed3MFData.slicerConfig.ams_mapping)
-                                .filter(v => typeof v === 'number');
+                        if (!isH2Print && parsed3MFData.slicerConfig?.ams_mapping) {
+                            const slots = normalizeAmsMappingObject(parsed3MFData.slicerConfig.ams_mapping);
                             if (slots.length > 0) {
-                                parsedAmsMapping = slots.sort((a, b) => a - b);
+                                parsedAmsMapping = slots;
                             }
                         }
                         let finalAmsMapping = parsedAmsMapping;
-                        const explicitUseAMS = args?.use_ams !== undefined;
-                        let useAMS = explicitUseAMS ? Boolean(args.use_ams) : (!!finalAmsMapping && finalAmsMapping.length > 0);
-                        if (args?.ams_mapping) {
+                        let finalAmsSlots;
+                        let useAMS = args?.use_ams !== undefined ? Boolean(args.use_ams) : (!!finalAmsMapping && finalAmsMapping.length > 0);
+                        const hasUserAmsMapping = hasAmsMappingInput(args?.ams_mapping);
+                        const hasUserAmsSlots = Array.isArray(args?.ams_slots);
+                        if (hasUserAmsMapping) {
                             let userMappingOverride;
                             if (Array.isArray(args.ams_mapping)) {
-                                userMappingOverride = args.ams_mapping.filter((v) => typeof v === 'number');
+                                userMappingOverride = args.ams_mapping.map((v, i) => normalizeBridgeAmsTrayValue(v, `ams_mapping[${i}]`));
                             }
-                            else if (typeof args.ams_mapping === 'object') {
-                                userMappingOverride = Object.values(args.ams_mapping)
-                                    .filter((v) => typeof v === 'number')
-                                    .sort((a, b) => a - b);
+                            else if (args.ams_mapping && typeof args.ams_mapping === 'object') {
+                                userMappingOverride = normalizeAmsMappingObject(args.ams_mapping);
                             }
                             if (userMappingOverride && userMappingOverride.length > 0) {
                                 finalAmsMapping = userMappingOverride;
                                 useAMS = true;
                             }
                         }
+                        if (hasUserAmsSlots) {
+                            const userSlots = args.ams_slots.filter((v) => typeof v === 'number');
+                            if (userSlots.length > 0) {
+                                finalAmsSlots = userSlots;
+                                finalAmsMapping = undefined;
+                                useAMS = true;
+                            }
+                        }
+                        if (!hasUserAmsMapping && !hasUserAmsSlots && args?.auto_match_ams === true && args?.use_ams !== false) {
+                            const requirements = await analyze3MFAmsRequirements(threeMFPath, plateIndex);
+                            const inventory = await this.getResolvedPrinterFilamentInventory(host, bambuSerial, bambuToken, printModel, printNozzle);
+                            const resolved = resolveAmsSlotsFromRequirements(requirements, inventory);
+                            if (resolved.missing.length > 0) {
+                                throw new Error(`auto_match_ams could not find loaded AMS trays for: ${resolved.missing
+                                    .map((missing) => missing.tray_info_idx || `filament position ${missing.filament_position}`)
+                                    .join(", ")}`);
+                            }
+                            finalAmsMapping = undefined;
+                            finalAmsSlots = resolved.ams_slots;
+                            useAMS = finalAmsSlots.length > 0;
+                        }
+                        if (isH2Print &&
+                            !hasUserAmsMapping &&
+                            !hasUserAmsSlots &&
+                            args?.auto_match_ams !== true &&
+                            (!finalAmsMapping || finalAmsMapping.length === 0) &&
+                            (!finalAmsSlots || finalAmsSlots.length === 0)) {
+                            const requirements = await analyze3MFAmsRequirements(threeMFPath, plateIndex);
+                            if (requirements.usedFilamentPositions.length > 0) {
+                                throw new Error(`H2 ${printModel.toUpperCase()} pre-sliced jobs with declared filaments require ams_slots, ams_mapping, or auto_match_ams: true. Plate uses project filament positions ${JSON.stringify(requirements.usedFilamentPositions)}; pass one physical tray per used filament, for example ams_slots: [0] for AMS 0 slot 0 or [1] for AMS 0 slot 1.`);
+                            }
+                        }
                         if (args?.use_ams === false) {
                             finalAmsMapping = undefined;
+                            finalAmsSlots = undefined;
                             useAMS = false;
                         }
-                        if ((!finalAmsMapping || finalAmsMapping.length === 0) && !explicitUseAMS) {
+                        if ((!finalAmsMapping || finalAmsMapping.length === 0) && (!finalAmsSlots || finalAmsSlots.length === 0)) {
                             useAMS = false;
                         }
                         const threeMfFilename = path.basename(threeMFPath);
@@ -1269,9 +2665,11 @@ class BambuPrinterMCPServer {
                         result = await this.bambu.print3mf(host, bambuSerial, bambuToken, {
                             projectName,
                             filePath: threeMFPath,
+                            bambuModel: printModel,
                             plateIndex,
                             useAMS: useAMS,
                             amsMapping: finalAmsMapping,
+                            amsSlots: finalAmsSlots,
                             bedType: printBedType,
                             bedLeveling: args?.bed_leveling !== undefined ? Boolean(args.bed_leveling) : undefined,
                             flowCalibration: args?.flow_calibration !== undefined ? Boolean(args.flow_calibration) : undefined,
@@ -1282,6 +2680,64 @@ class BambuPrinterMCPServer {
                         result = `Print command for ${threeMfFilename} sent successfully.`;
                         break;
                     }
+                    case "print_collar_charm": {
+                        const resolvedTemplateSourcePath = resolveTemplatePathFromName(["3mf"]);
+                        const resolvedSourcePath = String(resolvedTemplateSourcePath || args?.source_path || "");
+                        if (!resolvedSourcePath) {
+                            throw new Error("Missing required parameter: source_path or template_name");
+                        }
+                        if (!bambuSerial || !bambuToken) {
+                            throw new Error("Bambu serial number and access token are required for print_collar_charm.");
+                        }
+                        const { slicerType, slicerPath, slicerProfile } = resolveSlicerConfig(args);
+                        const printModel = await this.resolveBambuModel(args?.bambu_model);
+                        const printBedType = resolveBedType(args?.bed_type);
+                        const printNozzle = String(args?.nozzle_diameter || DEFAULT_NOZZLE_DIAMETER);
+                        const activeSlicerProfile = await resolveTemplateFirstSlicerProfilePath(args, slicerProfile || undefined, resolvedTemplateSourcePath || explicitTemplatePath || undefined, TEMP_DIR);
+                        const preparedThreeMFPath = await this.resolveCollarCharmPrepared3MF(resolvedSourcePath, resolvedTemplateSourcePath || explicitTemplatePath || undefined, slicerType, slicerPath, activeSlicerProfile || undefined, printModel, printNozzle, printBedType, host, bambuSerial, bambuToken);
+                        const collarAnalysis = await analyzeCollarCharm3MF(preparedThreeMFPath, 0);
+                        const inventory = await this.preflightCollarCharmPolicy(host, bambuSerial, bambuToken, printModel, printNozzle);
+                        const projectName = path.basename(preparedThreeMFPath).replace(/\.3mf$/i, '');
+                        result = await this.bambu.print3mf(host, bambuSerial, bambuToken, {
+                            projectName,
+                            filePath: preparedThreeMFPath,
+                            bambuModel: printModel,
+                            plateIndex: collarAnalysis.plateIndex,
+                            useAMS: true,
+                            amsSlots: collarAnalysis.amsSlots,
+                            bedType: printBedType,
+                            bedLeveling: args?.bed_leveling !== undefined ? Boolean(args.bed_leveling) : true,
+                            flowCalibration: args?.flow_calibration !== undefined ? Boolean(args.flow_calibration) : true,
+                            vibrationCalibration: args?.vibration_calibration !== undefined ? Boolean(args.vibration_calibration) : true,
+                            timelapse: args?.timelapse !== undefined ? Boolean(args.timelapse) : false,
+                        });
+                        result = {
+                            ...result,
+                            source_path: resolvedSourcePath,
+                            prepared_three_mf_path: preparedThreeMFPath,
+                            tray_policy: {
+                                inner: {
+                                    color: COLLAR_CHARM_POLICY.colors.inner,
+                                    absolute_tray: COLLAR_CHARM_POLICY.amsSlots.inner,
+                                },
+                                outer: {
+                                    color: COLLAR_CHARM_POLICY.colors.outer,
+                                    absolute_tray: COLLAR_CHARM_POLICY.amsSlots.outer,
+                                },
+                            },
+                            collar_roles: collarAnalysis.roles,
+                            inventory_slots_checked: inventory.trays
+                                .filter((tray) => tray.slot === COLLAR_CHARM_POLICY.amsSlots.inner || tray.slot === COLLAR_CHARM_POLICY.amsSlots.outer)
+                                .map((tray) => ({
+                                slot: tray.slot,
+                                loaded: tray.loaded,
+                                tray_color: tray.tray_color,
+                                tray_type: tray.tray_type,
+                                tray_info_idx: tray.tray_info_idx,
+                            })),
+                        };
+                        break;
+                    }
                     case "merge_vertices":
                         if (!args?.stl_path)
                             throw new Error("Missing required parameter: stl_path");