bambu-printer-mcp 1.0.5 → 1.1.2

package/dist/index.js

@@ -8,30 +8,347 @@ import fs from "fs";
 import path from "path";
 import { createServer as createHttpServer } from "node:http";
 import { randomUUID } from "node:crypto";
-import { STLManipulator } from "./stl/stl-manipulator.js";
-import { parse3MF } from './3mf_parser.js';
+import { STLManipulator, SLICER_TYPES, normalizeSlicerType, } from "./stl/stl-manipulator.js";
+import { BambuNetworkBridge } from "./bambu-network-bridge.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"];
+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`,
 };
+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",
+};
+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)) {
@@ -46,10 +363,63 @@ 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_PATH = process.env.SLICER_PATH || "/Applications/BambuStudio.app/Contents/MacOS/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",
+    "fulu-orcaslicer",
+    "orca-studio",
+    "orca-bambulab",
+];
+function firstExistingPath(paths, fallback) {
+    return paths.find((candidate) => fs.existsSync(candidate)) || fallback;
+}
+function defaultSlicerPathFor(slicerType) {
+    if (slicerType === "orcaslicer" || slicerType === "orcaslicer-bambulab") {
+        if (process.platform === "darwin") {
+            return firstExistingPath([
+                "/Applications/OrcaSlicer.app/Contents/MacOS/OrcaSlicer",
+                "/Applications/Orca Studio.app/Contents/MacOS/Orca Studio",
+                "/Applications/OrcaSlicer-BMCU.app/Contents/MacOS/OrcaSlicer",
+            ], "/Applications/OrcaSlicer.app/Contents/MacOS/OrcaSlicer");
+        }
+        if (process.platform === "win32") {
+            return "C:\\Program Files\\OrcaSlicer\\OrcaSlicer.exe";
+        }
+        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";
+        }
+        if (process.platform === "win32") {
+            return "C:\\Program Files\\Bambu Studio\\bambu-studio.exe";
+        }
+        return "BambuStudio";
+    }
+    return slicerType;
+}
+function resolveSlicerConfig(args) {
+    const slicerType = normalizeSlicerType(String(args?.slicer_type || DEFAULT_SLICER_TYPE));
+    const slicerPath = String(args?.slicer_path || process.env.SLICER_PATH || defaultSlicerPathFor(slicerType));
+    const slicerProfile = String(args?.slicer_profile || DEFAULT_SLICER_PROFILE);
+    return { slicerType, slicerPath, slicerProfile };
+}
 function parseBooleanEnv(rawValue, fallback) {
     if (rawValue === undefined)
         return fallback;
@@ -80,6 +450,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"
@@ -96,6 +497,241 @@ function readRuntimeConfig() {
         blenderBridgeCommand: process.env.BLENDER_MCP_BRIDGE_COMMAND?.trim() || undefined,
     };
 }
+function expandUserPath(rawPath) {
+    const trimmed = rawPath.trim();
+    if (trimmed === "~") {
+        return process.env.HOME || trimmed;
+    }
+    if (trimmed.startsWith("~/")) {
+        return path.join(process.env.HOME || "", trimmed.slice(2));
+    }
+    return path.resolve(trimmed);
+}
+function readableFilePathFromString(value) {
+    if (!value.trim() || value.includes("\n") || value.includes("\r")) {
+        return undefined;
+    }
+    const candidate = expandUserPath(value);
+    try {
+        return fs.statSync(candidate).isFile() ? candidate : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function looksLikeGcodeFilePath(value) {
+    const trimmed = value.trim();
+    if (!trimmed || trimmed.includes("\n") || trimmed.includes("\r")) {
+        return false;
+    }
+    return (trimmed.startsWith("/") ||
+        trimmed.startsWith("./") ||
+        trimmed.startsWith("../") ||
+        trimmed.startsWith("~/") ||
+        trimmed.includes("\\") ||
+        /\.(gcode|gco|gc)$/i.test(trimmed));
+}
+function requireReadableFilePath(rawPath, label) {
+    const candidate = expandUserPath(rawPath);
+    try {
+        if (!fs.statSync(candidate).isFile()) {
+            throw new Error(`${label} is not a file: ${candidate}`);
+        }
+    }
+    catch (error) {
+        if (error.message.startsWith(`${label} is not a file:`)) {
+            throw error;
+        }
+        throw new Error(`${label} does not exist or is not readable: ${candidate}`);
+    }
+    return candidate;
+}
+function writeGcodeContentToTempFile(filename, gcode) {
+    fs.mkdirSync(TEMP_DIR, { recursive: true });
+    const cleanupDir = fs.mkdtempSync(path.join(TEMP_DIR, "upload-gcode-"));
+    const safeName = path.basename(filename.replace(/^\/+/, "")) || "upload.gcode";
+    const filePath = path.join(cleanupDir, safeName);
+    fs.writeFileSync(filePath, gcode);
+    return { filePath, cleanupDir };
+}
+function resolveUploadGcodeSource(args) {
+    const gcodePath = args.gcode_path !== undefined ? String(args.gcode_path) : "";
+    const gcode = args.gcode !== undefined ? String(args.gcode) : "";
+    if (gcodePath && gcode) {
+        throw new Error("Provide either gcode_path or gcode, not both.");
+    }
+    if (gcodePath) {
+        return { filePath: requireReadableFilePath(gcodePath, "gcode_path") };
+    }
+    if (!gcode) {
+        throw new Error("Missing required parameter: gcode or gcode_path");
+    }
+    const detectedPath = readableFilePathFromString(gcode);
+    if (detectedPath) {
+        return { filePath: detectedPath };
+    }
+    if (looksLikeGcodeFilePath(gcode)) {
+        throw new Error("gcode looks like a local G-code path, but the file is not readable. " +
+            "Pass readable gcode_path or literal G-code content.");
+    }
+    return writeGcodeContentToTempFile(String(args.filename), gcode);
+}
+const BAMBU_NETWORK_PRINT_METHODS = [
+    "start_print",
+    "start_local_print",
+    "start_local_print_with_record",
+    "start_send_gcode_to_sdcard",
+    "start_sdcard_print",
+];
+function resolveBambuNetworkPrintMethod(rawMethod, connectionType) {
+    const defaultMethod = connectionType === "lan" ? "start_local_print" : "start_print";
+    const method = (rawMethod || defaultMethod).trim();
+    if (!BAMBU_NETWORK_PRINT_METHODS.includes(method)) {
+        throw new Error(`Invalid bambu_network_method: "${method}". Valid methods: ${BAMBU_NETWORK_PRINT_METHODS.join(", ")}`);
+    }
+    return method;
+}
+function toBridgeMethod(method) {
+    return `net.${method}`;
+}
+function stringifyBridgeJson(value) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value === "string")
+        return value;
+    return JSON.stringify(value);
+}
+function redactPrintParams(params) {
+    return {
+        ...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 });
 }
@@ -112,6 +748,7 @@ class BambuPrinterMCPServer {
             }
         });
         this.bambu = new BambuImplementation();
+        this.bambuNetwork = new BambuNetworkBridge();
         this.stlManipulator = new STLManipulator(TEMP_DIR);
         this.setupHandlers();
         this.setupErrorHandling();
@@ -150,11 +787,13 @@ 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" },
                             ],
                         },
                     },
@@ -178,6 +817,369 @@ class BambuPrinterMCPServer {
             throw elicitError;
         }
     }
+    bridgeOptionsFromArgs(args) {
+        return {
+            bridgeCommand: args?.bridge_command !== undefined ? String(args.bridge_command) : undefined,
+            configDir: args?.bambu_network_config_dir !== undefined ? String(args.bambu_network_config_dir) : undefined,
+            countryCode: args?.country_code !== undefined ? String(args.country_code) : undefined,
+            userInfo: args?.user_info !== undefined ? String(args.user_info) : undefined,
+            timeoutMs: args?.timeout_ms !== undefined ? Number(args.timeout_ms) : undefined,
+        };
+    }
+    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;
+        const zipData = fs.readFileSync(threeMFPath);
+        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) {
+            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, host, bambuSerial, bambuToken, printModel, printNozzle) {
+        const parsed3MFData = await parse3MF(threeMFPath);
+        let parsedAmsMapping;
+        if (parsed3MFData.slicerConfig?.ams_mapping) {
+            const slots = normalizeAmsMappingObject(parsed3MFData.slicerConfig.ams_mapping);
+            if (slots.length > 0) {
+                parsedAmsMapping = slots;
+            }
+        }
+        let finalAmsMapping = parsedAmsMapping;
+        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.map((v, i) => normalizeBridgeAmsTrayValue(v, `ams_mapping[${i}]`));
+            }
+            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) && (!finalAmsSlots || finalAmsSlots.length === 0)) {
+            useAMS = false;
+        }
+        return { useAMS, finalAmsMapping, finalAmsSlots };
+    }
+    async print3mfViaBambuNetwork(args, host, bambuSerial, bambuToken) {
+        if (!args?.three_mf_path) {
+            throw new Error("Missing required parameter: three_mf_path");
+        }
+        const printModel = await this.resolveBambuModel(args?.bambu_model);
+        const printBedType = resolveBedType(args?.bed_type);
+        const printNozzle = String(args?.nozzle_diameter || DEFAULT_NOZZLE_DIAMETER);
+        const printPreset = BAMBU_MODEL_PRESETS[printModel]?.(printNozzle);
+        const plateIndex = args?.plate_index !== undefined ? Number(args.plate_index) : 0;
+        if (!Number.isInteger(plateIndex) || plateIndex < 0) {
+            throw new Error("plate_index must be a non-negative integer.");
+        }
+        const connectionType = String(args?.connection_type || "cloud").trim().toLowerCase();
+        if (!["cloud", "lan"].includes(connectionType)) {
+            throw new Error('connection_type must be "cloud" or "lan".');
+        }
+        const bridgePrintMethod = resolveBambuNetworkPrintMethod(args?.bambu_network_method !== undefined ? String(args.bambu_network_method) : undefined, connectionType);
+        const bridgeMethod = toBridgeMethod(bridgePrintMethod);
+        const isLocalBridgePrint = bridgePrintMethod !== "start_print";
+        const devId = String(args?.dev_id || bambuSerial || DEFAULT_BAMBU_DEV_ID).trim();
+        if (!devId) {
+            throw new Error("dev_id is required for FULU BambuNetwork printing. Pass dev_id or set BAMBU_DEV_ID/BAMBU_SERIAL.");
+        }
+        const devIp = String(args?.dev_ip || args?.host || host || "").trim();
+        const explicitPassword = String(args?.password || args?.bambu_token || "").trim();
+        const password = isLocalBridgePrint ? (explicitPassword || String(bambuToken || "").trim()) : explicitPassword;
+        if (isLocalBridgePrint && (!devIp || devIp === "localhost")) {
+            throw new Error("dev_ip or host is required for FULU BambuNetwork LAN/local print methods.");
+        }
+        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, 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 ?? finalAmsSlots);
+        const params = {
+            dev_id: devId,
+            task_name: String(args?.task_name || projectName),
+            project_name: projectName,
+            preset_name: presetName,
+            filename: threeMFPath,
+            config_filename: String(args?.config_filename || threeMFPath),
+            plate_index: plateIndex + 1,
+            ftp_folder: String(args?.ftp_folder || ""),
+            ftp_file: String(args?.ftp_file || ""),
+            ftp_file_md5: String(args?.ftp_file_md5 || ""),
+            nozzle_mapping: stringifyBridgeJson(args?.nozzle_mapping) || "",
+            ams_mapping: amsMapping || "",
+            ams_mapping2: stringifyBridgeJson(args?.ams_mapping2) || "",
+            ams_mapping_info: stringifyBridgeJson(args?.ams_mapping_info) || "",
+            nozzles_info: stringifyBridgeJson(args?.nozzles_info) || "",
+            connection_type: connectionType,
+            comments: String(args?.comments || ""),
+            origin_profile_id: args?.origin_profile_id !== undefined ? Number(args.origin_profile_id) : 0,
+            stl_design_id: args?.stl_design_id !== undefined ? Number(args.stl_design_id) : 0,
+            origin_model_id: String(args?.origin_model_id || ""),
+            print_type: String(args?.print_type || "from_normal"),
+            dst_file: String(args?.dst_file || ""),
+            dev_name: String(args?.dev_name || ""),
+            dev_ip: devIp,
+            use_ssl_for_ftp: args?.use_ssl_for_ftp !== undefined ? Boolean(args.use_ssl_for_ftp) : true,
+            use_ssl_for_mqtt: args?.use_ssl_for_mqtt !== undefined ? Boolean(args.use_ssl_for_mqtt) : true,
+            username: String(args?.username || "bblp"),
+            password,
+            task_bed_leveling: args?.bed_leveling !== undefined ? Boolean(args.bed_leveling) : true,
+            task_flow_cali: args?.flow_calibration !== undefined ? Boolean(args.flow_calibration) : true,
+            task_vibration_cali: args?.vibration_calibration !== undefined ? Boolean(args.vibration_calibration) : true,
+            task_layer_inspect: args?.layer_inspect !== undefined ? Boolean(args.layer_inspect) : false,
+            task_record_timelapse: args?.timelapse !== undefined ? Boolean(args.timelapse) : false,
+            task_use_ams: useAMS,
+            task_bed_type: printBedType,
+            extra_options: stringifyBridgeJson(args?.extra_options) || "",
+            auto_bed_leveling: args?.auto_bed_leveling !== undefined ? Number(args.auto_bed_leveling) : 0,
+            auto_flow_cali: args?.auto_flow_cali !== undefined ? Number(args.auto_flow_cali) : 0,
+            auto_offset_cali: args?.auto_offset_cali !== undefined ? Number(args.auto_offset_cali) : 0,
+            extruder_cali_manual_mode: args?.extruder_cali_manual_mode !== undefined ? Number(args.extruder_cali_manual_mode) : -1,
+            task_ext_change_assist: args?.external_change_assist !== undefined ? Boolean(args.external_change_assist) : false,
+            try_emmc_print: args?.try_emmc_print !== undefined ? Boolean(args.try_emmc_print) : false,
+        };
+        const bridgeResult = await this.bambuNetwork.callWithAgent(bridgeMethod, { client_job_id: clientJobId, params }, this.bridgeOptionsFromArgs(args));
+        if (typeof bridgeResult === "object" && bridgeResult !== null && bridgeResult.ok === false) {
+            throw new Error(`FULU BambuNetwork bridge method ${bridgeMethod} failed: ${String(bridgeResult.error || "unknown bridge error")}`);
+        }
+        if (typeof bridgeResult === "object" &&
+            bridgeResult !== null &&
+            typeof bridgeResult.value === "number" &&
+            bridgeResult.value !== 0) {
+            const value = bridgeResult.value;
+            throw new Error(`FULU BambuNetwork bridge method ${bridgeMethod} returned non-zero result ${value}.`);
+        }
+        return {
+            status: "success",
+            message: `FULU BambuNetwork ${bridgePrintMethod} command for ${threeMfFilename} sent successfully.`,
+            bridgeMethod,
+            bridgeResult,
+            clientJobId,
+            autoSliced,
+            projectName,
+            plateIndex,
+            bridgePlateIndex: plateIndex + 1,
+            useAMS,
+            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 {
@@ -193,6 +1195,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: [
@@ -205,6 +1213,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"
                     }
                 ]
             };
@@ -225,6 +1238,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}`);
             }
@@ -264,6 +1291,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: ["p1s", "p1p", "p2s", "x1c", "x1e", "a1", "a1mini", "h2d", "h2s"],
+                                    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: ["p1s", "p1p", "p2s", "x1c", "x1e", "a1", "a1mini", "h2d", "h2s"],
+                                    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",
@@ -312,132 +1402,574 @@ class BambuPrinterMCPServer {
                             properties: {
                                 stl_path: { type: "string", description: "Path to the STL file to analyze" }
                             },
-                            required: ["stl_path"]
+                            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: ["p1s", "p1p", "p2s", "x1c", "x1e", "a1", "a1mini", "h2d", "h2s"],
+                                    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.",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                stl_path: { type: "string", description: "Path to the STL or 3MF file to slice" },
+                                bambu_model: {
+                                    type: "string",
+                                    enum: ["p1s", "p1p", "p2s", "x1c", "x1e", "a1", "a1mini", "h2d", "h2s"],
+                                    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: "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)" },
+                                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." },
+                                ensure_on_bed: { type: "boolean", description: "Detect models floating above the bed and lower them onto the build surface. Safety net for imported models with incorrect Z origins." },
+                                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." },
+                                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." },
+                                scale: { type: "number", description: "Uniform scale factor applied to all axes. 1.0 = original size, 2.0 = double, 0.5 = half. Applied before slicing." },
+                                rotate: { type: "number", description: "Rotate the model around the Z-axis (vertical) by this many degrees before slicing. Positive = counterclockwise when viewed from above." },
+                                rotate_x: { type: "number", description: "Rotate the model around the X-axis by this many degrees before slicing. Useful for reorienting prints for better layer adhesion." },
+                                rotate_y: { type: "number", description: "Rotate the model around the Y-axis by this many degrees before slicing. Useful for reorienting prints for better layer adhesion." },
+                                min_save: { type: "boolean", description: "Write a smaller output 3MF by omitting non-essential metadata. Reduces file size for faster FTP upload to the printer." },
+                                skip_modified_gcodes: { type: "boolean", description: "Strip custom start/end gcodes embedded in the 3MF. Recommended for downloaded 3MFs since custom gcodes from other users' profiles may be unsafe for your printer." },
+                                slice_plate: { type: "number", description: "Which plate index to slice. 0 = all plates (default). Use 1, 2, etc. to slice only a specific plate in multi-plate 3MF projects." }
+                            },
+                            required: ["stl_path", "bambu_model"]
+                        }
+                    },
+                    {
+                        name: "list_printer_files",
+                        description: "List files stored 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: "bambu_network_bridge_status",
+                        description: "Inspect or probe the FULU OrcaSlicer-bambulab BambuNetwork bridge runtime used for cloud and restored BambuNetwork printing.",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                connect: { type: "boolean", description: "When true, start the bridge command and run a handshake plus agent initialization probe." },
+                                bridge_command: { type: "string", description: "Override command for the FULU bridge host or macOS/WSL wrapper; defaults to BAMBU_NETWORK_BRIDGE_COMMAND." },
+                                bambu_network_config_dir: { type: "string", description: "Config/log directory used by the BambuNetwork agent; defaults to BAMBU_NETWORK_CONFIG_DIR or a user config directory." },
+                                country_code: { type: "string", description: "BambuNetwork country code, such as US, used by the agent during startup." },
+                                user_info: { type: "string", description: "Optional BambuNetwork user_info JSON string to pass to net.change_user after the agent starts." },
+                                timeout_ms: { type: "number", description: "Bridge request timeout in milliseconds for the connect probe." }
+                            }
+                        }
+                    },
+                    {
+                        name: "bambu_network_call",
+                        description: "Call a raw FULU OrcaSlicer-bambulab BambuNetwork bridge method, optionally with an initialized network agent injected into the payload.",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                method: { type: "string", description: "FULU bridge method name, for example bridge.handshake, net.is_user_login, or net.get_user_selected_machine." },
+                                payload: { type: "object", description: "JSON payload passed to the bridge method." },
+                                with_agent: { type: "boolean", description: "When true, initialize a BambuNetwork agent and add its agent id to the payload before calling the method." },
+                                bridge_command: { type: "string", description: "Override command for the FULU bridge host or macOS/WSL wrapper; defaults to BAMBU_NETWORK_BRIDGE_COMMAND." },
+                                bambu_network_config_dir: { type: "string", description: "Config/log directory used by the BambuNetwork agent; defaults to BAMBU_NETWORK_CONFIG_DIR or a user config directory." },
+                                country_code: { type: "string", description: "BambuNetwork country code, such as US, used by the agent during startup." },
+                                user_info: { type: "string", description: "Optional BambuNetwork user_info JSON string to pass to net.change_user after the agent starts." },
+                                timeout_ms: { type: "number", description: "Bridge request timeout in milliseconds." }
+                            },
+                            required: ["method"]
+                        }
+                    },
+                    {
+                        name: "print_3mf_bambu_network",
+                        description: "Print a 3MF through FULU OrcaSlicer-bambulab's restored BambuNetwork path instead of the MCP LAN MQTT/FTPS path.",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                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", "p2s", "x1c", "x1e", "a1", "a1mini", "h2d", "h2s"],
+                                    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." },
+                                bambu_network_method: { type: "string", enum: BAMBU_NETWORK_PRINT_METHODS, description: "FULU print method to invoke; defaults to start_print for cloud and start_local_print for lan." },
+                                dev_id: { type: "string", description: "Bambu device id used by BambuNetwork; defaults to BAMBU_DEV_ID or BAMBU_SERIAL." },
+                                dev_ip: { type: "string", description: "Printer IP address for LAN/local bridge methods; defaults to host when provided." },
+                                host: { type: "string", description: "Printer host or IP address, used as dev_ip for LAN/local bridge methods." },
+                                bambu_serial: { type: "string", description: "Fallback Bambu device id when dev_id is not supplied." },
+                                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", "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." },
+                                task_name: { type: "string", description: "Optional BambuNetwork task name; defaults to the project name." },
+                                config_filename: { type: "string", description: "Optional config 3MF path for cloud print; defaults to the same 3MF path." },
+                                bridge_command: { type: "string", description: "Override command for the FULU bridge host or macOS/WSL wrapper; defaults to BAMBU_NETWORK_BRIDGE_COMMAND." },
+                                bambu_network_config_dir: { type: "string", description: "Config/log directory used by the BambuNetwork agent; defaults to BAMBU_NETWORK_CONFIG_DIR or a user config directory." },
+                                country_code: { type: "string", description: "BambuNetwork country code, such as US, used by the agent during startup." },
+                                user_info: { type: "string", description: "Optional BambuNetwork user_info JSON string to pass to net.change_user after the agent starts." },
+                                timeout_ms: { type: "number", description: "Bridge request timeout in milliseconds." },
+                                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 fork." },
+                                slicer_path: { type: "string", description: "Path to the slicer executable for auto-slicing; defaults to value from env or a platform default." },
+                                slicer_profile: { type: "string", description: "Path to an optional slicer profile/config file for auto-slicing." },
+                                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." },
+                                nozzle_mapping: { type: "string", description: "Raw JSON string for FULU PrintParams nozzle_mapping." },
+                                nozzles_info: { type: "string", description: "Raw JSON string for FULU PrintParams nozzles_info." },
+                                bed_leveling: { type: "boolean", description: "Enable auto bed leveling in FULU PrintParams (default: true)." },
+                                flow_calibration: { type: "boolean", description: "Enable flow calibration in FULU PrintParams (default: true)." },
+                                vibration_calibration: { type: "boolean", description: "Enable vibration calibration in FULU PrintParams (default: true)." },
+                                layer_inspect: { type: "boolean", description: "Enable first-layer inspection where supported (default: false for BambuNetwork bridge)." },
+                                timelapse: { type: "boolean", description: "Enable timelapse recording in FULU PrintParams (default: false)." },
+                                use_ssl_for_ftp: { type: "boolean", description: "Whether FULU local print should use SSL for FTP (default: true)." },
+                                use_ssl_for_mqtt: { type: "boolean", description: "Whether FULU local print should use SSL for MQTT (default: true)." },
+                                external_change_assist: { type: "boolean", description: "Enable FULU PrintParams task_ext_change_assist for external filament change assistance." },
+                                try_emmc_print: { type: "boolean", description: "Enable FULU PrintParams try_emmc_print for printers that support internal storage printing." },
+                                extra_options: { type: "string", description: "Raw JSON string or text for FULU PrintParams extra_options." },
+                                client_job_id: { type: "number", description: "Optional client job id sent to the bridge; defaults to the current timestamp." }
+                            },
+                            required: ["three_mf_path", "bambu_model"]
+                        }
+                    },
+                    {
+                        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: {
+                                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)" }
+                            }
+                        }
+                    },
+                    {
+                        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: {
+                                filename: {
+                                    type: "string",
+                                    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: ["p1s", "p1p", "p2s", "x1c", "x1e", "a1", "a1mini", "h2d", "h2s"],
+                                    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)" },
+                                bambu_token: { type: "string", description: "Access token (default: value from env)" }
+                            },
+                            required: ["file_path", "filename"]
+                        }
+                    },
+                    {
+                        name: "start_print",
+                        description: "Start printing a G-code file already on the Bambu Lab printer. Alias of start_print_job for upstream MCP compatibility.",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                filename: { type: "string", description: "Name of the file to print" },
+                                bambu_model: {
+                                    type: "string",
+                                    enum: ["p1s", "p1p", "p2s", "x1c", "x1e", "a1", "a1mini", "h2d", "h2s"],
+                                    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)" },
+                                bambu_serial: { type: "string", description: "Serial number (default: value from env)" },
+                                bambu_token: { type: "string", description: "Access token (default: value from env)" }
+                            },
+                            required: ["filename", "bambu_model"]
+                        }
+                    },
+                    {
+                        name: "start_print_job",
+                        description: "Start printing a G-code file already on the Bambu Lab printer",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                filename: { type: "string", description: "Name of the file to print" },
+                                bambu_model: {
+                                    type: "string",
+                                    enum: ["p1s", "p1p", "p2s", "x1c", "x1e", "a1", "a1mini", "h2d", "h2s"],
+                                    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)" },
+                                bambu_serial: { type: "string", description: "Serial number (default: value from env)" },
+                                bambu_token: { type: "string", description: "Access token (default: value from env)" }
+                            },
+                            required: ["filename", "bambu_model"]
+                        }
+                    },
+                    {
+                        name: "cancel_print",
+                        description: "Cancel the current 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: "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: "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.",
+                        name: "set_airduct_mode",
+                        description: "Set H2/P2 airduct mode to cooling or heating.",
                         inputSchema: {
                             type: "object",
                             properties: {
-                                stl_path: { type: "string", description: "Path to the STL or 3MF file to slice" },
-                                bambu_model: {
+                                mode: {
                                     type: "string",
-                                    enum: ["p1s", "p1p", "x1c", "x1e", "a1", "a1mini", "h2d"],
-                                    description: "REQUIRED: Bambu Lab printer model. Ask the user if not known. Using the wrong model can damage the printer."
-                                },
-                                slicer_type: {
-                                    type: "string",
-                                    description: "Type of slicer to use (bambustudio, prusaslicer, cura, slic3r, orcaslicer) (default: bambustudio)"
+                                    enum: ["cooling", "heating"],
+                                    description: "Airduct mode to apply"
                                 },
-                                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)" },
-                                nozzle_diameter: { type: "string", description: "Nozzle diameter in mm (default: 0.4)" },
-                                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." },
-                                ensure_on_bed: { type: "boolean", description: "Detect models floating above the bed and lower them onto the build surface. Safety net for imported models with incorrect Z origins." },
-                                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'." },
-                                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." },
-                                scale: { type: "number", description: "Uniform scale factor applied to all axes. 1.0 = original size, 2.0 = double, 0.5 = half. Applied before slicing." },
-                                rotate: { type: "number", description: "Rotate the model around the Z-axis (vertical) by this many degrees before slicing. Positive = counterclockwise when viewed from above." },
-                                rotate_x: { type: "number", description: "Rotate the model around the X-axis by this many degrees before slicing. Useful for reorienting prints for better layer adhesion." },
-                                rotate_y: { type: "number", description: "Rotate the model around the Y-axis by this many degrees before slicing. Useful for reorienting prints for better layer adhesion." },
-                                min_save: { type: "boolean", description: "Write a smaller output 3MF by omitting non-essential metadata. Reduces file size for faster FTP upload to the printer." },
-                                skip_modified_gcodes: { type: "boolean", description: "Strip custom start/end gcodes embedded in the 3MF. Recommended for downloaded 3MFs since custom gcodes from other users' profiles may be unsafe for your printer." },
-                                slice_plate: { type: "number", description: "Which plate index to slice. 0 = all plates (default). Use 1, 2, etc. to slice only a specific plate in multi-plate 3MF projects." }
+                                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: ["stl_path", "bambu_model"]
+                            required: ["mode"]
                         }
                     },
                     {
-                        name: "list_printer_files",
-                        description: "List files stored on the Bambu Lab printer",
+                        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: "upload_gcode",
-                        description: "Upload a G-code file to the Bambu Lab printer",
+                        name: "set_temperature",
+                        description: "Set the temperature of a printer component (bed, nozzle)",
                         inputSchema: {
                             type: "object",
                             properties: {
-                                filename: { type: "string", description: "Name for the file on the printer" },
-                                gcode: { type: "string", description: "G-code content to upload" },
+                                component: { type: "string", description: "Component to heat: bed, nozzle, or extruder" },
+                                temperature: { type: "number", description: "Target temperature in °C" },
                                 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", "gcode"]
+                            required: ["component", "temperature"]
                         }
                     },
                     {
-                        name: "upload_file",
-                        description: "Upload a local file to the Bambu Lab printer",
+                        name: "set_fan_speed",
+                        description: "Set a Bambu printer fan speed percentage using the printer's MQTT fan command",
                         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)" },
+                                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: ["file_path", "filename"]
+                            required: ["fan", "speed"]
                         }
                     },
                     {
-                        name: "start_print_job",
-                        description: "Start printing a G-code file already on the Bambu Lab printer",
+                        name: "set_light",
+                        description: "Set a Bambu printer light node mode using the printer's MQTT LED command",
                         inputSchema: {
                             type: "object",
                             properties: {
-                                filename: { type: "string", description: "Name of the file to print" },
+                                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: ["filename"]
+                            required: ["light", "mode"]
                         }
                     },
                     {
-                        name: "cancel_print",
-                        description: "Cancel the current print job on the Bambu Lab printer",
+                        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_temperature",
-                        description: "Set the temperature of a printer component (bed, nozzle)",
+                        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: {
-                                component: { type: "string", description: "Component to heat: bed, nozzle, or extruder" },
-                                temperature: { type: "number", description: "Target temperature in °C" },
+                                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: ["component", "temperature"]
+                            required: ["action", "ams_id"]
                         }
                     },
                     {
@@ -449,32 +1981,97 @@ 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: ["p1s", "p1p", "p2s", "x1c", "x1e", "a1", "a1mini", "h2d", "h2s"],
                                     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 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." },
+                                dev_id: { type: "string", description: "Bambu device id for FULU BambuNetwork printing; defaults to BAMBU_DEV_ID or BAMBU_SERIAL." },
+                                dev_ip: { type: "string", description: "Printer IP address for FULU BambuNetwork LAN/local print methods; defaults to host when provided." },
+                                bridge_command: { type: "string", description: "Override command for the FULU bridge host or macOS/WSL wrapper; defaults to BAMBU_NETWORK_BRIDGE_COMMAND." },
+                                bambu_network_config_dir: { type: "string", description: "Config/log directory used by the FULU BambuNetwork agent." },
+                                country_code: { type: "string", description: "BambuNetwork country code, such as US, used by the FULU bridge agent." },
+                                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)"
                                 },
                                 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. 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)" },
                                 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)" },
                                 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: ["p1s", "p1p", "p2s", "x1c", "x1e", "a1", "a1mini", "h2d", "h2s"],
+                                    description: "REQUIRED: Bambu Lab printer model. H2D and H2S 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",
@@ -535,48 +2132,205 @@ 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 slicerType = String(args?.slicer_type || DEFAULT_SLICER_TYPE);
-            const slicerPath = String(args?.slicer_path || DEFAULT_SLICER_PATH);
-            const slicerProfile = String(args?.slicer_profile || DEFAULT_SLICER_PROFILE);
+            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;
+                    case "bambu_network_bridge_status": {
+                        const bridgeArgs = args;
+                        const options = this.bridgeOptionsFromArgs(bridgeArgs);
+                        result = this.bambuNetwork.getStatus(options);
+                        if (Boolean(bridgeArgs?.connect)) {
+                            const probe = await this.bambuNetwork.ensureAgent(options);
+                            result = {
+                                ...this.bambuNetwork.getStatus(options),
+                                connected: true,
+                                agent: probe.agent,
+                                handshake: probe.handshake,
+                            };
+                        }
+                        break;
+                    }
+                    case "bambu_network_call": {
+                        if (!args?.method) {
+                            throw new Error("Missing required parameter: method");
+                        }
+                        const bridgeArgs = args;
+                        const payload = bridgeArgs.payload && typeof bridgeArgs.payload === "object"
+                            ? bridgeArgs.payload
+                            : {};
+                        const options = this.bridgeOptionsFromArgs(bridgeArgs);
+                        result = bridgeArgs.with_agent === false
+                            ? await this.bambuNetwork.request(String(bridgeArgs.method), payload, options)
+                            : await this.bambuNetwork.callWithAgent(String(bridgeArgs.method), payload, options);
+                        break;
+                    }
+                    case "print_3mf_bambu_network": {
+                        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 || !args?.gcode) {
-                            throw new Error("Missing required parameters: filename and gcode");
+                        if (!args?.filename) {
+                            throw new Error("Missing required parameter: filename");
+                        }
+                        const uploadSource = resolveUploadGcodeSource(args);
+                        try {
+                            result = await this.bambu.uploadFile(host, bambuSerial, bambuToken, uploadSource.filePath, String(args.filename), false);
+                        }
+                        finally {
+                            if (uploadSource.cleanupDir) {
+                                fs.rmSync(uploadSource.cleanupDir, { recursive: true, force: true });
+                            }
                         }
-                        const tmpPath = path.join(TEMP_DIR, String(args.filename));
-                        fs.writeFileSync(tmpPath, String(args.gcode));
-                        result = await this.bambu.uploadFile(host, bambuSerial, bambuToken, tmpPath, String(args.filename), false);
                         break;
                     }
                     case "upload_file":
                         if (!args?.file_path || !args?.filename) {
                             throw new Error("Missing required parameters: file_path and filename");
                         }
+                        if (Boolean(args.print ?? false)) {
+                            await this.resolveBambuModel(args?.bambu_model);
+                        }
                         result = await this.bambu.uploadFile(host, bambuSerial, bambuToken, String(args.file_path), String(args.filename), Boolean(args.print ?? false));
                         break;
+                    case "start_print":
                     case "start_print_job":
                         if (!args?.filename) {
                             throw new Error("Missing required parameter: filename");
                         }
+                        await this.resolveBambuModel(args?.bambu_model);
                         result = await this.bambu.startJob(host, bambuSerial, bambuToken, String(args.filename));
                         break;
                     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");
@@ -609,12 +2363,100 @@ 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");
                         }
+                        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 = {};
@@ -632,10 +2474,20 @@ class BambuPrinterMCPServer {
                             sliceBambuOptions.cloneObjects = String(args.clone_objects);
                         if (args?.skip_objects !== undefined)
                             sliceBambuOptions.skipObjects = String(args.skip_objects);
-                        if (args?.load_filaments !== undefined)
+                        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)
@@ -654,7 +2506,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;
                     }
@@ -662,13 +2530,24 @@ class BambuPrinterMCPServer {
                         if (!args?.three_mf_path) {
                             throw new Error("Missing required parameter: three_mf_path");
                         }
+                        if (String(args?.connection_mode || "lan_mqtt_ftps") === "bambu_network") {
+                            result = await this.print3mfViaBambuNetwork(args, host, bambuSerial, bambuToken);
+                            break;
+                        }
                         if (!bambuSerial || !bambuToken) {
                             throw new Error("Bambu serial number and access token are required for print_3mf.");
                         }
+                        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, 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) {
+                            throw new Error("plate_index must be a non-negative integer.");
+                        }
                         let threeMFPath = String(args.three_mf_path);
                         // Auto-slice if 3MF has no gcode
                         try {
@@ -677,52 +2556,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) {
+                                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 = printModel === "h2s" || printModel === "h2d";
                         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;
+                        let finalAmsSlots;
                         let useAMS = args?.use_ams !== undefined ? Boolean(args.use_ams) : (!!finalAmsMapping && finalAmsMapping.length > 0);
-                        if (args?.ams_mapping) {
+                        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) {
+                        if ((!finalAmsMapping || finalAmsMapping.length === 0) && (!finalAmsSlots || finalAmsSlots.length === 0)) {
                             useAMS = false;
                         }
                         const threeMfFilename = path.basename(threeMFPath);
@@ -730,9 +2661,10 @@ class BambuPrinterMCPServer {
                         result = await this.bambu.print3mf(host, bambuSerial, bambuToken, {
                             projectName,
                             filePath: threeMFPath,
-                            plateIndex: 0,
+                            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,
@@ -743,6 +2675,63 @@ 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,
+                            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");