bambu-printer-mcp 1.0.5 → 1.1.2

package/src/index.ts

@@ -16,38 +16,485 @@ import fs from "fs";
 import path from "path";
 import { createServer as createHttpServer, type IncomingMessage, type Server as HttpServer, type ServerResponse } from "node:http";
 import { randomUUID } from "node:crypto";
-import { STLManipulator, type BambuSliceOptions } from "./stl/stl-manipulator.js";
-import { parse3MF } from './3mf_parser.js';
+import {
+  STLManipulator,
+  SLICER_TYPES,
+  normalizeSlicerType,
+  type BambuSliceOptions,
+  type SlicerType,
+} from "./stl/stl-manipulator.js";
+import { BambuNetworkBridge, type BambuNetworkBridgeOptions } 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 type { ThreeMFAmsRequirements } from "./types.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"] as const;
+const VALID_BAMBU_MODELS = ["p1s", "p1p", "p2s", "x1c", "x1e", "a1", "a1mini", "h2d", "h2s"] as const;
 type BambuModel = typeof VALID_BAMBU_MODELS[number];
 
-const VALID_BED_TYPES = ["textured_plate", "cool_plate", "engineering_plate", "hot_plate"] as const;
+const VALID_BED_TYPES = ["textured_plate", "cool_plate", "engineering_plate", "hot_plate", "supertack_plate"] as const;
+const VALID_BAMBUSTUDIO_CLI_BED_TYPES = ["textured_plate", "cool_plate", "engineering_plate", "hot_plate"] as const;
 
 // Map model IDs to BambuStudio --load-machine preset names
 const BAMBU_MODEL_PRESETS: Record<string, (nozzle: string) => string> = {
   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: Record<string, string> = {
+  p1s: "P1S",
+  p1p: "P1P",
+  p2s: "P2S",
+  x1c: "X1C",
+  x1e: "X1E",
+  a1: "A1",
+  a1mini: "A1M",
+  h2d: "H2D",
+  h2s: "H2S",
+};
+
+type FilamentProfileIndex = {
+  byName: Map<string, string>;
+  baseNameByFilamentId: Map<string, string>;
+};
+
+type PrinterFilamentInventory = {
+  current_slot: number | null;
+  current_source: "ams" | "external" | null;
+  summary: {
+    loaded_slots: number;
+    resolved_profile_slots: number;
+    unresolved_loaded_slots: number;
+    empty_slots: number;
+    current_slot: number | null;
+    current_source: "ams" | "external" | null;
+    recommended_slot: number | null;
+    recommended_reason: string | null;
+  };
+  trays: Array<{
+    ams_id: number | null;
+    tray_id: number | null;
+    slot: number | null;
+    state: number;
+    loaded: boolean;
+    tray_info_idx: string | null;
+    tray_type: string | null;
+    tray_sub_brands: string | null;
+    tray_color: string | null;
+    remain_percent: number | null;
+    nozzle_temp_min: number | null;
+    nozzle_temp_max: number | null;
+    resolved_base_profile_name: string | null;
+    resolved_profile_path: string | null;
+    profile_resolution: "exact-model-nozzle" | "model" | "generic" | "unresolved";
+    match_confidence: "high" | "medium" | "low" | "none";
+    display_name: string;
+    profile_candidates: string[];
+  }>;
+  recommended: {
+    slot: number | null;
+    tray_info_idx: string | null;
+    tray_type: string | null;
+    resolved_profile_path: string | null;
+    load_filaments: string | null;
+    reason: string;
+  } | null;
+  load_filaments_all: string | null;
 };
 
+const COLLAR_CHARM_POLICY = getCollarCharmRolePolicy();
+
+let filamentProfileIndexCache: FilamentProfileIndex | null = null;
+
+function buildFilamentProfileIndex(): FilamentProfileIndex {
+  const byName = new Map<string, string>();
+  const baseNameByFilamentId = new Map<string, string>();
+
+  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(): FilamentProfileIndex {
+  if (!filamentProfileIndexCache) {
+    filamentProfileIndexCache = buildFilamentProfileIndex();
+  }
+
+  return filamentProfileIndexCache;
+}
+
+function resolveFilamentProfileCandidates(
+  trayInfoIdx: string,
+  bambuModel?: string,
+  nozzleDiameter?: string
+): {
+  baseName: string | null;
+  paths: string[];
+  resolution: "exact-model-nozzle" | "model" | "generic" | "unresolved";
+} {
+  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: string[] = [];
+
+  if (modelCode && nozzleDiameter) {
+    candidateNames.push(`${bareName} @BBL ${modelCode} ${nozzleDiameter} nozzle`);
+  }
+  if (modelCode) {
+    candidateNames.push(`${bareName} @BBL ${modelCode}`);
+  }
+  candidateNames.push(bareName, baseName);
+
+  const resolvedPaths: string[] = [];
+  let resolution: "exact-model-nozzle" | "model" | "generic" | "unresolved" = "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: unknown): number | null {
+  if (value === undefined || value === null || value === "") return null;
+  const parsed = Number.parseInt(String(value), 10);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+
+function normalizePrinterFilamentInventory(
+  status: any,
+  bambuModel?: string,
+  nozzleDiameter?: string
+): PrinterFilamentInventory {
+  const rawAms = status?.raw?.ams || status?.ams || {};
+  const trayNow = parseIntegerOrNull(rawAms?.tray_now);
+  const trays: PrinterFilamentInventory["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" as const };
+      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): candidate is string => 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: string | null | undefined): string | null {
+  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: ThreeMFAmsRequirements,
+  inventory: PrinterFilamentInventory
+): {
+  ams_slots: number[];
+  matches: Array<{ filament_position: number; tray_info_idx: string; slot: number; matched_color?: string | null; match_strategy: "color" | "sku-only" }>;
+  missing: Array<{ filament_position: number; tray_info_idx: string | null; required_color?: string | null; reason: "no_sku" | "no_loaded_match" | "color_mismatch" | "exhausted" }>;
+} {
+  const matches: Array<{ filament_position: number; tray_info_idx: string; slot: number; matched_color?: string | null; match_strategy: "color" | "sku-only" }> = [];
+  const missing: Array<{ filament_position: number; tray_info_idx: string | null; required_color?: string | null; reason: "no_sku" | "no_loaded_match" | "color_mismatch" | "exhausted" }> = [];
+  const amsSlots: number[] = [];
+
+  // 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<number>();
+
+  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: "no_loaded_match" | "exhausted" = 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" | "sku-only" = "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: any): Record<string, unknown> {
+  const raw = status?.raw && typeof status.raw === "object" ? status.raw : {};
+  const diagnosticFields: Record<string, unknown> = {};
+
+  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: string): string {
   const normalized = model.trim().toLowerCase();
   if (!VALID_BAMBU_MODELS.includes(normalized as BambuModel)) {
@@ -68,10 +515,79 @@ function resolveBedType(argsBedType: string | undefined): string {
   return bedType;
 }
 
+function resolveBambuStudioCliBedType(argsBedType: string | undefined): string {
+  const bedType = resolveBedType(argsBedType);
+  if (!(VALID_BAMBUSTUDIO_CLI_BED_TYPES as readonly string[]).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: string[], fallback: string): string {
+  return paths.find((candidate) => fs.existsSync(candidate)) || fallback;
+}
+
+function defaultSlicerPathFor(slicerType: SlicerType): string {
+  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: Record<string, unknown> | undefined): {
+  slicerType: SlicerType;
+  slicerPath: string;
+  slicerProfile: string;
+} {
+  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 };
+}
 
 type RuntimeConfig = {
   transport: "stdio" | "streamable-http";
@@ -112,6 +628,57 @@ function parseCsvEnv(value: string | undefined): Set<string> {
   return new Set(value.split(",").map((e) => e.trim()).filter((e) => e.length > 0));
 }
 
+async function resolveSlicerProfilePath(
+  requestedProfile: string | undefined,
+  templatePath: string | undefined,
+  tempDir: string
+): Promise<string | undefined> {
+  if (requestedProfile) {
+    return requestedProfile;
+  }
+
+  if (templatePath) {
+    return resolveTemplateSlicerProfilePath(templatePath, tempDir);
+  }
+
+  return undefined;
+}
+
+async function resolveTemplateSlicerProfilePath(
+  templatePath: string,
+  tempDir: string
+): Promise<string> {
+  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: any): boolean {
+  return typeof args?.slicer_profile === "string" && args.slicer_profile.trim().length > 0;
+}
+
+async function resolveTemplateFirstSlicerProfilePath(
+  args: any,
+  configuredProfile: string | undefined,
+  template3mfPath: string | undefined,
+  tempDir: string
+): Promise<string | undefined> {
+  if (hasExplicitSlicerProfile(args)) {
+    return configuredProfile || undefined;
+  }
+
+  if (template3mfPath) {
+    return resolveTemplateSlicerProfilePath(template3mfPath, tempDir);
+  }
+
+  return configuredProfile || undefined;
+}
+
 function readRuntimeConfig(): RuntimeConfig {
   const rawTransport = process.env.MCP_TRANSPORT?.trim().toLowerCase();
   const transport =
@@ -139,6 +706,298 @@ type StructuredToolError = {
   tool: string;
 };
 
+type UploadGcodeSource = {
+  filePath: string;
+  cleanupDir?: string;
+};
+
+function expandUserPath(rawPath: string): string {
+  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: string): string | undefined {
+  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: string): boolean {
+  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: string, label: string): string {
+  const candidate = expandUserPath(rawPath);
+  try {
+    if (!fs.statSync(candidate).isFile()) {
+      throw new Error(`${label} is not a file: ${candidate}`);
+    }
+  } catch (error) {
+    if ((error as 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: string, gcode: string): UploadGcodeSource {
+  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: Record<string, unknown>): UploadGcodeSource {
+  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",
+] as const;
+
+type BambuNetworkPrintMethod = typeof BAMBU_NETWORK_PRINT_METHODS[number];
+
+function resolveBambuNetworkPrintMethod(
+  rawMethod: string | undefined,
+  connectionType: string
+): BambuNetworkPrintMethod {
+  const defaultMethod = connectionType === "lan" ? "start_local_print" : "start_print";
+  const method = (rawMethod || defaultMethod).trim();
+
+  if (!(BAMBU_NETWORK_PRINT_METHODS as readonly string[]).includes(method)) {
+    throw new Error(
+      `Invalid bambu_network_method: "${method}". Valid methods: ${BAMBU_NETWORK_PRINT_METHODS.join(", ")}`
+    );
+  }
+
+  return method as BambuNetworkPrintMethod;
+}
+
+function toBridgeMethod(method: BambuNetworkPrintMethod): string {
+  return `net.${method}`;
+}
+
+function stringifyBridgeJson(value: unknown): string | undefined {
+  if (value === undefined || value === null) return undefined;
+  if (typeof value === "string") return value;
+  return JSON.stringify(value);
+}
+
+function redactPrintParams(params: Record<string, unknown>): Record<string, unknown> {
+  return {
+    ...params,
+    password: params.password ? "[redacted]" : "",
+  };
+}
+
+function parseLooseSlicerConfig(content: string): Record<string, any> {
+  try {
+    return JSON.parse(content);
+  } catch {
+    const config: Record<string, any> = {};
+    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: Record<string, any>) {
+  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]
+        : [],
+  };
+}
+
+type TemplateEntry = {
+  name: string;
+  path: string;
+  source_type: "3mf" | "json" | "config";
+  relative_path: string;
+};
+type TemplateSourceType = TemplateEntry["source_type"];
+
+function sanitizeTemplateName(templateName: string): string {
+  return templateName
+    .trim()
+    .replace(/\\/g, "/")
+    .replace(/^\/+|\/+$/g, "")
+    .replace(/\s+/g, "_")
+    .replace(/[^A-Za-z0-9/_-]/g, "_");
+}
+
+function scanTemplateRegistry(templateDir: string): TemplateEntry[] {
+  if (!fs.existsSync(templateDir)) {
+    return [];
+  }
+
+  const allowedExtensions = new Set([".3mf", ".json", ".config"]);
+  const entries: TemplateEntry[] = [];
+  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 });
 }
@@ -146,6 +1005,7 @@ if (!fs.existsSync(TEMP_DIR)) {
 class BambuPrinterMCPServer {
   private server: Server;
   private bambu: BambuImplementation;
+  private bambuNetwork: BambuNetworkBridge;
   private stlManipulator: STLManipulator;
   private readonly runtimeConfig: RuntimeConfig;
   private httpRuntime?: { transport: StreamableHTTPServerTransport; httpServer: HttpServer };
@@ -166,6 +1026,7 @@ class BambuPrinterMCPServer {
     );
 
     this.bambu = new BambuImplementation();
+    this.bambuNetwork = new BambuNetworkBridge();
     this.stlManipulator = new STLManipulator(TEMP_DIR);
 
     this.setupHandlers();
@@ -210,11 +1071,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" },
               ],
             },
           },
@@ -246,56 +1109,613 @@ class BambuPrinterMCPServer {
     }
   }
 
-  setupResourceHandlers() {
-    this.server.setRequestHandler(ListResourcesRequestSchema, async () => {
-      return {
-        resources: [
-          {
-            uri: `printer://${DEFAULT_HOST}/status`,
-            name: "Bambu Printer Status",
-            mimeType: "application/json",
-            description: "Current status of the Bambu Lab printer"
-          },
-          {
-            uri: `printer://${DEFAULT_HOST}/files`,
-            name: "Bambu Printer Files",
-            mimeType: "application/json",
-            description: "List of files on the Bambu Lab printer"
-          }
-        ],
-        templates: [
-          {
-            uriTemplate: "printer://{host}/status",
-            name: "Bambu Printer Status",
-            mimeType: "application/json"
-          },
-          {
-            uriTemplate: "printer://{host}/files",
-            name: "Bambu Printer Files",
-            mimeType: "application/json"
-          }
-        ]
-      };
-    });
+  private bridgeOptionsFromArgs(args: Record<string, any> | undefined): BambuNetworkBridgeOptions {
+    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,
+    };
+  }
 
-    this.server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
-      const uri = request.params.uri;
-      const match = uri.match(/^printer:\/\/([^\/]+)\/(.+)$/);
+  private async ensurePrintableThreeMFPath(
+    args: Record<string, any>,
+    printModel: string,
+    printPreset: string | undefined,
+    bedType?: string
+  ): Promise<{ threeMFPath: string; autoSliced: boolean }> {
+    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 (!match) {
-        throw new McpError(ErrorCode.InvalidRequest, `Invalid resource URI: ${uri}`);
-      }
+    if (hasGcode) {
+      return { threeMFPath, autoSliced: false };
+    }
 
-      const [, host, resource] = match;
-      const bambuSerial = DEFAULT_BAMBU_SERIAL;
-      const bambuToken = DEFAULT_BAMBU_TOKEN;
-      let content;
+    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.'
+      );
+    }
 
-      if (resource === "status") {
-        content = await this.bambu.getStatus(host || DEFAULT_HOST, bambuSerial, bambuToken);
-      } else if (resource === "files") {
-        content = await this.bambu.getFiles(host || DEFAULT_HOST, bambuSerial, bambuToken);
-      } else {
+    console.log(`3MF has no gcode - auto-slicing with ${slicerType} for ${printModel}`);
+    const autoSliceOptions: BambuSliceOptions = {
+      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 };
+  }
+
+  private async resolveAmsPrintSettings(
+    threeMFPath: string,
+    args: Record<string, any>,
+    host: string,
+    bambuSerial: string,
+    bambuToken: string,
+    printModel?: string,
+    printNozzle?: string
+  ): Promise<{ useAMS: boolean; finalAmsMapping?: number[]; finalAmsSlots?: number[] }> {
+    const parsed3MFData = await parse3MF(threeMFPath);
+    let parsedAmsMapping: number[] | undefined;
+
+    if (parsed3MFData.slicerConfig?.ams_mapping) {
+      const slots = normalizeAmsMappingObject(parsed3MFData.slicerConfig.ams_mapping as Record<string, unknown>);
+      if (slots.length > 0) {
+        parsedAmsMapping = slots;
+      }
+    }
+
+    let finalAmsMapping = parsedAmsMapping;
+    let finalAmsSlots: number[] | undefined;
+    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: number[] | undefined;
+      if (Array.isArray(args.ams_mapping)) {
+        userMappingOverride = args.ams_mapping.map((v: unknown, i: number) =>
+          normalizeBridgeAmsTrayValue(v, `ams_mapping[${i}]`)
+        );
+      } else if (args.ams_mapping && typeof args.ams_mapping === 'object') {
+        userMappingOverride = normalizeAmsMappingObject(args.ams_mapping as Record<string, unknown>);
+      }
+      if (userMappingOverride && userMappingOverride.length > 0) {
+        finalAmsMapping = userMappingOverride;
+        finalAmsSlots = undefined;
+        useAMS = true;
+      }
+    }
+
+    if (!hasUserAmsMapping && hasUserAmsSlots) {
+      const userSlots = args.ams_slots.map((slot: unknown, i: number) =>
+        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 };
+  }
+
+  private async print3mfViaBambuNetwork(
+    args: Record<string, any>,
+    host: string,
+    bambuSerial: string,
+    bambuToken: string
+  ): Promise<Record<string, unknown>> {
+    if (!args?.three_mf_path) {
+      throw new Error("Missing required parameter: three_mf_path");
+    }
+
+    const printModel = await this.resolveBambuModel(args?.bambu_model as string | undefined);
+    const printBedType = resolveBedType(args?.bed_type as string | undefined);
+    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: Record<string, unknown> = {
+      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 as { ok?: unknown }).ok === false) {
+      throw new Error(`FULU BambuNetwork bridge method ${bridgeMethod} failed: ${String((bridgeResult as { error?: unknown }).error || "unknown bridge error")}`);
+    }
+    if (
+      typeof bridgeResult === "object" &&
+      bridgeResult !== null &&
+      typeof (bridgeResult as { value?: unknown }).value === "number" &&
+      (bridgeResult as { value: number }).value !== 0
+    ) {
+      const value = (bridgeResult as { value: number }).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),
+    };
+  }
+
+  private async getResolvedPrinterFilamentInventory(
+    host: string,
+    bambuSerial: string,
+    bambuToken: string,
+    bambuModel?: string,
+    nozzleDiameter?: string
+  ): Promise<PrinterFilamentInventory> {
+    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;
+  }
+
+  private async inspectSliceSettings(sourcePath: string) {
+    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 || {}) as Record<string, any>;
+      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,
+    };
+  }
+
+  private async resolveCollarCharmPrepared3MF(
+    sourcePath: string,
+    template3mfPath: string | undefined,
+    slicerType: SlicerType,
+    slicerPath: string,
+    slicerProfile: string | undefined,
+    printModel: string,
+    printNozzle: string,
+    bedType: string,
+    host: string,
+    bambuSerial: string,
+    bambuToken: string
+  ): Promise<string> {
+    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: any) {
+      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: BambuSliceOptions = {
+      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
+    );
+  }
+
+  private async preflightCollarCharmPolicy(
+    host: string,
+    bambuSerial: string,
+    bambuToken: string,
+    bambuModel: string,
+    nozzleDiameter: string
+  ): Promise<PrinterFilamentInventory> {
+    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;
+  }
+
+  private listTemplateRegistry(templateDir?: string): {
+    template_dir: string;
+    templates: TemplateEntry[];
+  } {
+    const resolvedTemplateDir = templateDir && templateDir.trim().length > 0
+      ? templateDir
+      : DEFAULT_TEMPLATE_DIR;
+    return {
+      template_dir: resolvedTemplateDir,
+      templates: scanTemplateRegistry(resolvedTemplateDir),
+    };
+  }
+
+  private resolveTemplatePath(
+    templateName?: string,
+    templateDir?: string,
+    sourceTypes?: TemplateSourceType[]
+  ): string | undefined {
+    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"] as TemplateSourceType[]);
+    const match = searchTypes
+      .map((sourceType) => nameMatches.find((entry) => entry.source_type === sourceType))
+      .find((entry): entry is TemplateEntry => 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;
+  }
+
+  private saveTemplate(sourcePath: string, templateName?: string, templateDir?: string) {
+    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: TemplateSourceType =
+      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 {
+        resources: [
+          {
+            uri: `printer://${DEFAULT_HOST}/status`,
+            name: "Bambu Printer Status",
+            mimeType: "application/json",
+            description: "Current status of the Bambu Lab printer"
+          },
+          {
+            uri: `printer://${DEFAULT_HOST}/files`,
+            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: [
+          {
+            uriTemplate: "printer://{host}/status",
+            name: "Bambu Printer Status",
+            mimeType: "application/json"
+          },
+          {
+            uriTemplate: "printer://{host}/files",
+            name: "Bambu Printer Files",
+            mimeType: "application/json"
+          },
+          {
+            uriTemplate: "printer://{host}/hms",
+            name: "Bambu Printer HMS Diagnostics",
+            mimeType: "application/json"
+          }
+        ]
+      };
+    });
+
+    this.server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+      const uri = request.params.uri;
+      const match = uri.match(/^printer:\/\/([^\/]+)\/(.+)$/);
+
+      if (!match) {
+        throw new McpError(ErrorCode.InvalidRequest, `Invalid resource URI: ${uri}`);
+      }
+
+      const [, host, resource] = match;
+      const bambuSerial = DEFAULT_BAMBU_SERIAL;
+      const bambuToken = DEFAULT_BAMBU_TOKEN;
+      let content;
+
+      if (resource === "status") {
+        content = await this.bambu.getStatus(host || DEFAULT_HOST, bambuSerial, bambuToken);
+      } 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}`);
       }
 
@@ -336,6 +1756,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",
@@ -387,6 +1870,110 @@ class BambuPrinterMCPServer {
               required: ["stl_path"]
             }
           },
+          {
+            name: "list_templates",
+            description: "List saved slicing templates from the local template registry directory.",
+            inputSchema: {
+              type: "object",
+              properties: {
+                template_dir: {
+                  type: "string",
+                  description: "Optional template directory override. Defaults to BAMBU_TEMPLATE_DIR or the server's configured local template registry."
+                }
+              }
+            }
+          },
+          {
+            name: "save_template",
+            description: "Copy a 3MF, JSON, or config file into the local template registry and register it under a template name.",
+            inputSchema: {
+              type: "object",
+              properties: {
+                source_path: {
+                  type: "string",
+                  description: "Path to a local .3mf, .json, or .config file to save into the template registry."
+                },
+                template_name: {
+                  type: "string",
+                  description: "Optional template name. Defaults to the source filename without extension."
+                },
+                template_dir: {
+                  type: "string",
+                  description: "Optional template directory override. Defaults to BAMBU_TEMPLATE_DIR or the server's configured local template registry."
+                }
+              },
+              required: ["source_path"]
+            }
+          },
+          {
+            name: "get_slice_settings",
+            description: "Inspect slicer settings from a saved 3MF template or a JSON/config slicer profile without slicing anything.",
+            inputSchema: {
+              type: "object",
+              properties: {
+                source_path: {
+                  type: "string",
+                  description: "Path to a 3MF template, extracted project_settings.config, or slicer profile JSON."
+                },
+                template_name: {
+                  type: "string",
+                  description: "Optional named template from the local registry. If provided, resolves source_path automatically."
+                },
+                template_dir: {
+                  type: "string",
+                  description: "Optional template directory override when resolving template_name."
+                }
+              }
+            }
+          },
+          {
+            name: "slice_with_template",
+            description: "Slice an STL or 3MF using a named template from the local registry. This is a higher-level wrapper around slice_stl for template-based workflows.",
+            inputSchema: {
+              type: "object",
+              properties: {
+                stl_path: { type: "string", description: "Path to the STL or 3MF file to slice" },
+                template_name: { type: "string", description: "Named template from the local registry." },
+                template_dir: { type: "string", description: "Optional template directory override when resolving template_name." },
+                bambu_model: {
+                  type: "string",
+                  enum: ["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.",
@@ -396,16 +1983,26 @@ class BambuPrinterMCPServer {
                 stl_path: { type: "string", description: "Path to the STL or 3MF file to slice" },
                 bambu_model: {
                   type: "string",
-                  enum: ["p1s", "p1p", "x1c", "x1e", "a1", "a1mini", "h2d"],
+                  enum: ["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",
-                  description: "Type of slicer to use (bambustudio, prusaslicer, cura, slic3r, orcaslicer) (default: bambustudio)"
+                  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." },
@@ -414,6 +2011,7 @@ class BambuPrinterMCPServer {
                 clone_objects: { type: "string", description: "Duplicate specific objects on the plate. Comma-separated clone counts per object index, e.g. '1,3,1,10' clones object 0 once, object 1 three times, etc." },
                 skip_objects: { type: "string", description: "Skip specific objects during slicing by index. Comma-separated, e.g. '3,5,10'. Useful for multi-object 3MFs where you only want to print some parts." },
                 load_filaments: { type: "string", description: "Override filament profiles. Semicolon-separated paths to filament JSON configs, e.g. 'pla_basic.json;petg_cf.json'." },
+                filament_profile: { type: "string", description: "Compatibility alias for load_filaments. Semicolon-separated Orca/Bambu filament profile JSON paths." },
                 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." },
@@ -440,76 +2038,403 @@ class BambuPrinterMCPServer {
               }
             }
           },
+          {
+            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" },
+                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: "set_airduct_mode",
+            description: "Set H2/P2 airduct mode to cooling or heating.",
+            inputSchema: {
+              type: "object",
+              properties: {
+                mode: {
+                  type: "string",
+                  enum: ["cooling", "heating"],
+                  description: "Airduct mode to apply"
+                },
+                host: { type: "string", description: "Hostname or IP of the printer (default: value from env)" },
+                bambu_serial: { type: "string", description: "Serial number (default: value from env)" },
+                bambu_token: { type: "string", description: "Access token (default: value from env)" }
+              },
+              required: ["mode"]
+            }
+          },
+          {
+            name: "reread_ams_rfid",
+            description: "Trigger a Bambu AMS RFID re-read for one AMS slot. This can move AMS filament; use only when the printer is idle and unloaded.",
+            inputSchema: {
+              type: "object",
+              properties: {
+                ams_id: { type: "number", description: "AMS unit index from 0 to 3" },
+                slot_id: { type: "number", description: "Slot index within that AMS, from 0 to 3" },
+                host: { type: "string", description: "Hostname or IP of the printer (default: value from env)" },
+                bambu_serial: { type: "string", description: "Serial number (default: value from env)" },
+                bambu_token: { type: "string", description: "Access token (default: value from env)" }
+              },
+              required: ["ams_id", "slot_id"]
+            }
+          },
+          {
+            name: "set_temperature",
+            description: "Set the temperature of a printer component (bed, nozzle)",
+            inputSchema: {
+              type: "object",
+              properties: {
+                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"]
             }
           },
           {
@@ -521,30 +2446,95 @@ 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: ["three_mf_path", "bambu_model"]
+              required: ["bambu_model"]
             }
           },
           {
@@ -609,9 +2599,15 @@ 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) as 'prusaslicer' | 'cura' | 'slic3r' | 'orcaslicer' | 'bambustudio';
-      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?: TemplateSourceType[]) =>
+        this.resolveTemplatePath(requestedTemplateName, requestedTemplateDir, sourceTypes);
+      const explicitTemplatePath = String(args?.template_3mf_path || DEFAULT_TEMPLATE_3MF_PATH);
 
       try {
         let result;
@@ -621,26 +2617,164 @@ class BambuPrinterMCPServer {
             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 "upload_gcode": {
-            if (!args?.filename || !args?.gcode) {
-              throw new Error("Missing required parameters: filename and gcode");
+          case "bambu_network_bridge_status": {
+            const bridgeArgs = args as Record<string, any> | undefined;
+            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,
+              };
             }
-            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 "bambu_network_call": {
+            if (!args?.method) {
+              throw new Error("Missing required parameter: method");
+            }
+            const bridgeArgs = args as Record<string, any>;
+            const payload = bridgeArgs.payload && typeof bridgeArgs.payload === "object"
+              ? bridgeArgs.payload as Record<string, unknown>
+              : {};
+            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 as Record<string, any>, host, bambuSerial, bambuToken);
+            break;
+          }
+
+          case "camera_snapshot": {
+            const snapshotModel = (args?.bambu_model as string | undefined) ?? process.env.BAMBU_MODEL ?? process.env.BAMBU_PRINTER_MODEL;
+            result = await this.bambu.cameraSnapshot(host, bambuSerial, bambuToken, {
+              savePath: args?.save_path ? String(args.save_path) : undefined,
+              timeoutMs: args?.timeout_ms !== undefined ? Number(args.timeout_ms) : undefined,
+              bambuModel: snapshotModel ? String(snapshotModel) : undefined,
+              experimental: Boolean(args?.experimental),
+              ffmpegPath: args?.ffmpeg_path ? String(args.ffmpeg_path) : undefined,
+            });
+            break;
+          }
+
+          case "delete_printer_file":
+            if (!args?.filename) {
+              throw new Error("Missing required parameter: filename");
+            }
+            result = await this.bambu.deleteFile(
+              host,
+              bambuSerial,
+              bambuToken,
+              String(args.filename),
+              args.confirm
             );
             break;
+
+          case "upload_gcode": {
+            if (!args?.filename) {
+              throw new Error("Missing required parameter: filename");
+            }
+            const uploadSource = resolveUploadGcodeSource(args as Record<string, unknown>);
+            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 });
+              }
+            }
+            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 as string | undefined);
+            }
             result = await this.bambu.uploadFile(
               host, bambuSerial, bambuToken,
               String(args.file_path), String(args.filename),
@@ -648,10 +2782,12 @@ class BambuPrinterMCPServer {
             );
             break;
 
+          case "start_print":
           case "start_print_job":
             if (!args?.filename) {
               throw new Error("Missing required parameter: filename");
             }
+            await this.resolveBambuModel(args?.bambu_model as string | undefined);
             result = await this.bambu.startJob(host, bambuSerial, bambuToken, String(args.filename));
             break;
 
@@ -659,6 +2795,45 @@ class BambuPrinterMCPServer {
             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");
@@ -669,6 +2844,57 @@ class BambuPrinterMCPServer {
             );
             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: unknown) => 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");
@@ -713,12 +2939,113 @@ 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 as Record<string, unknown> | undefined);
+            const sliceModel = await this.resolveBambuModel(args?.bambu_model as string | undefined);
+            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: BambuSliceOptions = {};
+            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 as string | undefined);
+            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 as Record<string, unknown> | undefined);
             const sliceModel = await this.resolveBambuModel(args?.bambu_model as string | undefined);
             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);
 
@@ -730,8 +3057,20 @@ class BambuPrinterMCPServer {
             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) sliceBambuOptions.loadFilaments = String(args.load_filaments);
+            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 as string | undefined);
             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);
@@ -741,10 +3080,34 @@ class BambuPrinterMCPServer {
             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,
-              slicerProfile || undefined,
+              activeSlicerProfile,
               undefined, // progressCallback
               printerPreset,
               sliceBambuOptions
@@ -756,14 +3119,31 @@ 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 as Record<string, any>, 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 as Record<string, unknown> | undefined);
             const printModel = await this.resolveBambuModel(args?.bambu_model as string | undefined);
             const printBedType = resolveBedType(args?.bed_type as string | undefined);
             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);
 
@@ -776,15 +3156,37 @@ class BambuPrinterMCPServer {
                 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: BambuSliceOptions = {
                   uptodate: true,
                   ensureOnBed: true,
                   minSave: true,
                   skipModifiedGcodes: true,
+                  bedType: printBedType,
                 };
+                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, slicerProfile || undefined,
+                  threeMFPath, slicerType, slicerPath, activeSlicerProfile,
                   undefined, // progressCallback
                   printPreset,
                   autoSliceOptions
@@ -792,42 +3194,93 @@ class BambuPrinterMCPServer {
                 console.log("Auto-sliced to: " + threeMFPath);
               }
             } catch (sliceCheckErr: any) {
+              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: number[] | undefined;
-            if (parsed3MFData.slicerConfig?.ams_mapping) {
-              const slots = Object.values(parsed3MFData.slicerConfig.ams_mapping)
-                .filter(v => typeof v === 'number') as number[];
+            if (!isH2Print && parsed3MFData.slicerConfig?.ams_mapping) {
+              const slots = normalizeAmsMappingObject(parsed3MFData.slicerConfig.ams_mapping as Record<string, unknown>);
               if (slots.length > 0) {
-                parsedAmsMapping = slots.sort((a, b) => a - b);
+                parsedAmsMapping = slots;
               }
             }
 
             let finalAmsMapping = parsedAmsMapping;
+            let finalAmsSlots: number[] | undefined;
             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 (args?.ams_mapping) {
+            if (hasUserAmsMapping) {
               let userMappingOverride: number[] | undefined;
               if (Array.isArray(args.ams_mapping)) {
-                userMappingOverride = args.ams_mapping.filter((v: any) => typeof v === 'number');
-              } else if (typeof args.ams_mapping === 'object') {
-                userMappingOverride = Object.values(args.ams_mapping)
-                  .filter((v: any) => typeof v === 'number')
-                  .sort((a: any, b: any) => a - b) as number[];
+                userMappingOverride = args.ams_mapping.map((v: unknown, i: number) =>
+                  normalizeBridgeAmsTrayValue(v, `ams_mapping[${i}]`)
+                );
+              } else if (args.ams_mapping && typeof args.ams_mapping === 'object') {
+                userMappingOverride = normalizeAmsMappingObject(args.ams_mapping as Record<string, unknown>);
               }
               if (userMappingOverride && userMappingOverride.length > 0) {
                 finalAmsMapping = userMappingOverride;
                 useAMS = true;
               }
             }
+            if (hasUserAmsSlots) {
+              const userSlots = (args.ams_slots as unknown[]).filter((v: any) => 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;
             }
 
@@ -837,9 +3290,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,
@@ -851,6 +3305,92 @@ class BambuPrinterMCPServer {
             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 as Record<string, unknown> | undefined);
+            const printModel = await this.resolveBambuModel(args?.bambu_model as string | undefined);
+            const printBedType = resolveBedType(args?.bed_type as string | undefined);
+            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");
             result = await this.stlManipulator.mergeVertices(