bambu-printer-mcp 1.0.4 → 1.0.8

package/src/index.ts

@@ -16,7 +16,14 @@ 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 {
+  STLManipulator,
+  SLICER_TYPES,
+  normalizeSlicerType,
+  type BambuSliceOptions,
+  type SlicerType,
+} from "./stl/stl-manipulator.js";
+import { BambuNetworkBridge, type BambuNetworkBridgeOptions } from "./bambu-network-bridge.js";
 import { parse3MF } from './3mf_parser.js';
 import { BambuImplementation } from "./printers/bambu.js";
 
@@ -25,6 +32,7 @@ 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_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
@@ -70,8 +78,60 @@ function resolveBedType(argsBedType: string | undefined): string {
 
 // 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 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.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";
@@ -139,6 +199,147 @@ 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]" : "",
+  };
+}
+
 if (!fs.existsSync(TEMP_DIR)) {
   fs.mkdirSync(TEMP_DIR, { recursive: true });
 }
@@ -146,6 +347,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 +368,7 @@ class BambuPrinterMCPServer {
     );
 
     this.bambu = new BambuImplementation();
+    this.bambuNetwork = new BambuNetworkBridge();
     this.stlManipulator = new STLManipulator(TEMP_DIR);
 
     this.setupHandlers();
@@ -193,7 +396,7 @@ class BambuPrinterMCPServer {
       return validateBambuModel(fromArgs);
     }
 
-    // No model from args or env — ask the user via elicitation
+    // No model from args or env - ask the user via elicitation
     try {
       const result = await this.server.elicitInput({
         mode: "form" as const,
@@ -230,7 +433,7 @@ class BambuPrinterMCPServer {
         "Printer model selection was cancelled. Cannot proceed without knowing the printer model."
       );
     } catch (elicitError: any) {
-      // Elicitation not supported by this client — fall back to a clear error
+      // Elicitation not supported by this client - fall back to a clear error
       const msg = elicitError?.message || String(elicitError);
       if (
         elicitError?.code === -32601 || elicitError?.code === -32600 ||
@@ -246,6 +449,232 @@ class BambuPrinterMCPServer {
     }
   }
 
+  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,
+    };
+  }
+
+  private async ensurePrintableThreeMFPath(
+    args: Record<string, any>,
+    printModel: string,
+    printPreset: string | undefined
+  ): 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 (hasGcode) {
+      return { threeMFPath, autoSliced: false };
+    }
+
+    console.log(`3MF has no gcode - auto-slicing with ${slicerType} for ${printModel}`);
+    const autoSliceOptions: BambuSliceOptions = {
+      uptodate: true,
+      ensureOnBed: true,
+      minSave: true,
+      skipModifiedGcodes: true,
+    };
+    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>
+  ): Promise<{ useAMS: boolean; finalAmsMapping?: number[] }> {
+    const parsed3MFData = await parse3MF(threeMFPath);
+    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 (slots.length > 0) {
+        parsedAmsMapping = slots.sort((a, b) => a - b);
+      }
+    }
+
+    let finalAmsMapping = parsedAmsMapping;
+    const explicitUseAMS = args?.use_ams !== undefined;
+    let useAMS = explicitUseAMS ? Boolean(args.use_ams) : (!!finalAmsMapping && finalAmsMapping.length > 0);
+
+    if (args?.ams_mapping) {
+      let 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[];
+      }
+      if (userMappingOverride && userMappingOverride.length > 0) {
+        finalAmsMapping = userMappingOverride;
+        useAMS = true;
+      }
+    }
+
+    if (args?.use_ams === false) {
+      finalAmsMapping = undefined;
+      useAMS = false;
+    }
+    if ((!finalAmsMapping || finalAmsMapping.length === 0) && !explicitUseAMS) {
+      useAMS = false;
+    }
+
+    return { useAMS, finalAmsMapping };
+  }
+
+  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);
+    const { useAMS, finalAmsMapping } = await this.resolveAmsPrintSettings(threeMFPath, args);
+    const threeMfFilename = path.basename(threeMFPath);
+    const projectName = String(args?.project_name || threeMfFilename.replace(/\.3mf$/i, ''));
+    const presetName = String(args?.preset_name || `${projectName}_plate_${plateIndex + 1}`);
+    const clientJobId = args?.client_job_id !== undefined ? Number(args.client_job_id) : Date.now();
+
+    const amsMapping = stringifyBridgeJson(args?.ams_mapping_bridge ?? finalAmsMapping);
+    const 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,
+      params: redactPrintParams(params),
+    };
+  }
+
   setupResourceHandlers() {
     this.server.setRequestHandler(ListResourcesRequestSchema, async () => {
       return {
@@ -401,12 +830,13 @@ class BambuPrinterMCPServer {
                 },
                 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_path: { type: "string", description: "Path to the slicer executable (default: value from env or a platform default)" },
                 slicer_profile: { type: "string", description: "Path to the slicer profile/config file (optional, overrides bambu_model preset)" },
                 nozzle_diameter: { type: "string", description: "Nozzle diameter in mm (default: 0.4)" },
-                uptodate: { type: "boolean", description: "Refresh 3MF preset configs to match the latest BambuStudio version. Use when slicing downloaded or older 3MF files to prevent stale-config failures." },
+                uptodate: { type: "boolean", description: "Refresh 3MF preset configs to match the latest Bambu-compatible slicer presets. Use when slicing downloaded or older 3MF files to prevent stale-config failures." },
                 repetitions: { type: "number", description: "Print N identical copies of the model. Each copy gets its own plate placement. Example: 3 prints three copies." },
                 orient: { type: "boolean", description: "Auto-orient the model for optimal printability (minimize supports, maximize bed adhesion). Recommended for raw STL imports that lack a pre-set orientation." },
                 arrange: { type: "boolean", description: "Auto-arrange all objects on the build plate with optimal spacing. Recommended when importing STLs or adding multiple objects. Set false to preserve existing plate layout." },
@@ -414,6 +844,7 @@ class BambuPrinterMCPServer {
                 clone_objects: { type: "string", description: "Duplicate specific objects on the plate. Comma-separated clone counts per object index, e.g. '1,3,1,10' clones object 0 once, object 1 three times, etc." },
                 skip_objects: { type: "string", description: "Skip specific objects during slicing by index. Comma-separated, e.g. '3,5,10'. Useful for multi-object 3MFs where you only want to print some parts." },
                 load_filaments: { type: "string", description: "Override filament profiles. Semicolon-separated paths to filament JSON configs, e.g. 'pla_basic.json;petg_cf.json'." },
+                filament_profile: { type: "string", description: "Compatibility alias for load_filaments. Semicolon-separated Orca/Bambu filament profile JSON paths; flat self-contained profiles are safest because Orca does not resolve every inherited system filament setting from arbitrary file paths." },
                 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,6 +871,97 @@ 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", "x1c", "x1e", "a1", "a1mini", "h2d"],
+                  description: "REQUIRED: Bambu Lab printer model. Ask the user if not known. Using the wrong model can damage the printer."
+                },
+                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"], 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_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: "upload_gcode",
             description: "Upload a G-code file to the Bambu Lab printer",
@@ -447,12 +969,17 @@ class BambuPrinterMCPServer {
               type: "object",
               properties: {
                 filename: { type: "string", description: "Name for the file on the printer" },
-                gcode: { type: "string", description: "G-code content to upload" },
+                gcode: { type: "string", description: "G-code content to upload, or a readable local .gcode path. For large files, prefer gcode_path." },
+                gcode_path: { type: "string", description: "Local path to a .gcode file to upload. This avoids sending large G-code bodies through the MCP request." },
                 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: ["filename"],
+              anyOf: [
+                { required: ["gcode"] },
+                { required: ["gcode_path"] }
+              ]
             }
           },
           {
@@ -464,6 +991,11 @@ class BambuPrinterMCPServer {
                 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", "x1c", "x1e", "a1", "a1mini", "h2d"],
+                  description: "Required when print is true. Bambu Lab printer model used as a safety confirmation before starting the uploaded file."
+                },
                 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)" }
@@ -471,6 +1003,25 @@ class BambuPrinterMCPServer {
               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", "x1c", "x1e", "a1", "a1mini", "h2d"],
+                  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",
@@ -478,11 +1029,16 @@ class BambuPrinterMCPServer {
               type: "object",
               properties: {
                 filename: { type: "string", description: "Name of the file to print" },
+                bambu_model: {
+                  type: "string",
+                  enum: ["p1s", "p1p", "x1c", "x1e", "a1", "a1mini", "h2d"],
+                  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"]
+              required: ["filename", "bambu_model"]
             }
           },
           {
@@ -524,14 +1080,35 @@ class BambuPrinterMCPServer {
                   enum: ["p1s", "p1p", "x1c", "x1e", "a1", "a1mini", "h2d"],
                   description: "REQUIRED: Bambu Lab printer model. Ask the user if not known. Using the wrong model can damage the printer."
                 },
+                connection_mode: {
+                  type: "string",
+                  enum: ["lan_mqtt_ftps", "bambu_network"],
+                  description: "Print path to use: lan_mqtt_ftps uses this MCP's direct local MQTT/FTPS path; bambu_network uses FULU OrcaSlicer-bambulab's restored BambuNetwork bridge."
+                },
+                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"],
                   description: "Bed plate type currently installed (default: textured_plate)"
                 },
+                plate_index: { type: "number", description: "Zero-based plate index to print from the sliced 3MF (default: 0)" },
                 host: { type: "string", description: "Hostname or IP of the printer (default: value from env)" },
                 bambu_serial: { type: "string", description: "Serial number (default: value from env)" },
                 bambu_token: { type: "string", description: "Access token (default: value from env)" },
+                slicer_type: {
+                  type: "string",
+                  enum: SLICER_SCHEMA_VALUES,
+                  description: "Slicer to use only if auto-slicing an unsliced 3MF. Use orcaslicer-bambulab for FULU's OrcaSlicer-bambulab fork; aliases such as fulu-orca and orca-studio are accepted."
+                },
+                slicer_path: { type: "string", description: "Path to the slicer executable for auto-slicing (default: value from env or a platform default)" },
+                slicer_profile: { type: "string", description: "Path to an optional slicer profile/config file for auto-slicing" },
                 use_ams: { type: "boolean", description: "Whether to use the AMS (default: auto-detect from 3MF)" },
                 ams_mapping: {
                   type: "array",
@@ -541,6 +1118,7 @@ class BambuPrinterMCPServer {
                 bed_leveling: { type: "boolean", description: "Enable auto bed leveling (default: true)" },
                 flow_calibration: { type: "boolean", description: "Enable flow calibration (default: true)" },
                 vibration_calibration: { type: "boolean", description: "Enable vibration calibration (default: true)" },
+                layer_inspect: { type: "boolean", description: "Enable first-layer inspection where supported (default: printer/profile behavior)" },
                 timelapse: { type: "boolean", description: "Enable timelapse recording (default: false)" },
                 nozzle_diameter: { type: "string", description: "Nozzle diameter in mm for auto-slicing (default: 0.4)" }
               },
@@ -609,10 +1187,6 @@ 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);
-
       try {
         let result;
 
@@ -625,15 +1199,56 @@ class BambuPrinterMCPServer {
             result = await this.bambu.getFiles(host, bambuSerial, bambuToken);
             break;
 
+          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,
+              };
+            }
+            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 "upload_gcode": {
-            if (!args?.filename || !args?.gcode) {
-              throw new Error("Missing required parameters: filename and gcode");
+            if (!args?.filename) {
+              throw new Error("Missing required parameter: filename");
+            }
+            const uploadSource = resolveUploadGcodeSource(args 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 });
+              }
             }
-            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;
           }
 
@@ -641,6 +1256,9 @@ class BambuPrinterMCPServer {
             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 +1266,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;
 
@@ -717,6 +1337,7 @@ class BambuPrinterMCPServer {
             if (!args?.stl_path) {
               throw new Error("Missing required parameter: stl_path");
             }
+            const { slicerType, slicerPath, slicerProfile } = resolveSlicerConfig(args);
             const sliceModel = await this.resolveBambuModel(args?.bambu_model as string | undefined);
             const nozzleDiam = String(args?.nozzle_diameter || DEFAULT_NOZZLE_DIAMETER);
             // Resolve printer preset for BambuStudio slicer
@@ -730,7 +1351,18 @@ 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);
             if (args?.enable_timelapse !== undefined) sliceBambuOptions.enableTimelapse = Boolean(args.enable_timelapse);
             if (args?.allow_mix_temp !== undefined) sliceBambuOptions.allowMixTemp = Boolean(args.allow_mix_temp);
@@ -756,14 +1388,26 @@ 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);
             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.");
+            }
 
             let threeMFPath = String(args.three_mf_path);
 
@@ -776,7 +1420,7 @@ class BambuPrinterMCPServer {
                 f => f.match(/Metadata\/plate_\d+\.gcode/i) || f.endsWith('.gcode')
               );
               if (!hasGcode) {
-                console.log(`3MF has no gcode — auto-slicing with ${slicerType} for ${printModel}`);
+                console.log(`3MF has no gcode - auto-slicing with ${slicerType} for ${printModel}`);
                 const autoSliceOptions: BambuSliceOptions = {
                   uptodate: true,
                   ensureOnBed: true,
@@ -806,7 +1450,8 @@ class BambuPrinterMCPServer {
             }
 
             let finalAmsMapping = parsedAmsMapping;
-            let useAMS = args?.use_ams !== undefined ? Boolean(args.use_ams) : (!!finalAmsMapping && finalAmsMapping.length > 0);
+            const explicitUseAMS = args?.use_ams !== undefined;
+            let useAMS = explicitUseAMS ? Boolean(args.use_ams) : (!!finalAmsMapping && finalAmsMapping.length > 0);
 
             if (args?.ams_mapping) {
               let userMappingOverride: number[] | undefined;
@@ -827,7 +1472,7 @@ class BambuPrinterMCPServer {
               finalAmsMapping = undefined;
               useAMS = false;
             }
-            if (!finalAmsMapping || finalAmsMapping.length === 0) {
+            if ((!finalAmsMapping || finalAmsMapping.length === 0) && !explicitUseAMS) {
               useAMS = false;
             }
 
@@ -837,7 +1482,7 @@ class BambuPrinterMCPServer {
             result = await this.bambu.print3mf(host, bambuSerial, bambuToken, {
               projectName,
               filePath: threeMFPath,
-              plateIndex: 0,
+              plateIndex,
               useAMS: useAMS,
               amsMapping: finalAmsMapping,
               bedType: printBedType,