Kiln

Analyze the structure of OpenSCAD code. Parses parameters, modules, and library imports to understand the code's architecture. Use this before modifying code to know what modules exist and what each one does. Args: scad_code: OpenSCAD source code.

Analyze an STL mesh for structural weak points. Goes beyond printability to find **structural** risks: - **thin_neck**: narrow cross-sections that will snap under load - **stress_concentration**: abrupt section changes that focus stress - **cantilever**: unsupported overhanging geometry - **sharp_corner**: concave edges that initiate cracks - **insufficient_base**: topple risk from height-to-base ratio - **weak_layer_adhesion**: overhangs in structurally critical areas Returns risk locations as (x, y, z) coordinates in mm so agents can reason about *where* problems are, not just *that* they …

Analyze warping risk for a 3D model based on geometry and material. Examines the mesh for warping risk factors: large flat surfaces that tend to curl at corners, tall/narrow geometry prone to thermal contraction pulling, and sharp base corners that lift. Cross-references with the material's known warping tendency (from thermal properties). Returns a risk assessment with: - risk_level: "low", "moderate", "high", or "critical" - score_deduction: impact on overall printability score - large_flat_surfaces: detected flat areas prone to warping - height_to_base_ratio: geometry aspect ratio risk fa…

Apply a saved decoration to a new model — proven settings, one call. Loads a previously saved decoration and applies it to the target model using the exact settings that worked before. Automatically resolves depth, mode, and image style from the proven recipe. This is the magic tool — decorations that took many iterations to perfect can be replayed on any model in one call. :param name: Decoration name or slug. :param model_path: Path to the target model (STL or OBJ). :param material: Override material (empty = use proven or detect from printer). :param face: Which face to decorate (au…

Analyze a part for structural risks, then auto-apply fixes. This is the **one-step design hardening tool** — it runs the full structural analysis pipeline, then applies every applicable fix: - **Thin necks** → thickened walls (+material at narrow sections) - **Sharp corners** → rounded edges (stress concentration reduced at inside corners) - **Insufficient base** → wider base plate (stabilizing geometry added) - **Cantilevers** → triangular gusset ribs Thickening and edge rounding are done on the part's CAD file, so pass its STEP file when there is one (or a mesh Kiln converted from one tha…

Pack multiple STL files onto a virtual build plate. Uses greedy bottom-left bin-packing (largest parts first) to efficiently arrange parts with configurable spacing. Reports which parts fit, which overflow, and plate utilization. Supports printing multiple copies of parts via the copies parameter. :param file_paths: JSON array of file paths, e.g. ``["/tmp/a.stl", "/tmp/b.stl"]``. :param plate_width_mm: Build plate width in mm (default 256). :param plate_depth_mm: Build plate depth in mm (default 256). :param spacing_mm: Minimum gap between parts in mm (default 5). :param copies: Optional JS…

Analyze load-bearing characteristics of a mesh from its geometry. Infers structural behavior by analyzing surface normals, shape type, and cross-section distribution: - **primary_load_axis**: which direction the part resists force - **load_surfaces**: which surfaces bear load (with area fractions) - **weak_axis**: the most vulnerable direction for failure - **recommended_print_orientation**: how to orient for maximum strength - **layer_direction_concern**: how FDM layers affect structural integrity This is the difference between "PLA is good for prototypes" (lookup) and "this bracket should …

Run a ruthless audit of an original design before printing. Combines design briefing, prompt enhancement, mesh validation, printability scoring, orientation analysis, advanced diagnostics, and regeneration feedback into a single report. Use this after generating or modeling a new part to answer: "Is this genuinely ready to print, and if not, what exact changes should the agent make next?" Args: file_path: Path to STL or OBJ file. requirements: Functional requirements the design must satisfy. material: Optional material constraint (e.g. "petg"). printer_model: Optional printe…

Calculate non-overlapping XY positions for multiple parts on a print plate. Use this **before** :func:`compose_multicolor_3mf` when you have multiple separate objects (e.g., two coasters) to print in one job. Parts that share the same ``group`` index are treated as a multi-color unit and placed at the *same* XY position (they overlap intentionally). Returns a list of positioned part specs ready to pass directly to ``compose_multicolor_3mf`` — pass the SAME ``printer_id`` to that call: the composer re-centres a group it judges off ITS plate (256mm by default), so composing a layout packed fo…

Split a 3D model into horizontal color zones by Z-height. Divides the model's height into N equal bands. Faces that cross a band edge are cut exactly at it, so the line where two colors meet is the straight horizontal line the bands name — never a sawtooth of whole faces, on any tessellation. The cut faces are capped at the band planes, so each zone of a closed model is itself a closed solid ready to slice. Produces separate STL files per zone and (if available) a multicolor 3MF ready for AMS/MMU printers. Zero cloud dependencies — pure geometry. Says whether its colours are on the printe…

Split a 3D model into color zones by geometric region. Supports multiple assignment methods: - ``"z_height"``: horizontal bands by Z-height (default) — faces crossing a band edge are cut exactly at it and the cuts are capped, so the color boundary is a straight line on any tessellation and each zone of a closed model is itself a closed solid ready to slice - ``"normal"``: group by face normal direction (top / bottom / sides) - ``"random"``: random face assignment for artistic prints The 3MF takes whichever form actually prints: z_height bands become one closed solid…

Find the optimal print orientation for a 3D model. Evaluates multiple rotations of the model, ranks them, and reports each candidate's bed contact, support volume, print height and overhang share. On a plain install, and for a caller below Kiln Pro on Kiln's hosted service, the ranking is by bed contact, the lower part first between equals; a Kiln Pro caller on the hosted service gets Kiln's own scorer (https://kiln3d.com/pricing). A caller the scorer was withheld from is told so once, in ``upgrade_hint``. Optionally applies the best orientation and writes a reoriented STL file. Args: …

Wait for a generation job to complete and return the final status. Polls the provider until the job reaches a terminal state or the timeout is exceeded. Useful for agents that want to block until a model is ready. Args: job_id: Job ID from ``generate_model``. provider: Provider that owns the job. timeout: Max seconds to wait for generation (default 600 = 10 min). poll_interval: Seconds between polls (default 10).

Back up the Kiln database with optional credential redaction. Creates a copy of the SQLite database. By default, sensitive fields (API keys, access codes, payment refs) are replaced with "REDACTED" in the backup. Args: output_path: Destination file path. Defaults to ``~/.kiln/backups/kiln-YYYYMMDD-HHMMSS.db``. redact: If ``True`` (default), redact credentials in the backup.

Perform a CSG boolean operation on two or more STL meshes. Uses OpenSCAD's boolean engine to compute: - **union**: combine multiple bodies into one - **difference**: subtract subsequent bodies from the first - **intersection**: keep only the overlapping region Requires OpenSCAD installed on the system. **Use cases:** - Subtract a cylinder from a block to create a hole - Combine multiple parts into a single printable body - Create complex shapes from simple primitives :param operation: ``"union"``, ``"difference"``, or ``"intersection"``. :param file_paths: List of STL file paths (minimum 2…

Browse Thingiverse models by popularity, recency, or category. Args: browse_type: One of "popular", "newest", or "featured". page: Page number (1-based, default 1). per_page: Results per page (default 10, max 100). category: Optional category slug to filter by (e.g. "3d-printing", "art"). Use ``list_categories`` to see available slugs. Returns model summaries similar to ``search_models``.

Build a design-aware generation prompt for original 3D creation. This is the best pre-generation tool for original designs. It takes a natural-language idea and appends manufacturing constraints, printer-fit limits, and material guidance so text-to-3D backends receive a prompt grounded in real printability constraints. When provider is specified, the prompt length is optimized for that backend. Use provider="openscad" for maximum constraint injection (100K chars), "meshy" for lean prompts (600 chars), or omit for the default limit. Args: requirements: Natural language description of the…

Build a prompt optimized for parametric OpenSCAD code generation. Returns an enhanced prompt with OpenSCAD-specific instructions that guide AI to produce well-structured parametric code with named variables, descriptive comments, and material-aware design limits. Use this instead of build_generation_prompt when you want the AI to generate editable OpenSCAD code rather than a mesh file. Args: requirements: Natural language description of the desired part. material: Optional material override (e.g. "petg"). printer_model: Optional printer model ID (e.g. "bambu_a1").

Cache a 3D design file for faster access and version tracking. Args: file_path: Path to the design file to cache. label: Human-readable label for the cached design. material: Intended material for this design.

Cache a design file alongside its parametric source code. Stores the STL/3MF file in the design cache and attaches the OpenSCAD source code and generation prompt so the design can be re-generated or tweaked later. Args: file_path: Path to the design file (STL, 3MF, etc.). scad_source: OpenSCAD source code that produced this file. generation_prompt: The prompt used to generate the design. provider: Generation provider name (e.g. "openscad", "gemini"). tags: Optional tags for search. filament_type: Material type (e.g. "PLA", "PETG").

Add a 3D model file to the local cache for reuse across jobs. Copies the file into ``~/.kiln/model_cache/`` and stores metadata (source, prompt, tags, dimensions) in the database. Duplicate files are detected automatically by SHA-256 hash. Args: file_path: Path to the model file on disk. source: Origin — ``"thingiverse"``, ``"myminifactory"``, ``"meshy"``, ``"openscad"``, ``"upload"``, etc. source_id: Marketplace thing ID or generation job ID. prompt: For generated models, the text prompt used. tags: Comma-separated tags (e.g. ``"benchy,calibration,test"``). …

Cancel an active recovery session. Args: session_id: The session_id to cancel. reason: Optional reason for the cancellation.

Cancel a print service order. Only orders that have not started printing can be cancelled. Args: order_id: The order ID to cancel.

Remove one job from the print queue while it is still WAITING. Queue bookkeeping only: this marks the row cancelled and never sends anything to a printer. To STOP a job the machine has already started, use ``cancel_print`` — that is the tool that talks to the hardware. Args: job_id: The job ID to cancel. Only a job still in the QUEUED state can be cancelled here. A job that has reached the machine (starting, printing, or paused) is refused with ``code="PRINT_IN_PROGRESS"`` rather than cancelled, because marking the row cancelled would leave the queue claiming a print had stopped while…

Cancel ALL queued print jobs at once. The bulk companion to ``cancel_queued_job`` (which cancels one job by id). Cancels every job currently in the QUEUED state — clear a backed-up queue in one call instead of cancelling one job at a time. - ``printer_name``: limit the sweep to one printer's queued jobs; omit to clear every queued job. - ``dry_run=True``: preview exactly which jobs WOULD be cancelled and change nothing. Run this first when clearing a large queue. Safety: this never cancels a running print. Only jobs still in the QUEUED state are cancelled; each job's status is re-chec…

Cancel all pending/in-progress parts of a split plan. Args: plan_id: The plan ID to cancel.

Center a mesh on the build plate and place at z=0. Translates the model so it sits centered on the bed with its lowest point touching the build plate. :param file_path: Path to the STL file. :param bed_x_mm: Build plate X dimension (default 256). :param bed_y_mm: Build plate Y dimension (default 256). :param printer_id: Optional supported printer model id. When provided, printer intelligence supplies the bed size. :param output_path: Output path (defaults to overwriting input). :returns: Dict with translation applied.

Check clearances between all mating parts in an assembly. Returns a list of clearance check results indicating whether each interface meets its clearance requirements. Args: assembly_json: JSON string of the current assembly state. default_clearance_mm: Default clearance gap in mm to use when an interface does not specify one (default 0.2).

Check firmware version for a specific printer by name (fleet-level, firmware manager). Use this in multi-printer setups. For single-printer setups where you don't need to specify a name, use ``firmware_status`` instead. Args: printer_name: Printer to check.

Check whether a material is compatible with an environment, and optionally whether it meets the rules the part must meet. Args: material: Material ID from the design knowledge base. environment: Natural language environment description. requirements: Optional rules to check the material against before printing: any of ``food_safe``, ``reach``, ``rohs``, ``flame_retardant``, ``uv``. The answer comes back under ``rule_checks``: the material's warnings at every tier, and from Kiln Business a meets / does-not-meet verdict with the reason for ea…

Check if a printer has enough material for a print job. When material is insufficient, says what the person can do with what they have: a spool on the shelf, a pause-and-swap. Only when nothing they have will do does it end with one offer of help finding a filament. Relay that offer as written and never suggest buying filament unless the person asks or says yes; then use ``find_closest_filaments``. Suggestions that point at OTHER machines are a fleet-wide answer and need Kiln Business; the check itself — does THIS printer have enough — works on every tier. Args: printer_name: Name of …

Check if two materials can be co-printed in dual extrusion. Returns compatibility (yes/no), interface adhesion quality, notes on temperature management, and soluble support dissolution instructions when applicable. Use this when a user asks "can I print PLA with TPU?" or "what support material works with ABS?" or planning any multi-material / dual-extrusion print. Args: material_a: First material (e.g. "pla", "abs"). material_b: Second material (e.g. "tpu", "hips", "pva").

Check the user's current Kiln subscription tier (Free / Pro / Business / Enterprise) and explain WHY they're on it. Use this whenever the user asks any tier / plan / subscription / paywall / access question — for example: "what tier am I on", "why does it say I need Pro", "do I have to pay for this", "what's my plan", "why isn't this Pro feature working", "did my subscription not activate", "what's the difference between Free and Pro", "I just paid but I'm still seeing free tier", "can I use the texture engine", "do I have access to fleet management", "what unlocks at Business", "how do I upg…

Perform a single-shot health assessment of the current print. Unlike ``watch_print`` (which starts a background monitoring thread), this tool runs one check cycle and returns immediately. It is designed for quick "is the print OK right now?" queries from an agent without starting persistent background tasks. Checks performed: * **Printer connectivity** — is the printer online? * **Temperature** — are hot-end and bed within 15 °C of target? * **Print progress** — current completion, layer count, ETA. * **Error state** — any active firmware error codes. If *model_path* is supplied, adhesion …

Single-call print readiness check with optional auto-repair. Runs the full validation battery: parseable, manifold, no floating regions, supports (``analyze_printability``'s own verdict, which knows a short ceiling bridges), fits build plate, no degenerate triangles. With ``auto_fix=True``, automatically repairs degenerate triangles, closes holes, and removes floating regions. :param file_path: Path to mesh file. :param auto_fix: Attempt automatic repairs (default False). :param output_path: Where to write the fixed file. :param bed_x_mm: Build plate X dimension (default 256). :param bed_y_…

Check if a specific printer can handle a material. Returns compatibility status (compatible / needs_upgrade / not_compatible), any required hardware upgrades (enclosure, hardened nozzle, dry box), and practical notes. Use this when a user asks "can my Ender 3 print nylon?" or another specific printer/material question. Args: printer: Printer model ID (e.g. "ender3", "bambu_x1c", "prusa_mk4", "voron_2"). Use underscores, lowercase. material: Material to check (e.g. "nylon", "abs").

Check which STEP import backends are available on this system. Returns a dict listing each backend (FreeCAD, Gmsh, the OCCT kernel, CadQuery) with its availability status and priority. If none is found, includes ``install_help`` (prose) and ``remedy`` (structured) — prefer ``remedy``: its ``actionable_by_caller`` flag tells you whether the user can fix this (``kiln install-step-backend``) or whether they're on a hosted server where they cannot. Call this before ``import_step_file`` to verify the system is ready for STEP conversion.

Remove all expired agent memory entries. Entries with a TTL that has elapsed are permanently deleted. Returns the count of entries removed.

Configure and start cloud sync. Args: cloud_url: Base URL of the cloud sync endpoint. api_key: API key for authentication. interval: Sync interval in seconds (default 60).

Trigger an immediate cloud sync cycle.

Get the current cloud sync status.

Get overall print-registry statistics. ``stats`` covers this install: total records, unique models, printers, materials, and overall success rate. ``community`` adds the size of the shared pool everyone contributes to — counts only, available to anyone signed in. Works offline: the local numbers are always returned.

Compare two mesh files and report geometric differences. Computes volume change, surface area change, dimension deltas, center-of-mass shift, the mesh-check delta, and an approximate Hausdorff distance showing how far the meshes differ spatially. Useful for verifying that a repair, rescale, or regeneration actually improved the model. :param file_a: Path to the reference (original) mesh. :param file_b: Path to the modified mesh. :returns: Dict with comparison metrics and ``meshes_identical`` flag.

Compile OpenSCAD code into an STL file. Takes OpenSCAD source code OR a path to a .scad file, compiles it using the local OpenSCAD binary, and returns the path to the generated STL. Supports Kiln's bundled BOSL2 library. For surface() heightmap operations (photo emboss, lithophane), increase timeout to 600+ seconds. Kiln checks the compiled part is joined up. A piece that floats with nothing under it is joined to nothing and prints as a loose part on supports, or not at all, so the make is REFUSED (``code: "FLOATING_PIECES"``; ``error`` names the pieces, how far they are from the nearest s…

Mark a recovery session as completed. On failure (success=False) with ``alternative_printers`` and kiln-pro installed, the answer can carry a ``reroute_recommendation``: whether the failed job should move to one of those printers, and which. Choosing between printers is Kiln Business (https://kiln3d.com/pricing); below it the answer says so once in ``reroute_recommendation_gated``. A failure that needs hands-on inspection of the printer is held where it is, in ``reroute_recommendation``, at every tier. Recommendation only; the agent runs any move itself via ``submit_job`` / ``start_print``.…

Compose all assembly parts into a single output STL file. Merges the individual part meshes according to their positions and writes the combined model to ``output_path``. Args: assembly_json: JSON string of the current assembly state. output_path: File path where the composed STL will be written.

Merge multiple mesh files into a single combined model. Concatenates all triangle geometry from the input files into one output STL. No boolean operations — bodies are simply combined. Useful for multi-part assemblies or adding components to a design. **See also:** ``merge_mesh_files`` for the same operation with a different parameter style, or ``merge_stl`` for positional offset support. :param file_paths: List of .stl/.obj/.glb file paths to merge. :param output_path: Path for the combined output STL. :returns: Dict with merge statistics.

Build a functional part by composing geometric primitives with booleans. The **CAD-aware generation path** -- instead of asking text-to-mesh AI to guess at geometry, describe parts as a tree of primitives combined with boolean operations. Produces exact, deterministic, functional parts. **SAFETY DEFAULT (changed 2026-04-15):** ``center_on_bed=True`` is the default. OpenSCAD primitives are natively centered on the model origin (``cylinder(h,r)`` produces geometry centered on X/Y = (0,0), which means half the geometry lives at NEGATIVE X/Y). Sending such an STL to most FDM printers (Bambu, P…

Configure SSO (OIDC or SAML) for Enterprise authentication. Enterprise feature. Sets up single sign-on with your identity provider (Okta, Google Workspace, Azure AD, Auth0, etc.). Args: issuer_url: IdP issuer URL (e.g. ``https://accounts.google.com``). client_id: OIDC client ID or SAML entity ID. protocol: ``"oidc"`` or ``"saml"``. client_secret: OIDC client secret (optional for public clients). redirect_uri: Callback URL after auth. Default: ``http://localhost:8741/sso/callback``. allowed_domains: Comma-separated email domains (e.g. ``"acme.com,partner.org"``). r…

Confirm that a recovery plan should proceed. For plans requiring human confirmation, transitions from ``awaiting_confirmation`` to ``executing``. Args: session_id: The session_id to confirm.

Which standing consent windows are open, for what, until when. A standing window is the person's "yes, for a while": inside it, prints start on the named printer without asking each time (each one still previewed first). Only the person opens one — by picking "yes, and for the next…" in the approval dialog, or with ``kiln consent window`` at a terminal. Nothing an agent can call opens or extends one. Closing one is always allowed: see ``revoke_consent_window``. An entry with ``always: true`` is always allow: the person turned it on for one printer — at a terminal, or on their Kiln account…

Get the guided onboarding workflow for users without a 3D printer. Returns a step-by-step guide covering model discovery/generation, material recommendations, pricing, ordering, and delivery tracking. Perfect for first-time users who want to manufacture a custom part.

Contribute a print outcome to the community registry. Adds an anonymous print record for community aggregation. Only geometric signatures and settings are stored — never file contents, user IDs, or file paths. Args: geometric_signature: Geometric signature from fingerprinting. printer_model: Printer model name. material: Material used. settings: Print settings dict. outcome: ``"success"``, ``"failed"``, or ``"partial"``. quality_grade: Grade from ``"A"`` to ``"F"`` (default ``"B"``). failure_mode: Optional failure description. print_time_seconds: Print duratio…

Create a new empty assembly. Returns the assembly state as a JSON-serialisable dict that must be passed back to subsequent assembly tools. Args: name: Human-readable name for the assembly.

Create a Print-as-a-Service order and get a quote. Provide ONE of ``model_path``, ``model_url``, or ``prompt``. Returns a quote with local and fulfillment options. Call ``print_service_quote`` with the order ID to confirm. Args: model_path: Local path to a 3D model file. model_url: URL to download a 3D model. prompt: Text prompt for AI model generation. material: Material type (default ``"pla"``). intent: Print intent — ``"strong"``, ``"pretty"``, or ``"cheap"``. quantity: Number of copies (default 1). color: Desired color (optional). prefer_local: Prefer loca…

Compute a 2D cross-section of a mesh at a cutting plane. Slices the mesh perpendicular to the chosen axis and returns contour polygons and cross-sectional area. Useful for inspecting internal geometry (e.g., wall thickness, hole placement). :param file_path: Path to STL file. :param plane: Axis perpendicular to the cut -- "x", "y", or "z". :param offset_ratio: Fractional position 0.0-1.0 (default 0.5 = midpoint). :param offset_mm: If set, absolute position in mm (overrides offset_ratio). :returns: Dict with contour_count, contour_points, cross_section_area_mm2.

Check database backend status and configuration. Reports whether Kiln is using SQLite or PostgreSQL, the connection status, and key metrics. Useful for verifying a PostgreSQL migration or diagnosing connectivity issues. Requires Enterprise license.

Get every version of a saved decoration (Kiln Pro). Each version with when it was made, what changed, the materials it has printed well on and its print count. :param name: Decoration name or slug. :returns: Dict with the version history and the current version.

Get full details about a saved decoration. Shows the decoration's proven settings, content paths, tags, processing pipeline, and library location. :param name: Decoration name or slug. :returns: Dict with full decoration details and file paths.

Check your decoration quota — how many decorations you've used this month. Free-tier users get 3 decorations per calendar month. Every paid tier has unlimited decorations. Returns used count, limit, remaining, tier, and current month.

Remove a stored note or preference. Args: key: The key of the note to delete. scope: The scope namespace (default ``"global"``). printer_name: If provided, targets ``"printer:<name>"`` scope.

Remove a model from the local cache (file and metadata). Args: cache_id: The unique cache ID of the model to delete.

Delete a saved local shipping profile. Args: name: Profile name to delete.

Ask which generation method to use for a design idea (triage tool — call FIRST). Analyzes the design prompt and recommends: - Which generation approach to use (template, OpenSCAD, or AI) - Which template matches (if any) - Material recommendations - Key constraints to consider - Estimated complexity :param prompt: Text description of the desired object. :param printer_model: Optional printer model for constraints. :param material: Optional material the user has already named ("for ABS") — tunes the constraint analysis to it. :returns: Dict with recommendations.

Generate a complete structural improvement plan for a design. The **full design reasoning pipeline** — combines risk analysis, reinforcement recommendations, and load analysis into one actionable report with an overall structural score (0-100, A-F grade). This is the tool that makes Kiln a **design advisor**, not just a geometry validator. It answers: "This bracket needs a gusset at the load point" — not just "the part has thin walls." The plan includes: 1. **Risks**: all structural weak points with locations and severity 2. **Reinforcements**: specific fixes and what each does for the part…

Detect pockets and cavities in a mesh before multi-part composition. Analyzes a base model to find recessed regions (circular or rectangular pockets) on top and bottom faces. Call this before compose_models or multi_material_print to know pocket dimensions for overlay geometry. :param file_path: Path to the STL file to analyze. :param min_depth_mm: Minimum pocket depth to report (default 0.3mm). :returns: Dict with pocket list, dimensions, and positions.

Analyze printer telemetry to detect and classify a print failure. Examines current telemetry data and optional historical snapshots to identify failure conditions such as thermal runaway, layer shift, filament runout, adhesion loss, nozzle clogs, and more. Args: printer_name: Identifier of the printer to analyze. telemetry: Current telemetry snapshot with keys like ``hotend_temp``, ``bed_temp``, ``connected``, ``filament_detected``, etc. telemetry_history: Optional list of recent telemetry snapshots for trend analysis (newest last). job_info: Optional …

Deep mesh defect analysis — self-intersections, holes, normals, fragments (defect-focused). Goes deeper than ``analyze_mesh_geometry`` (which focuses on printability scoring and overhang detection). Use this when you suspect mesh defects or when ``repair_mesh`` didn't fix the issue. Analyzes: self-intersections, inverted/inconsistent normals, degenerate (zero-area) faces, floating fragments, detailed hole reporting (count, size, location), and polygon count assessment for FDM printing. Returns a structured report with severity level, defect list, and actionable fix recommendations (specific…

Diagnose a print failure using live printer state + model geometry. Unlike ``analyze_print_failure`` (which requires a job_id and analyzes historical data), this tool works in real-time by reading the current printer state and optionally analyzing the model that was being printed. Combines printer temperature deltas, bed adhesion analysis, overhang geometry, material properties, and printer intelligence to produce a ranked diagnosis with actionable fixes. Args: printer_name: Printer to diagnose. Omit for the default printer. model_path: Path to the model file that was being printed…

Compute a unified diff between two design versions. Version IDs are interpreted as ``<design_id>:<version_number>`` (e.g. ``my-coaster:2``). If no colon is present the string is treated as a plain version number and the tool will attempt to locate a design that contains that version. Args: version_id_a: The "from" version in ``design_id:N`` format. version_id_b: The "to" version in ``design_id:N`` format. Returns: A unified diff string showing changes from version A to B.

Scan the local network for 3D printers. Uses mDNS/Bonjour and HTTP subnet probing to find OctoPrint, Moonraker/Creality, Bambu Lab, Elegoo, and Prusa printers on the local network. Args: timeout: Maximum scan duration in seconds (default 5). Returns a list of discovered printers with host, port, type, and whether the API is reachable. Each one also carries ``address`` -- pass it as ``register_printer``'s ``host``; it keeps the port the printer answered on -- and ``to_connect``: what the person still has to supply and where they find it (``still_needed``), and anything to switch on in t…

Get crypto wallet addresses to tip/donate to the Kiln project. Kiln is free, open-source software. This tool returns wallet addresses (with ENS/SNS domains) where users can send tips in SOL, ETH, USDC, or other tokens to support development. No payment is required -- Kiln is fully functional without donating.

Download a completed generated model, check it, and open it on the stage. The result says where the model came from (``came_from``: the provider and the prompt) and, when the provider was asked for a shape and not a size, that its numbers are not millimetres (``size_check``). A note beside the file keeps where it came from, so the stage and design history can say so later. Args: brief_id: The saved goal's id from ``design_session``; pass it so this make joins the goal (recorded against it; Kiln Pro checks the result against it). Empty when there is no goal. job_id: J…

Download model file(s) from a marketplace to local storage. **Community models are unverified.** Always preview dimensions and validate the mesh (``validate_generated_mesh``) before printing. Models with high download counts and positive ratings are generally safer. AI-generated or untested designs can damage delicate printer hardware — prefer proven blueprints when possible. Args: brief_id: The saved goal's id from ``design_session``; pass it so this make joins the goal (recorded against it; Kiln Pro checks the result against it). Empty when there is no goal. file_i…

Check G-code encryption status and configuration. Enterprise feature. Reports whether encryption is active on this computer, whether the local encryption key is configured, and whether the cryptography library is installed. On a machine where encryption at rest is not installed, it answers that encryption is not active here, in the same shape, and says what enables it. ``account_files`` says, on every install, what is true of the print files kept in the person's Kiln account: Kiln's servers encrypt those with a key held there. Local files on this computer are encrypted only when the local …

Compare adaptive plan time savings vs uniform layer height. Shows layer count reduction, estimated time savings, and percentage improvement. Args: plan_data: Plan dict from ``generate_adaptive_slicing_plan``. uniform_height_mm: Reference uniform layer height for comparison (default 0.2mm).

Estimate print time, cost, and filament usage BEFORE generating a model. Works from dimensions alone — no file, no slicing, no generation needed. Use this to answer "how long will it take?", "how much will it cost?", and "how much filament?" before committing to a design. **Two ways to specify dimensions:** 1. **Direct dimensions** — provide ``width_mm``, ``depth_mm``, ``height_mm`` explicitly. 2. **Template** — provide ``template_id`` (e.g. ``"phone_stand"``, ``"box_with_lid"``) and optional ``template_overrides`` to use the template's default dimensions. **Multi-material prints…

Estimate the cost of a print job from a G-code file (already-sliced only). For STL/OBJ files, use ``slice_and_estimate`` instead — it slices and estimates in one step. The slicer's own ``filament used`` totals are the filament figures when the file carries them; otherwise Kiln counts the extruding moves itself. ``estimate.filament_source`` says which, and a ``warnings`` entry names both numbers when Kiln's count sits more than 5% from the slicer's total. Each filament is priced as the material the file was sliced for; ``estimate.filaments`` lists them and ``estimate.material_source`` says …

Estimate material usage and cost for printing a mesh. Computes filament weight, length, and cost based on mesh volume, infill percentage, wall shell count, and material density. The walls are as wide as the nozzle, and the reply's ``nozzle`` says which size was used and where it came from. **See also:** ``estimate_print_cost_from_mesh`` for a richer estimate that includes support material, adhesion, and electricity. Supported materials: pla, petg, abs, tpu, asa, nylon, pc, pla+, carbon_fiber_pla. :param file_path: Path to mesh file (.stl, .obj, or .glb). :param material: Material type (de…

Rough print time estimate from mesh geometry (STL/OBJ/GLB; a STEP file is converted first). Divides the plastic the part needs by the rate a print head lays it down, plus per-layer overhead. It is a planning figure for a printer it is not told about: ``range_seconds`` is how far a real slice has sat from it, and the printer is most of that spread. Unlike estimate_print_time (which slices the part with the printer's profile, and is the real answer when a slicer is installed), this works directly on mesh files before slicing. :param file_path: Path to mesh file. :param layer_height_mm: Layer…

Estimate the printed weight of a model file (a STEP file is converted first). Uses the divergence theorem to compute mesh volume, then applies material density, infill ratio, and shell fraction for a realistic weight estimate. :param file_path: Path to an STL file. :param material: Material name (pla, abs, petg, tpu, nylon, etc.). :param infill_percent: Infill percentage 0-100 (default 20). :param wall_thickness_mm: Perimeter wall thickness in mm (default 1.2). :returns: Dict with volume, weight estimates, bounding box.

Get an instant price estimate before requesting a full quote. Args: technology: Manufacturing technology: FDM, SLA, SLS, MJF, or DMLS. volume_cm3: Part volume in cubic centimeters (if known). dimensions_x_mm: Bounding box X dimension in mm (alternative to volume). dimensions_y_mm: Bounding box Y dimension in mm. dimensions_z_mm: Bounding box Z dimension in mm. quantity: Number of copies (default 1). Returns a low/high price range based on typical per-cm3 pricing for the technology. For exact pricing, use ``fulfillment_quote`` with a real model file. Either ``volume_…

Estimate total print cost from a 3D model file. Calculates material, support, adhesion, and electricity costs directly from mesh geometry — no G-code or slicing required. Includes a detailed cost breakdown and actionable recommendations to reduce cost. Supported materials: pla, pla+, petg, abs, tpu, asa, nylon, pc, cf-pla, silk-pla, hips, pva, pp, peek. Args: file_path: Path to mesh file (.stl, .obj, or .3mf). material: Material type (default "pla"). infill_percent: Interior fill percentage 0-100 (default 20). wall_layers: Number of perimeter shells (default 3). layer_he…

Estimate print progress with phase-aware time prediction. Breaks a print into phases -- preparing, printing, cooling, and post-processing -- and uses historical data from the print outcomes database to estimate time remaining. Typically more accurate than raw firmware estimates for predicting true completion time. Supply ``elapsed_seconds``, ``total_layers``, and ``current_layer`` when available; any omitted values will be read from the printer's live status. :param printer_name: Printer running the job. :param elapsed_seconds: Seconds elapsed since print start. Omit to read from prin…

Estimate print time and filament usage for a model. Slices the model and parses the G-code for print time, filament length/weight, and layer count. For **already-sliced** G-code files, pass the ``.gcode`` path directly — it will be parsed without re-slicing. Weight needs a filament density, which lives on a filament profile; Kiln's bundled profiles describe a PRINTER and name no filament, so pass ``material`` to get a weight. Without it the weight is reported as absent rather than guessed — a key missing from the result means the slicer could not answer it, never that the answer is zero. …

Estimate safe structural load for a cantilevered section. The figure is Kiln Pro's (https://kiln3d.com/pricing), worked out for this one part -- strength, sag and the arm's own weight, for any length of arm and size of section; below Pro the answer says the load was not checked. A part whose arm cannot hold its own weight gets no figure: ``load_checked`` is false and ``message`` says why. When the figure cannot be had (offline, signed out, no answer) the answer says why and that the part is unchecked. Args: material: Material ID (e.g. "petg", "nylon", "polycarbonate"). cross_sectio…

Estimate support material needed for a mesh. Analyzes overhang triangles and projects them to the build plate to estimate the volume and weight of support material required. :param file_path: Path to a .stl, .obj, .glb, or .3mf file. :returns: Dict with support volume (mm³), weight (g), and overhang stats.

Estimate support volume for a 3D model. Analyzes the mesh for overhangs and estimates the volume of support material needed to print the model in its current orientation. Args: file_path: Path to an STL or OBJ mesh file. max_overhang_angle: Maximum overhang angle in degrees before supports are needed (default 45).

Estimate order-to-delivery timeline with per-stage breakdown. Args: technology: Manufacturing technology (FDM, SLA, SLS, MJF, DMLS). shipping_days: Known shipping days from a quote (optional). quantity: Number of copies (larger quantities add production time). country: Destination country code for shipping estimate fallback. Returns a stage-by-stage timeline (order confirmation, production, quality check, packaging, shipping) with estimated days per stage and a total delivery date.

Export an adaptive slicing plan as slicer-compatible configuration. Converts a plan to the target slicer's format — PrusaSlicer and OrcaSlicer use variable layer height data, Cura uses adaptive layers plugin format. Args: plan_data: Plan dict from ``generate_adaptive_slicing_plan``. slicer: Target slicer — "prusaslicer", "orcaslicer", "cura", or "generic".

Export the safety audit trail as JSON or CSV. Enterprise feature. Returns the full audit log with optional filters for date range, tool name, action type, and session ID. Args: start_time: Unix timestamp lower bound (0 = no filter). end_time: Unix timestamp upper bound (0 = no filter). format: Output format, ``"json"`` or ``"csv"``. tool_name: Filter by MCP tool name. action: Filter by action (executed, blocked, etc.). session_id: Filter by agent session ID.

Export a mesh to 3MF format (preferred by modern slicers). Converts STL/OBJ/GLB to 3MF, a ZIP-based XML format used by PrusaSlicer, OrcaSlicer, and Bambu Studio. 3MF is more compact and supports metadata better than STL. :param file_path: Path to the input mesh file. :param output_path: Output 3MF path. Auto-generated if empty. :returns: Dict with the output file path.

Extract the embedded 3D model from a .3mf or .gcode.3mf file to STL. 3MF files are ZIP archives containing XML mesh geometry. This tool parses the embedded model, extracts all mesh objects, and writes a binary STL file ready for slicing, multi-copy printing, or further mesh operations. .. note:: For extracting a single object's **G-code** from a multi-object Bambu .gcode.3mf file, use ``extract_plate_object`` instead. Use ``list_plate_objects`` to discover available objects. Works with both standard 3MF files and Bambu Studio .gcode.3mf files (which bundle both G-code and the s…

View failure history for a printer or failure type. Args: printer_name: Filter by printer name. failure_type: Filter by failure type. limit: Maximum records to return (default 20). The response declares its own SCOPE: these are the failures THIS machine recorded, and ``scope.local.total_records`` gives the store's full matching count when ``limit`` truncated the page.

Find a ready-made parametric part for what the user is making. CALL THIS FIRST whenever a user asks for a FUNCTIONAL PART to their own dimensions — a bracket that holds a shelf, a bin that fits a drawer, a clip for an 8 mm cable, a case for a board, an adapter between two hose sizes. Kiln ships a library of print-verified parametric parts; offering one is faster and more reliable than writing OpenSCAD from scratch, it is FREE, and it needs no AI provider or API key. Do not wait to be asked whether a template exists — search, and if something fits, offer it. Ranked best match first, across …

Find printers that have a specific material loaded. Returns printers with the matching material, sorted by remaining stock (most first). Optionally filter by colour and minimum remaining grams. Args: material_type: Material type to find (e.g. ``"PLA"``). color: Optional colour filter. min_grams: Minimum remaining grams (default 0).

Find similar models in the print DNA knowledge base. Uses geometric signature matching and surface area / volume similarity to locate models with similar geometry. Args: file_hash: SHA-256 hash of the model file. geometric_signature: Geometric signature from fingerprinting. surface_area_mm2: Surface area in mm^2 (for fuzzy matching). volume_mm3: Volume in mm^3 (for fuzzy matching). complexity_score: Complexity (for fuzzy matching). limit: Maximum results (default 10). threshold: Similarity threshold 0.0-1.0 (default 0.8). geometric_signature_v2: ``fingerprint_…

Check if a slicer (PrusaSlicer/OrcaSlicer) is available on the system. Returns the slicer path, name, and version if found.

Compute a geometric fingerprint for a 3D model file. Reads the STL file and produces a fingerprint containing: SHA-256 file hash, triangle/vertex counts, bounding box, surface area, volume, overhang ratio, complexity score, and TWO geometric signatures for similarity matching. ``geometric_signature_v2`` is the one to carry into ``record_print_dna`` / ``predict_print_settings`` / ``find_similar_prints`` / ``contribute_community_print``: it tells this design apart from a different one that happens to share the older ``geometric_signature``. Pass both — the older key is what joins this print t…

Check firmware updates on the default/connected printer (adapter-level, no name needed). For fleet setups where you need to check a specific printer by name, use ``check_firmware_status`` instead. Returns a list of firmware components (e.g. Klipper, Moonraker, OctoPrint) with current and available versions, plus whether an update is available. Not all printer backends support firmware updates. Bambu and Prusa Link printers will return an ``UNSUPPORTED`` error.

Check the status of a first-layer monitor. Returns the current monitoring state, including any captured snapshots once monitoring is complete. A fault the printer has stopped for rides this result as ``printer_fault`` (as it rides every tool result while Kiln's watchdog sees it standing); the monitor's own fields describe the first layer, not the machine's fault state. Args: monitor_id: The monitor ID returned by ``start_monitored_print``.

Get fleet historical analytics: per-printer success rates, utilization, job throughput. For live printer status (current state/temps), use ``fleet_status``. Returns statistics for every registered printer including total prints, success rate, average print duration, and total print hours. Also includes fleet-wide aggregate metrics. Requires Business license.

Get the status of a fleet-managed print job. Args: job_id: The orchestrated job's identifier.

Get fleet status grouped by physical site/location. Returns printer statuses organized by site, making it easy to see which printers are idle, busy, or offline at each location. Printers without a site are grouped under ``"unassigned"``. Requires Enterprise license.

Submit a print job to the fleet orchestrator. If no printer is specified, the orchestrator auto-assigns to the best available printer. Tracks the job through completion. Before anything is queued, every candidate plate is surveyed as it stands (the named printer's, or the whole fleet's): a job no plate has room for is refused here, with each machine's own sentence (``NO_ROOM``), never queued to be refused at the printer later. Args: file_path: Path to the file to print. printer_name: Specific printer to assign to (auto-routes if None). material: Required filament material. p…

Get fleet utilization metrics — busy/idle/offline counts and utilization %. Lightweight overview of fleet capacity. For full printer details, use ``fleet_status``. For historical analytics, use ``fleet_analytics``.

Forecast when a material type will run out. Combines current stock with historical consumption rate to estimate remaining days and urgency level (ok/low/critical). Args: material_type: Material type to forecast (e.g. ``"PLA"``). days_ahead: Days of history for rate estimation (default 30).

Check for fulfillment order alerts (stalled, failed, cancelled orders). Returns any active alerts from the background fulfillment monitor. Alerts are generated when orders are cancelled/failed by the provider or have been stuck in processing longer than the expected lead time.

Cancel a fulfillment order (if still cancellable). Args: order_id: Order ID to cancel. Only orders that have not yet shipped can be cancelled. When the print service has nothing to cancel (an unpaid order is never made) or cancels only on a written request, the error message says which and how; pass it on to the person as it is.

List available materials from external manufacturing services. Returns materials with technology (FDM, SLA, SLS, etc.), color, finish, and pricing. Use the material ``id`` when requesting a quote with ``fulfillment_quote``. The full catalog contains 2000+ materials. Use the optional filter parameters to narrow results so agents can find the right material without overwhelming context windows. Args: search: Filter materials whose name contains this term (word-boundary match, case-insensitive). E.g. ``"nylon"`` matches "Nylon 12" and "Glass-filled Nylon" but not …

Place a manufacturing order based on a previous quote. Charges the orchestration fee BEFORE placing the order to prevent unpaid orders. If order placement fails after payment, the charge is automatically refunded. Args: quote_id: Quote ID from ``fulfillment_quote``. shipping_option_id: Shipping option ID from the quote's ``shipping_options`` list. shipping_address: Optional shipping contact/address dict for provider checkout. Keys: ``first_name``, ``last_name``, ``email``, ``phone``, ``street``, ``city``, ``postal_code``, ``country``; include ``st…

Check the status of a fulfillment order. Args: order_id: Order ID from ``fulfillment_order``. Returns current order state, tracking info, and estimated delivery. The reply opens with ``tell_the_person``: where the order is and, while it is unpaid, the link to pay for it. Pass every line on to the person word for word. Nothing is made until an order is paid on the print service's checkout, and Kiln cannot pay it for them. When the person wants to pay, asks how to pay, or asks about an order that is not paid yet, call this right away for that order and give them the link to pay first, be…

Get a manufacturing quote for a 3D model from Craftcloud. Args: file_path: Absolute path to the model file (STL, 3MF, OBJ). material_id: Material ID from ``fulfillment_materials``. quantity: Number of copies to print (default 1). shipping_country: ISO country code for shipping (default "US"). Uploads the model, returns pricing from Craftcloud's network of 150+ print services, including unit price, total, lead time, and shipping options. A Kiln orchestration fee is shown separately so the user sees the full cost before committing. If a payment method is linked, a hold is plac…

Generate a per-layer adaptive slicing plan. Creates a layer-by-layer plan with variable heights, speeds, and cooling based on detected geometry regions and material constraints. Args: regions: List of region dicts from ``analyze_model_geometry``. Each dict needs ``region_type``, ``z_start_mm``, ``z_end_mm``, and ``area_pct``. material: Material name (PLA, PETG, ABS, etc.). model_height_mm: Total model height in mm. model_name: Optional model name for record keeping. printer: Optional printer identifier. nozzle_diameter_mm: Nozzle diameter in mm. Leave…

Full pipeline: generate a model, validate, slice, and upload (preview). **EXPERIMENTAL:** This generates a 3D model, validates it, slices it, and uploads it to the printer — but does NOT start printing. 3D printers are delicate hardware and AI-generated models are not guaranteed to be safe or printable. You MUST call ``start_print`` separately after reviewing the preview results. When possible, prefer downloading proven models from marketplaces (Thingiverse, MyMiniFactory) instead of generating new ones. Args: brief_id: The saved goal's id from ``design_session``; pass it so t…

Generate a 3D model from a text prompt via external AI API (Meshy/etc). Pass ``material`` when the user has named one ("print this in TPU") — it steers the design-intelligence prompt enrichment toward that material's constraints. It is a design hint, not a slicing setting; leave it empty when the material is undecided. Start here if user has no template/image — just a text description. For image-based generation, use ``generate_model_from_image``. For parametric templates (local, no AI API needed), use ``generate_from_template``. To also slice + upload in one step, use ``generate_and_print`…

Make a 3D model from a reference image. DEFAULT (keyless): you (the agent) can SEE the image — study it, give it to ``design_session`` as ``reference_images`` (every later make is checked against it), and write the OpenSCAD yourself for ``design_session(verb="generate", scad_code=...)`` — or ``compile_scad`` on an install without ``design_session``. You do NOT need an image-to-3D provider, and with no key configured this tool hands the job back to your vision instead of erroring. OPT-IN cloud path: when the user has set their OWN KILN_MESHY_API_KEY, this submits the image to Meshy for an AI …

Generate a printable design via an external AI provider. The cloud, provider-backed creation path: hands a natural-language description to an external idea-to-3D service, audits the candidate for printability and design correctness, and can perform one or more corrective retries using feedback from failed attempts. This is NOT the default. It needs a configured provider (the user supplies their own API key). For most custom objects the free, keyless path is to author the OpenSCAD yourself and make it with ``design_session(verb="generate", goal_id=..., scad_code=...)`` — or ``compile_scad`` o…

Generate a print "birth certificate" for a 3D model. Queries print history for the file and builds a certificate containing tested printers, materials, success rate, and recommended settings. Args: file_path: Path to the 3D model file.

Generate multiple variations of a parametric template. Creates N variations by sampling parameter values across their valid ranges. Useful for exploring design space or offering choices to the user. :param template_id: Template ID (e.g. ``"phone_stand"``). :param variation_count: Number of variations (1-10, default 3). :param parameter_ranges: Optional overrides ``{param: [min, max]}``. :returns: Dict with list of generated variations and their files.

Cloud AI texture generation (requires Meshy API key + internet). For instant offline textures without any API, use ``apply_procedural_texture`` (multicolor) or ``apply_geometric_texture`` (relief) from kiln-pro. Takes any untextured mesh (STL, OBJ, GLB) and generates a UV-mapped texture based on the text description. The textured model can then be processed with ``auto_multicolor_from_texture`` (Kiln Pro) for multi-material printing. Requires a Meshy API key (``KILN_MESHY_API_KEY``). Args: mesh_path: Absolute path to the mesh file (STL, OBJ, GLB, FBX). prompt: Text description of …

Check the status of a generation feedback loop. Args: model_id: The model ID of the feedback loop.

Check the status of a model generation job. Args: job_id: Job ID returned by ``generate_model``. provider: Provider that owns the job (``"meshy"`` or ``"openscad"``).

Get the filament physically active in the AMS hardware right now (Bambu Lab). Reads live tray data from the AMS hardware. For the software-tracked material (what was told to Kiln via ``set_material``), use ``get_material`` instead. For Bambu Lab printers with an AMS, reads the active tray and returns its type, colour, remaining percentage, and temperature range. For non-Bambu printers (or printers without AMS), the material is reported as ``"unknown"``. ``tray_now`` is the printer's own tray id (``unit * 4 + slot`` on a chained unit, the unit id itself on an AMS HT); ``254`` is the externa…

Generate a human-readable summary of an adaptive slicing plan. Args: plan_data: Plan dict from ``generate_adaptive_slicing_plan`` or ``quick_adaptive_plan``. Returns a structured summary with key metrics and region breakdown.

Retrieve all stored agent memory for context. Call this at the start of a session to recall what you've learned about printers, materials, and past print outcomes. Expired entries are automatically filtered out. Each entry includes a ``version`` field showing how many times it has been updated. Args: printer_name: If provided, retrieves printer-specific memory. scope: Filter by scope (e.g., ``"global"``, ``"fleet"``).

Retrieve a cached design by ID. Args: design_id: The cached design's identifier.

Return details for a specific cached model. Args: cache_id: The unique cache ID of the model.

Get aggregated print data for a model geometry. Two layers, and the tool always returns whatever it can get: * ``insight`` — what THIS install has printed of this geometry: success rate, printers, materials, settings, failure modes. Always available, no account needed. * ``community`` — the same picture across everyone who has printed this shape, so you can start from what already worked. Community insights come with Kiln Pro (https://kiln3d.com/pricing); without them ``community`` reports that it isn't available and the local layer is unaffected. Never fails because of the …

Retrieve the parametric source code for a cached design. Returns the OpenSCAD source, generation prompt, and provider so the design can be re-generated, tweaked, or inspected. Args: design_id: ID of the cached design.

Look up one design template by id — parametric part or pattern. Resolves an id from EITHER library and says which it came from, so a caller never has to know in advance: * a PARAMETRIC PART (``generatable: true``) comes back with its full parameter list — names, defaults, and units — which is what you need to fill in the user's own dimensions and call ``generate_from_template``. * a DESIGN PATTERN (``generatable: false``) comes back with its use cases, material compatibility, and print orientation. Patterns are guidance for OpenSCAD you write yourself; ``generate_from_template``…

Retrieve a single design version by its ID. Use this to inspect the full source code, parameters, and notes for a specific version when you already know the version reference. Args: version_id: ``design_id:N`` reference (e.g. ``my-coaster:3``) or a plain integer version number if the design_id is unambiguous. Returns: The version record including source_scad, prompt, parameters, notes, and parent_version. Returns an error if the version does not exist.

Aggregate material inventory across all printers and spools. Returns a per-material-type summary of total stock in grams, spool counts, which printers have it loaded, and available colours.

Get recent interception results for a session. Args: session_id: Target session ID. limit: Maximum results to return (default 50, max 500). Returns interception results from newest to oldest, including actions taken, triggered rules, and reasons.

Get status and statistics for an interception session. Args: session_id: Target session ID. Returns session metadata, command counts, and current telemetry.

Get recommended clearance settings for a joint type and material pairing. Returns clearance recommendations based on the joint type and the materials of the two mating parts. When ``printer_id`` is supplied AND kiln-pro is installed, the response narrows the clearance range by the user's calibration tier (HIGH halves it, MEDIUM shaves ~10%, LOW and UNKNOWN leave it unchanged) and attaches a ``calibration_used`` block documenting the source. Args: joint_type: Type of joint (e.g. ``"clearance_fit"``, ``"press_fit"``, ``"snap_fit"``). material_a: Material of the first part (def…

Get material consumption history from completed prints. Aggregates filament usage per material type over the given window, converting filament length to grams using standard material densities. Args: days: Number of days to look back (default 30).

Compatibility lookup for a material's public design floor. Returns the same public safety and process fields as ``get_material_properties``. For deeper engineering guidance, ask one specific question with ``answer_material_question``. Args: material: Material ID (for example ``"pla"`` or ``"petg"``).

Get material-specific slicing constraints for adaptive slicing. Returns layer height limits, bridge/overhang parameters, fan speeds, and other material-tuned values used by the adaptive slicer. Args: material: Material name — PLA, PETG, ABS, TPU, ASA, Nylon, PC, PVA, or HIPS. nozzle_diameter_mm: Nozzle diameter in mm (affects layer height limits). Leave unset for the only printer Kiln knows of, else 0.4; the reply's ``nozzle`` says which.

Get all print attempts for a model. Returns the complete history of print outcomes, settings, and quality grades. The success-rate metrics cover every material by default; pass ``material`` to scope them to one filament ("how does this do in PETG?"). PASS ``model_path`` WHENEVER YOU HAVE THE FILE. History is a question about the SHAPE, and ``model_path`` lets Kiln identify it directly. A file hash alone identifies BYTES: re-export an unchanged part from CAD and the hash changes, so a hash-only lookup reports a part with real history as never printed. ``identified_by`` in the response say…

Get bounded public post-processing help for one goal. Pass ``surface_finish``, ``paint``, ``strengthen``, or the name of one listed technique. Omitting ``goal`` returns a compact compatibility overview rather than the complete guide. Args: material: Material ID (e.g. "pla", "abs", "petg", "nylon"). goal: Optional finishing goal or technique name.

Get a comprehensive print diagnostic combining multiple knowledge sources. This is the PRIMARY tool for debugging print problems. Combines troubleshooting data (symptom matching, root causes, fixes), printer compatibility (upgrade requirements, known issues), storage requirements (drying temps, humidity limits), and post-processing tips (strengthening options) into a single actionable response. Call this FIRST when a user reports any print quality problem. It cross-references all knowledge sources so the agent doesn't need to make multiple tool calls. Examples: material="petg", symptom…

Query cross-printer learning insights for a specific printer. Returns success rates, failure mode breakdown, and per-material statistics based on previously recorded outcomes — plus any UNRESOLVED prints: jobs that started (or ended) while no Kiln process was watching, whose outcome nobody has settled yet. **Agent contract for ``unresolved_prints``**: these entries are waiting on the one witness the machine can't replace — the user, who has the part. When the moment is natural (not mid-task), ask casually ("Your ashtray finished while Kiln wasn't watching — did it come out OK?") and settle …

Get the G-code/commands for executing a recovery. Args: session_id: The session_id to get steps for.

Get a recovery plan for a specific failure type. Args: failure_type: One of: spaghetti, layer_shift, adhesion_loss, nozzle_clog, stringing, thermal_runaway, power_loss, filament_runout, warping, unknown. printer_name: Name of the affected printer. has_power_loss_recovery: Whether the printer supports power-loss recovery. has_filament_sensor: Whether the printer has a filament runout sensor.

Get the current status of a recovery session. Args: session_id: The session_id to query.

Get historical recovery success rates and failure distribution. Returns aggregate statistics about all recovery attempts including success rates per strategy, failure type distribution, and active session counts.

Find materials running low and generate purchase links. Examines all material types in inventory and returns restock suggestions for any projected to run out within 30 days, sorted by urgency (critical first).

Get the full safety profile for a specific printer model. Returns temperature limits, feedrate limits, volumetric flow, build volume, and safety notes. Falls back to the default profile if the printer_id is not found. The profile also says where its numbers came from: ``owner_supplied`` lists any limit fields whose values were typed by this machine's owner rather than verified by Kiln, and ``limits_provenance`` is a ready-made sentence stating it. Repeat that sentence when quoting a limit, so a verified number and a typed one are never presented with the same authority. Args: printer_…

Return the full audit log for an agent session. Every tool call made by an agent is recorded with a session ID — a UUID generated when the MCP server starts. Use this tool to replay exactly what an agent issued during a session: every command, every safety check that fired, every blocked attempt. Args: session_id: Session UUID to query. Omit to use the current session. limit: Maximum records to return (default 100, max 500).

Get the Kiln skill manifest for agent self-discovery. Returns a machine-readable description of Kiln's capabilities, configuration requirements, available interfaces, and setup instructions. Use this when first connecting to understand what Kiln can do and what configuration is needed.

Get the full tuned slicer profile for a printer model. Returns all INI settings (layer height, speeds, temps, retraction, etc.) and the recommended slicer. A catalogued printer's profile is served one printer per call and kept on this computer; a printer whose record this install does not hold answers with the generic ``default`` profile (``profile.id == "default"``). Free-tier profiles (default, ender3, prusa_mk3s, klipper_generic) are available to all users. Premium profiles require a Kiln Pro license. Args: printer_id: Printer model identifier (e.g. ``"ender3"``, ``"bambu_x…

Kiln could not start — read this for what went wrong and how to fix it.

Relay the code the person typed after Kiln showed one on their screen. When a print is refused with "a code was just shown in a notification", ask the person to type it here, then pass their exact words: the code alone approves that one print; the code followed by ``2h`` or ``today`` also keeps printing on that printer without asking for a while. Then call the start tool again. Nothing you can call reveals the code; a wrong guess counts, and three wrong guesses void every code for a minute. When the reply carries ``phone_next_time``, pass that one line on once the print has started. Args: …

Tell Kiln you are taking a printer from here, so it can move on. Below the fleet tier Kiln works with one printer at a time: the machine it started a print on, or one it is watching for you. This hands that machine back — you keep the print, Kiln stops being the one driving it, and its attention is free for another printer. Nothing is cancelled and nothing is paused. The print carries on exactly as it was; this only changes which machine Kiln considers itself responsible for. Called with no arguments it reports which printer Kiln is working with, without changing anything, so you can alway…

Return system health information for monitoring. No authentication required. Useful for container healthchecks, dashboards, and verifying the server is responsive. **See also:** ``kiln_health`` for version info, module availability, scheduler status, and webhook configuration.

Create a hollow version of a mesh to save material. Generates an inner offset shell and combines it with the outer surface. Reports estimated material savings. :param file_path: Path to the STL file. :param wall_thickness_mm: Wall thickness in mm (default 2.0). :param output_path: Output path (defaults to ``<name>_hollow.stl``). :returns: Dict with hollowing stats and material savings.

Home the print head — what the Home button on the printer's screen does. Refused while a print is running, and while one is paused (the head is over the part and homing travels). Where the connected model's own start-sequence homing is served one plan at a time through Kiln's hosted service for a printer paired to your Kiln sign-in, free, and kept on your machine so it works offline — raise first, home X, Z found the way the maker finds it, park off the plate — it runs that, one described motion at a time. A bare ``G28`` from an unknown height is exactly the move that family's own sequences…

Import a STEP (.step/.stp) CAD file and convert it for Kiln's mesh pipeline. Converts STEP files using whichever backend is available (the OCCT kernel that ``kiln install-step-backend`` sets up, or an existing FreeCAD / Gmsh / CadQuery install). **The output format follows what the file carries.** A plain single-solid STEP becomes an STL. A STEP with part colours or several parts (an assembly: each placed part, a part placed twice is two) becomes ONE 3MF that keeps each part's name, position and colour — so a CAD assembly arrives as its parts, ready to print apart or together, instead of o…

Generate an improved prompt from feedback. Adds physical constraints to the original prompt to address printability and structural issues, without modifying the creative intent. The improved prompt is run through a three-check sanity gate (no contradictions, fits the provider budget, ≥70% original-token overlap so intent is preserved). When ``enforce_sanity=True`` (default) and the gate fails, this tool refuses with ``code="SANITY_GATE_FAILED"`` and returns the failure list instead of a contradictory prompt. Callers that genuinely want the failed prompt — for inspection, repair, or model s…

Infer optimal slicer settings from structural analysis. Bridges the gap between **design analysis** and **print success**. Analyzes the mesh for structural risks, then recommends concrete slicer parameters (perimeters, infill, supports, brim, layer height) tuned to compensate for the design's weaknesses. **Examples of what it catches:** - Thin neck detected → increase perimeters to 4+ - Cantilever overhangs → enable tree supports - High center of gravity → add brim for bed adhesion - Stress concentrations → switch to gyroid infill at 50%+ - Sharp corners → fine layer height for detail Mate…

Insert code into an OpenSCAD module without replacing it. Adds geometry or operations inside a module. Use for targeted additions like "add ventilation holes to the top panel" or "add screw holes to the base." Args: scad_code: OpenSCAD source code. module_name: Module to modify (e.g. "base_plate"). code_to_insert: OpenSCAD code to insert. position: "end" (before closing brace) or "start" (after opening brace). Default: "end".

Check one line of G-code for danger before you send it to a printer. G-code is the language printers take orders in -- "heat the nozzle to 250C", "move to X=100". One bad line can cook a hotend or drive the nozzle into the bed. This checks a single line against the safety rules for this session (temperature ceilings, speed caps, the printer's build volume) and says whether it looks safe to send. It is a smoke detector, not a sprinkler. It reports; it does not intervene. Kiln does not quietly pipe outgoing G-code through it, so a line gets checked only when you call this on it, and gets s…

Issue a single-use token after the user confirms shipping details. Call this only after showing the normalized contact/shipping address and selected shipping option to the user, asking whether Kiln should save the address as a profile, and receiving approval. ``fulfillment_order`` refuses to place an order without this token. Args: quote_id: Quote ID from ``fulfillment_quote``. shipping_option_id: Shipping option ID selected from the quote. shipping_address: Explicit full shipping address. shipping_profile_name: Saved profile name to use instead of passing ``shipping_…

Create a new version of a saved decoration, archiving the current one (Kiln Pro). Use this when tuning a decoration -- a new depth, mode, style or content file -- and the previous version stays available for ``rollback_decoration``. :param name: Decoration name or slug. :param content_path: New content file (empty = keep current). :param depth_mm: New depth in mm (0 = keep current). :param mode: New mode (empty = keep current). :param image_style: New image style (empty = keep current). :param notes: Free-text notes for this iteration. :returns: Dict with the new version and what changed.

Automated design iteration: generate -> validate -> improve -> regenerate. Runs a closed loop that generates a model, validates it for printability issues, and if issues are found, improves the prompt and regenerates. Stops when the model passes validation or max_iterations is reached. Returns the best result. :param prompt: Text description or OpenSCAD code. :param provider: Generation provider (default ``"openscad"``). :param max_iterations: Maximum improvement attempts (1-5). :param material: Optional material for design intelligence. :param printer_model: Optional printer model for con…

Get history of completed, failed, and cancelled print jobs. Args: limit: Maximum number of jobs to return (default 20, max 100). status: Optional filter by status -- "completed", "failed", or "cancelled". Omit to show all finished jobs. Returns recent job records from newest to oldest, read from the durable job store on THIS machine (``~/.kiln/queue.db``) — a server restart does not shorten it. The response declares its own SCOPE: ``scope.local.total_records`` gives the store's full matching count when ``limit`` truncated the page, other machines running Kiln keep their own…

Get the status of a queued or completed print job. Args: job_id: The job ID returned by ``submit_job``. Returns the full job record including status, timing, and metadata, plus ``watch`` when the scheduler is watching it: ``state`` is ``moving`` / ``stalled`` / ``no_contact`` / ``watching`` and ``note`` is the sentence to show a person when it is not moving.

Kiln could not start — read this for what went wrong and how to fix it.

Internal support for Kiln's inline print monitor. Relays a pause, resume, or cancel from the panel's own buttons through the same doors the pause_print, resume_print and cancel_print tools open. Called by the panel itself; not useful to call directly.

Internal support for Kiln's inline print monitor. Returns the composed printer snapshot the rendered panel polls. Called by the panel itself; not useful to call directly.

Start a Kiln sign-in via OAuth. Returns a URL the user can open in their browser to sign in with Google / Apple / GitHub. Relay the ``verification_uri`` to the user and then call ``kiln_signin_poll(device_code)`` every few seconds until the status is no longer ``"pending"``. Response fields (all strings unless noted): * ``verification_uri`` — URL to open in the browser; the ``user_code`` is already embedded as a query param so the user typically doesn't have to type anything. * ``user_code`` — the short human-readable code (``KLN-ABCD-EFGH``); show it only as a fallback in case the…

Check whether a sign-in started by ``kiln_signin`` is done. Call this repeatedly (every ``interval`` seconds) with the ``device_code`` that ``kiln_signin`` returned. Each call is a single HTTP round-trip (it does NOT block), so the agent stays responsive and the user sees progress. Returns ``{"status": "pending" | "success" | "denied" | "expired", ...}``. * ``pending`` — user hasn't finished in the browser yet; wait ``interval`` seconds and call again. * ``success`` — tokens have been written to ``~/.kiln/auth_tokens.json`` (mode 0600); the response also echoes ``email`` and ``tier``…

Confirm a cap change with the person's six-digit code (step 2 of 2). Args: challenge_id: From ``kiln_spend_caps_request_change``. totp_code: The six-digit code the PERSON reads from their own authenticator app. Never produce or guess it. Returns the new caps on success. A refusal names its case: a wrong code (they may try again within the daily limit), a challenge that expired or was already used (ask again from step 1), no authenticator set up on the account, or too many attempts.

Confirm a one-order approval with the person's code (step 2 of 2). On success returns an ``approval_token``: pass it to the order tool when placing that order again. It works once, for that order and amount, and expires within minutes. Args: challenge_id: From ``kiln_spend_caps_request_order_approval``. totp_code: The six-digit code the PERSON reads from their own authenticator app. Never produce or guess it.

Ask to raise the per-order and/or monthly spend cap (step 1 of 2). The servers hold the requested change for a few minutes and return a ``challenge_id``. Show the person ``current_caps`` and ``requested_caps`` so they can review the change, then ask them for the six-digit code from their authenticator app and pass it to ``kiln_spend_caps_confirm_change``. Args: per_order_dollars: New per-order cap; leave unset to keep it. monthly_dollars: New monthly cap; leave unset to keep it. reason: Optional note kept with the change. A refusal says which case it is (chat changes turned off…

Ask to approve ONE order over the cap (step 1 of 2). For an order Kiln refused as over the person's spend cap, when they want this order to go ahead without raising the cap for good. Returns a ``challenge_id``; step 2 is ``kiln_spend_caps_confirm_order_approval`` with their code. Args: order_id: The order Kiln refused. max_dollars: The order total being approved, in dollars.

Show your current Kiln spend caps and whether chat may change them. Returns the per-order and monthly caps, the defaults, and ``agent_flow_enabled``. When that is off the answer carries a ``next_step`` with the web page where the account owner turns it on; give the person that link as written, because turning it on cannot be done from chat. Needs a signed-in session: call ``kiln_signin`` first.

Why the Kiln server failed to start, in plain language, with the fix.

Internal support for Kiln's inline 3D viewer. Returns the viewer-grade mesh payload for a token the viewer was handed. Called by the rendered panel itself; not useful to call directly.

List all available 3D printing materials with properties. Returns details for every material in the database including strength, flexibility, heat resistance, surface quality, ease of print, cost, and temperature requirements.

List cached designs, optionally filtered by material. Args: material: Filter by material (e.g. "PLA", "PETG"). limit: Maximum number of results. Most recently used designs come first. The response declares its ``scope``: which store was read. The cache is local-only at every tier (regenerable files, no cloud copy), so a complete local read is the whole cache.

List all models in the local cache, newest first. Args: limit: Maximum results (default 50). offset: Number of entries to skip for pagination. The response declares its ``scope``: this cache is local to this machine, so the count is what THIS install has cached, not everything the user has ever downloaded or generated. It is also a page — ``limit``/``offset`` bound it further.

List all stored credentials (metadata only, no plaintext).

List all saved decorations in the library. Browse the decoration library to find reusable decorations. Filter by content type, category, or tag. :param content_type: Filter by type — ``photo``, ``svg``, ``qr``, ``text``, ``procedural_texture``, ``ai_texture`` (empty = show all). :param category: Filter by category — ``surface`` (photo/svg/qr/text) or ``texture`` (procedural/AI textures). Empty = show all. :param tag: Filter by tag (empty = show all). :returns: Dict with decoration count and list. This is the decoration LIBRARY: keyed by name, and it ADAPTS — each recorded succe…

List available pre-built OpenSCAD components from bundled libraries. Kiln bundles BOSL2 OpenSCAD libraries with pre-built components for gears, threads, screws, bearings, hinges, and more. These components produce proven geometry — much better than generating complex mechanical parts from scratch. Categories: mechanical, fasteners, electronics Args: category: Optional filter by category. If not provided, lists all available components.

List public material identifiers and safety/process summaries. The list is sourced only from public Kiln data and does not include optional engineering enrichment.

Browse the whole design-template library, both kinds. Returns every PARAMETRIC PART Kiln can render on its own — brackets, bins, stands, cases, hooks, jigs, clamps, plumbing and garden parts — followed by the DESIGN PATTERNS that are guidance rather than geometry. Every entry carries a ``generatable`` flag and the call to make next. The parametric parts are FREE and need no AI provider: they compile locally through OpenSCAD. Reach for one whenever a user wants a functional part to their own dimensions, and offer it before writing OpenSCAD from scratch — it is faster and every part in the l…

List version history for a design, newest first. Args: design_id: The design whose versions to list. limit: Maximum number of versions to return (default 20). Returns: A list of version records ordered by version number descending, plus a ``scope`` block saying which store was read and whether the user's cloud-side versions are included. Read ``scope`` before treating ``count`` as the design's whole history.

List all fleet sites/locations with printer counts. Returns the distinct sites defined across registered printers. Useful for multi-site fleet dashboards. Requires Enterprise license.

List available text-to-3D generation providers. Returns details about each provider: name, description, available styles, and whether it requires an API key. Use this to discover providers before calling ``generate_model``.

List all active G-code interception sessions. Returns summary information for each active session including printer name, command counts, and rule counts.

List available Thingiverse content categories. Returns category names and slugs. Pass a slug to ``browse_models(category=...)`` to browse models in that category.

List available multi-material add-on systems for 3D printers. Returns a catalog of optional multi-material add-ons (Creality CFS, Mosaic Palette, Co Print KCM, 3D Chameleon, Elegoo CANVAS) with their tool change times, color capacity, and compatibility info. When a ``printer_id`` is provided, only add-ons compatible with that printer are returned. Universal add-ons (Palette, Chameleon) appear for all printers. Klipper-only add-ons (KCM) appear only for Klipper-based printers. Use the returned ``id`` values as the ``tool_changer_addon`` parameter in ``estimate_before_design`` to model mult…

List all available pre-validated print pipelines. Pipelines are named command sequences that chain multiple operations into reliable one-shot workflows (e.g. quick_print, calibrate, benchmark).

Show the curated hardware variants available for a printer. A curated profile describes a printer AS SHIPPED. When Kiln has verified a documented hardware change — an Ender 3 whose PTFE-lined hotend has been replaced with an E3D Revo CR, say — that configuration is curated as a VARIANT, with its own limits, its manufacturer source, and the preconditions that make it true. Returns the as-shipped limits alongside each variant's, so you can see what selecting one would change before selecting it. An empty ``variants`` map is the honest answer for a machine Kiln has not verified a modified con…

List models that have been published to marketplaces. Args: marketplace: Filter by marketplace name (optional). limit: Maximum number of results (default 50).

List the printers Kiln has a safety profile for, by id and name. The list names printers; it carries no limits. Kiln reads a printer's limits one printer at a time: call ``get_safety_profile`` with one of these ids for its temperature, feedrate and flow limits, its build volume, and where those numbers came from. ``validate_gcode_safe`` checks commands against one printer's limits. A printer set up on this machine with limits its owner entered is listed too, marked ``set_up_on_this_machine``.

List saved local shipping profiles. Args: include_addresses: Include full contact/address fields. Defaults to ``False`` so listing profiles does not expose personal details unless the user is actively reviewing them.

List all bundled slicer profiles for supported printers. Returns profile IDs, display names, recommended slicer, and the minimum license tier required for each. Free-tier profiles can be used by everyone; PRO profiles require a Kiln Pro license. Use with ``get_slicer_profile`` to see full settings, or ``slice_model`` with printer_id for auto-profile selection.

List all materials with adaptive slicing profiles. Returns material names with their key slicing constraints (layer height limits, bridge parameters, overhang angles).

Return the list of trusted printer hostnames/IPs. Trusted printers are used to flag discovered printers that have been explicitly approved by the user, preventing spoofed-printer attacks.

Feed filament to the nozzle — an AMS tray on Bambu, a manual feed elsewhere. On Bambu Lab the firmware's own change-filament routine runs (retract, feed, purge) and the answer is read from the AMS: ``extrusion_verified`` is ``True`` once ``tray_now`` reports the tray feeding the nozzle, ``False`` with the fault code in plain language if the routine raised one (the same HMS codes the touchscreen shows), ``None`` if neither arrived in ``wait_seconds``. On Klipper a ``LOAD_FILAMENT`` / ``M701`` macro from the printer's own config is used when it exists; otherwise, and on OctoPrint / Duet / seri…

Load safety-profile rules for a printer into an active session. Generates rules from the printer's safety profile (temperature limits, feedrate caps, blocked commands) and adds them to the session. Use this to reset or refresh safety rules. Args: session_id: Target session ID. printer_name: Printer model for safety profile lookup. AGENT CONTRACT: relay any ``coverage_warnings`` to the user verbatim -- they mean the loaded rule set protects less than a full one.

Keep a design on this computer only: never saved to the person's Kiln account. A locked design is never saved to the Kiln account, by any door: a cloud push, an automatic save after each version, a push of one of its signed releases, or a pull request. Each is refused and says the design is locked. Branching, merging and the history views keep working; when Kiln's servers run one of those, the design passes through them for that call only and is not kept there. Locking removes nothing already in the account. Free on every plan. Args: design_id: The design to lock or unlock. locke…

Lock a safety profile so agents cannot modify its limits. Enterprise feature. When locked, community profile updates for this printer model are rejected. Only an admin can unlock. Args: printer_model: Profile identifier to lock (e.g. "ender3").

Look at the build plate through the machine's camera, and record what is there. Two steps, one tool. Called WITHOUT ``seen`` it fetches a frame and hands it to you as a picture, after a short text record that names ``snapshot_path``, the same picture saved on this computer -- and records nothing. Look at it, then call again with ``seen="clear"`` (nothing on the plate) or ``seen="occupied"`` (something is), and that answer becomes the plate record with you named as the one who looked. The picture shows whatever the camera sees, the room around the printer included. This tool saves it only …

Add, remove, or update a team member. Enterprise feature. Manages team seats and role assignments. Business includes 3 seats and meters to a cap of 10; Enterprise is unlimited. Args: action: One of ``"add"``, ``"remove"``, ``"set_role"``, ``"list"``. email: Member email address (ignored for ``"list"``). role: Role for add/set_role: ``"admin"``, ``"engineer"``, ``"operator"``.

Run connectivity checks against all configured marketplaces. Performs a lightweight probe (empty search) against each connected marketplace and reports which ones are reachable. Useful for debugging download failures.

Check which 3D model marketplaces are connected and available. Returns the list of configured marketplace sources, their connection status, and whether credentials are present. Use this to verify marketplace access before searching or downloading models.

Find pre-built library components matching a design description. Given a natural language description of what you want to build, identifies which bundled OpenSCAD library components can be used. Returns import lines, example usage, parameters, and guidance for each matching component. Examples: "hand crank with a gear" → finds spur_gear "box with a hinge" → finds knuckle_hinge "mounting bracket with screw holes" → finds screw_hole Args: description: Natural language description of the design.

Identify which functional requirements apply to a design task. Scans natural language for requirement triggers (load bearing, watertight, outdoor, food safe, heat resistant, flexible, impact resistant, precision, aesthetic) and returns matched constraint sets with rules and guidance. Use this to understand WHAT constraints apply before getting the full design brief. Args: description: What the object needs to do (e.g. "outdoor hook that holds a heavy hanging planter").

Combine multiple STL files into a single mesh file (simple concatenation). For positioning parts with x/y/z offsets, use ``merge_stl`` instead. Useful for composing multi-part designs into one printable file. :param file_paths: List of STL file paths to merge. :param output_path: Destination path for the merged file. :returns: Dict with merge statistics.

Assess a model — a graded scorecard for a mesh, an intake report for a CAD file. **For a mesh** (.stl, .obj, .glb) it evaluates four dimensions: - **Printability** (35%): ``analyze_printability``'s own score and grade for ``material`` / ``printer_id`` — pass the ones you gave ``analyze_printability`` and the two match - **Structural** (25%): aspect ratio, base stability, component count - **Efficiency** (20%): fill ratio, support waste - **Quality** (20%): triangle density, degenerate count and returns per-factor scores, an overall 0-100 score, and a letter grade (A-F). ``subject`` is `…

Mirror (reflect) a mesh along an axis. Creates a mirror image by negating coordinates on the chosen axis and reversing triangle winding order to preserve correct normals. :param file_path: Path to the STL file. :param axis: Axis to mirror ("x", "y", or "z", default "x"). :param output_path: Output path (defaults to overwriting input). :returns: Dict with mirror info.

Get full details for a Thingiverse model. Args: thing_id: Numeric thing ID (from ``search_models`` results). Returns comprehensive metadata including description, instructions, license, tags, and file count.

List downloadable files for a Thingiverse model. Args: thing_id: Numeric thing ID. Returns a list of files with name, size, and download URL. Use ``download_model`` with the ``file_id`` to save a file locally.

Get revenue summary for a specific model. Args: model_id: File hash or listing ID of the model.

Replace a module in OpenSCAD code with new implementation. Finds the named module and replaces its body entirely. Use for major modifications like redesigning a component. Args: scad_code: OpenSCAD source code. module_name: Module to replace (e.g. "top_panel"). new_module_code: Complete new module code including the module declaration and braces.

Snapshot + structured data for AI visual inspection of an in-progress print. Use when analyzing camera images for print failures. Returns webcam image (base64 or saved file) alongside structured metadata (temps, progress, phase, cost estimate, failure hints). Can auto-pause on detected issues. For a quick text status report, use ``monitor_print`` instead. For persistent background monitoring, use ``watch_print``. Args: printer_name: Target printer. Omit for the default printer. include_snapshot: Whether to capture a webcam snapshot (default True). save_snapshot: Optional path to…

Assign print jobs to printers by material availability. Each job dict should contain ``file_name``, ``material_type``, ``required_grams``, and optionally ``color``. On one machine it says which jobs its loaded spool can take, in order; across several machines it picks a printer for each job, preferring colour matches and fewer spool swaps (Kiln Business, https://kiln3d.com/pricing). Args: jobs: List of job dicts to assign.

Auto-rotate a mesh to minimize overhangs and maximize bed contact. Tests multiple candidate orientations and picks the one with the fewest overhangs and the most bed contact. Re-orients the mesh and places it flat on the build plate (z_min = 0). ``printability_score`` / ``printability_grade`` are the chosen orientation's score from ``analyze_printability`` itself, judged for ``material`` and ``printer_id`` — pass the same ones you gave ``analyze_printability`` and the two numbers match. :param file_path: Path to the STL file. :param output_path: Output path. Defaults to overwriting the in…

Find the structurally strongest version of a parametric template. Sweeps each template parameter across its [min, max] range at evenly spaced sample points, generates every combination via OpenSCAD, runs structural analysis on each variant, and returns the configuration with the highest structural score. Use this when you want to **automatically** find optimal dimensions for a functional part -- e.g. "what wall thickness and bracket height give the strongest shelf bracket?" :param template_id: Template ID from the design template library. :param samples_per_param: Sample points per paramete…

Paint exactly the faces a decoration carve created (Pro-free). A deboss/emboss records which output triangles it created — recess floors and side-walls — in a face-provenance sidecar beside the decorated mesh. This tool paints THOSE faces and nothing else, so a debossed logo with a closed outline (any mark with enclosed regions) colors only its carved strokes: the untouched surface island inside the outline stays the body color, where crease-angle segmentation would have "filled the logo in". Use after any decoration door (``decorate_surface``, ``apply_decoration``, ``apply_decoration_prese…

Move the print head somewhere safe, away from the plate, and leave it there. The retreat, as distinct from ``home_axes`` (the measurement). A park NEVER homes Z and never heats: it raises the head the vendor's way, homes X (an endstop -- nothing is touched), and travels to the model's own off-plate spot -- on a Bambu, the position the machine itself flushes at, served one plan at a time through Kiln's hosted service for a printer paired to your Kiln sign-in, free, and kept on your machine so it works offline. On Marlin, Klipper and RepRapFirmware the firmware's own home position IS the park…

Parse parameter variables from OpenSCAD code. Extracts named dimension variables from the top of an OpenSCAD file, including their values, units, descriptions, and valid ranges (if annotated in comments). Use this after generating OpenSCAD code to discover which parameters can be adjusted. A parameter computed from others (``inner = outer - 2*wall;``) is returned with ``derived: true``, its ``expression`` and ``depends_on``; it moves when those change and cannot be set directly. Args: scad_code: OpenSCAD source code string.

Abort a running or paused pipeline. Immediately marks the pipeline as aborted. Any completed steps are preserved in the result. Args: execution_id: The pipeline execution ID.

Pause a running pipeline at the next step boundary. The pipeline will finish the current step and then pause before starting the next one. Use ``pipeline_resume`` to continue. Args: execution_id: The pipeline execution ID.

Resume a paused pipeline from where it stopped. Continues executing from the next unfinished step. Args: execution_id: The pipeline execution ID.

Retry a specific failed step in a pipeline, then continue from there. Re-runs the step at the given index and, if it succeeds, continues executing the remaining steps. Args: execution_id: The pipeline execution ID. step_index: Zero-based index of the step to retry.

Get the current state of a pipeline execution. Returns the execution state (running/paused/completed/failed/aborted), completed steps, and the name of the next step to run. Args: execution_id: The pipeline execution ID returned when starting a pipeline.

Split a multi-file assembly across printers. Assigns each file in a multi-part assembly to a different printer for parallel printing. Args: file_paths: List of file paths in the assembly. material: Material type (default ``"pla"``).

Generate a recovery plan for a previously detected failure. Uses the failure ID from a prior ``detect_print_failure`` call to look up the failure report and generate an appropriate recovery strategy with preparation steps, parameter adjustments, and risk assessment. **Which recovery tool to use:** - Have a printer_name + job_id from a failed print? → ``plan_print_recovery`` - Have a failure_id from ``detect_print_failure``? → ``plan_failure_recovery`` (this tool) With kiln-pro installed the answer can also carry ``nozzle_wear_hypothesis`` (Kiln Pro), or below Pro ``nozzle_wear_hypothesis_g…

Plan parallel printing of multiple copies across printers. Distributes N copies of a file across available printers in the fleet for maximum parallelism. Args: file_path: Path to the G-code or model file. copies: Number of copies to print. material: Material type (default ``"pla"``).

What Kiln knows is on the build plate -- read-only, no printer round trip. Kiln records the plate at the moments it can be sure of: a print Kiln started puts a part there (``occupied``, with the file and, where Kiln could read it, the part's height); a print seen ending leaves it there; a PERSON says it is empty (``plate_clear=true`` on ``home_axes`` or ``park_head``, or ``kiln plate clear`` at the command line); and a LOOK through the machine's camera settles it either way (``look_at_plate``). Anything else -- no record, a torn record, a print started at the printer's own screen -- reads as…

Get detailed information about a specific plugin. Args: name: Plugin name.

Predict optimal print settings from historical DNA data. Searches for exact file hash matches first, then falls back to geometrically similar models, and finally to material defaults. Args: file_hash: SHA-256 hash of the model file. geometric_signature: Geometric signature from fingerprinting. surface_area_mm2: Surface area in mm^2. volume_mm3: Model volume in mm^3. complexity_score: Model complexity (0.0-1.0). printer_model: Target printer model. material: Target material. geometric_signature_v2: ``fingerprint_model``'s ``geometric_signature_v2``. Pa…

Prepare any AI-generated model for printing — fixes the unit mix-up. AI model generators (Meshy, Tripo, Stability, Gemini) routinely export models in meters instead of millimeters, so a 60mm figurine reads as 0.06mm. This tool corrects that by the real unit conversion when exactly one explains the size — never by scaling to an invented "reasonable" target — then runs the full validation pipeline and provides smart recommendations for simplification and hollowing. Pipeline: 1. Run validate_and_prepare for baseline analysis 2. Size — scale to target_height_mm when given; otherwise …

Specialized post-generation verification renderer. For general-purpose model viewing, use ``visualize_model`` instead. This tool adds generation-specific checks (floating geometry, thin walls) on top of the standard multi-angle renders. Render a 3D model to multi-angle PNG previews for visual inspection. **REQUIRED** before printing any generated model. You MUST call this tool after generating a model and BEFORE printing. View ALL rendered angles to check for: - Missing or simplified features (e.g., plain box instead of pattern) - Incorrect proportions or dimensions - Floating/disconnected…

Confirm a print service order and start processing. Args: order_id: The order ID from ``create_print_service_order``. option: ``"local"``, ``"fulfillment"``, or ``"recommended"``.

Check the status of a print service order. Args: order_id: The order ID to check.

Help Kiln get to know your printer in a few minutes: a guided session, one ask at a time. Kiln judges where a second part can go on an occupied plate from a record of how each printer moves its head on its own. Where that record has a blank -- a pause, cancel or end nobody has described, a head nobody has measured -- Kiln assumes the worst. This session fills the blanks for THIS printer: it prints a coin-sized square, pauses, resumes, cancels and ends it, and watches where the head goes. A Klipper or Marlin printer says where its head is, so nothing about the moves is asked; a closed-firmwa…

How many printers are registered with this Kiln, and what they add to your bill on your plan, at the prices on kiln3d.com/pricing. Free on every plan. Counts the machines registered here, so ask it on the computer your printers are attached to.

Publish a 3D model to one or more marketplaces. Validates the model, optionally generates a print "birth certificate" from print history, and uploads to the specified marketplaces. Args: file_path: Path to the 3D model file (STL, 3MF, OBJ). title: Listing title for the model. description: Listing description (Markdown supported). tags: List of tags for discoverability. category: Model category (e.g. "tools", "art", "gadgets"). license: License type — ``"cc-by"``, ``"cc-by-sa"``, ``"cc-by-nc"``, ``"gpl"``, or ``"public_domain"``. target_marketplaces: Market…

Upload the current print's sliced file so the web Monitor can show the object and scrub its layers. The web Monitor at kiln3d.com calls this through the Kiln bridge while a print is running; there is normally no reason to call it by hand. It reads the engine's own retained copy of the file it last sent to the printer (kept per printer under ``~/.kiln/monitor_twin``), uploads it — gzipped — to YOUR Kiln account, and returns a short-lived artifact token the browser uses to fetch the mesh and toolpath. Nothing is uploaded except by this explicit call, and nothing crosses tenants: the token is …

Heat the nozzle and extrude a short length — the clog test. Reports what the printer could honestly say, not that a command was sent: ``extrusion_verified`` is ``False`` with ``error_hint`` when the firmware refused the move (cold-extrusion guard, Klipper ``can_extrude=false``) or raised an extrusion fault during or right after the purge (Bambu HMS codes, decoded to plain language); ``None`` when the move was accepted and the machine reports no flow signal — every backend without a flow sensor — in which case look at the nozzle for a clean stream. It is never ``True`` on a purge alone. Refu…

Get an overview of the print job queue. Returns counts by status, next job to execute, recent jobs, and ``watch_alerts``: watched prints that have stalled or stopped answering and need a person (they stay active until the printer ends them or someone cancels).

All-in-one adaptive slicing: analyze geometry + generate plan. Convenience tool that combines geometry analysis and plan generation in a single call. Ideal when you have basic model info and want a quick adaptive plan without multiple tool calls. Args: material: Material name (PLA, PETG, ABS, etc.). model_height_mm: Total model height in mm. model_name: Optional model name. nozzle_diameter_mm: Nozzle diameter in mm. Leave unset for the nozzle Kiln has for ``printer`` (or the only printer it knows of), else 0.4; the reply's ``nozzle`` says which. mode: Ad…

Re-execute the full build pipeline from a saved design recipe. Two modes, chosen by what the recipe carries — the result names which one ran: - **Parametric** (the recipe has OpenSCAD source): the geometry is RE-DERIVED. The recipe's numeric parameters are applied to the source and recompiled, so wall thicknesses and fastener holes come out exactly as designed. To resize a parametric design, change the parameter — with ``update_scad_parameter`` on the source, or on the recipe's parameters — and rebuild. Never scale the mesh instead: it scales every feature with the body, so a…

Recommend brim/raft settings for a 3D model based on geometry + material. Analyzes the model's bed contact area, material warp tendency, and printer type to produce a concrete brim width and optional raft recommendation. Returns ``slicer_overrides`` ready to pass to ``slice_model`` or ``slice_and_print``. Args: model_path: Path to an STL or OBJ mesh file. material: Filament material (e.g. ``"PLA"``, ``"ABS"``, ``"PETG"``). Affects warp risk calculation. printer_id: Optional printer model ID (e.g. ``"bambu_a1"``). Used to detect bed-slinger printers that need wid…

Recommend material for engineering/functional parts (strength, heat, environment). Analyzes functional requirements and recommends the optimal material considering mechanical needs, environmental exposure, printer capabilities, and ease of printing. Returns the top recommendation with reasoning, warnings, and alternatives. **Which material tool to use:** - Designing a part and need engineering specs? → ``recommend_design_material`` (this tool) - Quick intent-based pick for your own printer? → ``recommend_material`` - Ordering a print from a service? → ``suggest_material_for_order`` Args: …

Recommend specific reinforcements for an STL mesh. Analyzes geometry to find structural risks, then generates actionable recommendations with **specific locations** and what each one does for the part: - **gusset**: triangular support at cantilever bases - **fillet**: smooth transitions at stress concentrations - **thicken_wall**: add material at thin necks - **add_base**: widen the base for stability - **reorient**: change print orientation for layer strength Each recommendation includes the coordinates where the reinforcement should be applied and which Kiln tool to use (e.g., ``add_mesh_f…

Recommend material from intent + printer capabilities (considers enclosure, bed, budget). Uses printer DNA + historical data to translate natural language intent (e.g. ``"make it strong"``, ``"make it pretty"``, ``"make it cheap"``) into an optimal material recommendation with settings. Pass ``printer_id`` to answer for a SPECIFIC machine — essential on a mixed fleet, where "what should I run this in" depends on which printer will run it. The recommendation is then computed against that machine's nozzle state (abrasive materials on a brass nozzle get an explicit wear warning) and the respon…

Recommend print settings based on historical successful outcomes. Queries the learning database for settings that produced successful prints, filtered by printer, material, and/or file hash. Returns aggregated recommendations (most common temps, speeds, slicer profiles) plus the raw successful settings for agent review. When kiln-pro is installed AND the user has a calibrated slicer profile for ``(printer_name, material_type)``, the calibration coach overlays personally-tuned values (flow rate, max volumetric speed, pressure advance, retraction distance) on top of the historical medians. T…

Record a successful print with a saved decoration (Kiln Pro). After a decoration prints well, call this with the settings that worked. ``apply_decoration`` then replays them on that material. :param name: Decoration name or slug. :param material: Material used (e.g. ``"PLA"``, ``"PETG"``). :param depth_mm: Depth in mm that printed well. :param mode: ``"emboss"`` or ``"deboss"``. :param image_style: Image style that worked (e.g. ``"coin"``). :param source_job_id: The print's job id when known: the same print reported twice (here and through ``record_print_outcome``) counts once. :ret…

Record a print outcome with full model DNA. Saves the model fingerprint alongside print settings and outcome for cross-user learning. Use ``fingerprint_model`` first to compute the fingerprint fields. Args: file_hash: SHA-256 hash of the model file. geometric_signature: Geometric signature from fingerprinting. triangle_count: Number of triangles in the model. surface_area_mm2: Total surface area in mm^2. volume_mm3: Model volume in mm^3. overhang_ratio: Ratio of overhanging triangles (0.0-1.0). complexity_score: Model complexity (0.0-1.0). printer_model: Prin…

Record the outcome of a print for cross-printer learning. The learning database helps agents make better decisions about which printer to use for a given job and material. Outcomes are agent-curated quality data — separate from the auto-populated print history. **Safety**: Settings are validated against hard safety limits. Outcomes with temperatures exceeding safe maximums are rejected to prevent poisoning the learning database with dangerous data. **Decoration feedback**: When ``decoration_slug`` is provided, the corresponding decoration's proven-settings counter is auto-updated (``succe…

Record a post-recovery monitoring check result. After recovery execution, monitoring checks verify the print is proceeding correctly. Args: session_id: The session_id being monitored. passed: Whether this monitoring check passed. notes: Optional notes about the check result.

Record a revenue event (sale, royalty, tip, or refund). Args: model_id: File hash or listing ID of the model. marketplace: Marketplace name (e.g. ``"thingiverse"``). amount_usd: Amount in USD. transaction_type: Type — ``"sale"``, ``"royalty"``, ``"tip"``, or ``"refund"``. currency: Currency code (default ``"USD"``). description: Optional description of the transaction.

Release an exclusive lock on a printer. Args: printer_name: Printer to unlock. holder: Identifier of the lock holder (must match acquire).

Remove an interception rule from an active session. Args: session_id: Target session ID. rule_id: The rule ID to remove.

Remove small disconnected components (floating geometry). Downloads and marketplace models often contain support pillars, internal fragments, or other floating geometry. This tool identifies connected components and removes the small ones. :param file_path: Path to the STL file. :param output_path: Output path (defaults to overwriting input). :param keep_largest: Keep only the largest component (default True). :param min_triangle_pct: Min triangle % to keep (when keep_largest=False). :returns: Dict with removal statistics.

Walk through the printer maker's own repair guide, one step per call. The guide is the maker's published page for THIS model, reproduced in the maker's order: their power-off warning first, their numbered steps in their words, their picture for each step (as a URL, served from their site with attribution -- Kiln never copies it), and their own check at the end where the page has one. Kiln adds words only where the picture cannot say it. Where the maker states them, the header carries the tools, the interval ("every 10-15 spools") and the parts. **Run it in steps, with the person at the mac…

Repair mesh defects: rounding-noise seams, degenerates, holes. Every pass first welds vertices that are coincident up to a tiny radius (0.1 µm by default) — scanned and AI-generated meshes routinely carry float rounding jitter that reads as thousands of phantom open edges, and welding is the honest fix for those. The default pass then removes zero-area triangles and recomputes face normals. Pass ``close_holes=True`` for the deep pass, which additionally finds boundary edges (edges shared by only one triangle) and closes small holes via fan triangulation — use it when the mesh is not waterti…

Deprecated alias for ``repair_mesh(close_holes=True)``. Kept for one release so existing callers keep working; new callers should use ``repair_mesh`` with ``close_holes=True``. Behavior is identical to the original tool. :param file_path: Path to the STL file. :param output_path: Output path. Defaults to overwriting the input. :param close_holes: Whether to attempt closing holes (default True). :param weld_tolerance: Weld radius in mm. Empty = auto; "0" disables welding. :returns: Dict with repair statistics.

Rescale an STL model to meet dimensional targets. Useful when a generated model is the wrong size for the printer's build volume or doesn't match the desired dimensions. **Uniform scaling** -- provide exactly ONE of: - ``target_height_mm``: Scale so Z-axis equals this value. - ``scale_factor``: Uniform multiplier (2.0 = double size). - ``max_dimension_mm``: Scale down so largest axis fits this limit. **Per-axis scaling** -- provide ``scale_x``, ``scale_y``, and/or ``scale_z``. Omitted axes default to 1.0 (no change). Cannot combine uniform and per-axis options. Args: file_path: Path…

Reslice a 3D model with custom slicer parameter overrides. Accepts a base printer profile and a JSON dict of overrides to customize the slice. Common override keys (PrusaSlicer INI format): Adhesion: brim_width (mm), skirts (count), skirt_distance (mm) Temperature: temperature, first_layer_temperature, bed_temperature Speed: perimeter_speed, infill_speed, external_perimeter_speed, first_layer_speed, travel_speed (mm/s) Structure: fill_density (e.g. "25%"), fill_pattern (gyroid/grid/honeycomb), layer_height Support: support_material (0/1), support_material_buildplate_only (0/1) Re…

Resolve a material name or brand ID to a unified filament profile. Accepts EITHER a generic material (``"PLA"``, ``"TPU"``) OR a specific brand profile ID (``"bambu_pla_basic"``, ``"prusament_tpu_95a"``). Brand profiles return manufacturer-exact specs (density, temps, drying, nozzle/enclosure requirements). Generic materials return conservative defaults. When ``printer_id`` is provided, also checks compatibility and returns warnings (e.g. "needs hardened nozzle", "needs enclosure", "not AMS compatible"). Use this BEFORE slicing or printing to get exact filament specs. Pass the result to ``…

Decrypt and return a stored credential. Args: credential_id: The credential's unique identifier.

Diagnose the last print failure and re-slice + print with fixes. When a print fails, call this tool instead of manually chaining ``diagnose_print_failure_live`` → ``slice_and_print``. It: 1. Reads live printer state and analyses the model geometry to diagnose the failure (unless ``skip_diagnosis`` is True). 2. Auto-detects the loaded material from the AMS when ``material`` is omitted and the printer supports it. 3. Merges diagnosis-recommended slicer overrides with any ``custom_overrides`` you supply (your overrides win on conflict). 4. Re-validates the mesh's printability befor…

Get aggregate revenue analytics dashboard. Returns total revenue, sales count, top models, monthly trends, and marketplace breakdown. Args: days: Number of days to include (default 30).

Close a standing consent window now. Prints ask the person again. The person opened the window — in the approval dialog or at a terminal — and can close it here, through you, without touching a terminal: when they say to close it, call this. Closing is the safe direction, so it needs no confirmation and no window can refuse it. Jobs queued under the window will not start. This is also how always allow is turned off: when the person says "ask me first", call this with the printer's name (or the id on the print result) and show them the ``note`` as written. Args: window_id: The window …

Restore an earlier version of a saved decoration (Kiln Pro). The current version is archived and the earlier one comes back as a NEW version number, so history is never rewritten. :param name: Decoration name or slug. :param version: Version number to restore. :returns: Dict with the restored decoration.

Rollback a design to a previous version. Creates a *new* version whose source matches the target version, preserving full history. The new version's notes record the rollback origin. Args: design_id: The design to rollback. to_version_id: The version number (integer) or ``design_id:N`` ref to restore. Returns: The newly created rollback version record.

Rollback firmware on a specific printer by name (fleet-level, supports version pinning). Use this in multi-printer setups. For single-printer setups, use ``rollback_firmware`` instead. Args: printer_name: Printer to rollback. target_version: Specific version to rollback to.

Rotate the G-code encryption key by re-encrypting all files. Scans *directory* recursively for encrypted G-code files, decrypts with the old passphrase, and re-encrypts with the new one. **Run with ``dry_run=True`` first** to preview which files would be affected. Then call again with ``dry_run=False`` to execute. After rotation, update the ``KILN_ENCRYPTION_KEY`` environment variable to the new passphrase and restart the server. Args: old_passphrase: The current KILN_ENCRYPTION_KEY value. new_passphrase: The new passphrase to encrypt with. directory: Root directory to scan fo…

Route a print job to the best available printer in the fleet. Scores each registered printer on material match, availability, queue depth, and historical success rate, then recommends the best assignment with scored alternatives. Every candidate also carries a ``plate`` block -- whether the plate as it stands has room for this part and how a print there would start. A machine with no room, or a plate Kiln has no record of, is never recommended; when none has room the answer is a refusal (``NO_ROOM``) with each machine's own sentence. A print that would start the quiet way beside a part sti…

Query the safety audit log. Returns a record of all safety-relevant operations: tool executions, blocked attempts, rate-limit violations, and preflight failures. Args: action: Filter by action type. Options: ``"executed"``, ``"blocked"``, ``"rate_limited"``, ``"auth_denied"``, ``"preflight_failed"``, ``"dry_run"``. Omit for all. tool_name: Filter by MCP tool name (e.g. ``"send_gcode"``). limit: Maximum number of records to return (default 25, max 100).

Show current safety and auto-print settings. Displays whether auto-print is enabled for marketplace downloads and AI-generated models, and which printers have always allow on, along with guidance on how to change them. Call this early in a session to understand what safety protections are active.

Get a comprehensive snapshot of all active safety measures. Returns a single summary showing: the active safety profile, temperature limits, rate-limit configuration, recent blocked actions, authentication status, and confirmation-mode status. Use this to answer "is my printer safe right now?" in a single call.

Save a persistent note or preference that survives across sessions. Use this to remember printer quirks, calibration findings, material preferences, or any operational knowledge worth preserving. Args: key: Name for this memory (e.g., ``"z_offset_adjustment"``, ``"pla_temp_notes"``). value: The information to store. scope: Namespace — ``"global"``, ``"fleet"``, or use *printer_name* for printer-specific. printer_name: If provided, scope is automatically set to ``"printer:<name>"``. ttl_seconds: Optional time-to-live in seconds. The note will be automatically excl…

Save a proven decoration to the library for reuse on future models. Captures the content file (heightmap, SVG, image), settings (depth, mode, material), and processing pipeline from the ``.kiln_recipe.json`` sidecar so the exact same decoration can be applied to new models with ``apply_decoration``. :param name: Human-readable name (e.g. "Ash Portrait"). :param model_path: Path to the model that was just decorated. :param content_type: Content type — ``photo``, ``svg``, ``qr``, ``text``, or ``auto`` (detect from file extension). :param source_path: Path to the original input file (photo,…

Save a new version of a parametric design. Automatically computes a unified diff from the previous version, increments the version number, and persists a versioned recipe sidecar (``~/.kiln/designs/<design_id>/.kiln_recipe.vN.json``). **Upgrade to Kiln Pro** for automatic mesh fingerprinting, regression detection (warns when features are lost between versions), and ``.kiln.json`` sidecar provenance files that travel with your STLs. Args: design_id: Identifier grouping versions of the same design. scad_source: Full OpenSCAD source code for this version. prompt: The natural-langua…

Save a local shipping profile after explicit user consent. Args: name: Profile name, e.g. ``"home"`` or ``"office"``. shipping_address: Full shipping contact/address dict. Keys: ``first_name``, ``last_name``, ``email``, ``phone``, ``street``, ``city``, ``postal_code``, ``country``; include ``state`` for US addresses. overwrite: Replace an existing profile with the same name. set_default: Make this the default shipping profile. consent_to_store: Must be ``True``. This is the explicit consent gate for storing personal contact/address data.

Auto-scale a mesh to fit within a build volume while maintaining aspect ratio. Useful when a model is too large for your printer -- this uniformly shrinks it to the largest size that fits. :param file_path: Path to mesh file (.stl). :param max_x_mm: Maximum X dimension of build volume. :param max_y_mm: Maximum Y dimension of build volume. :param max_z_mm: Maximum Z dimension of build volume. :param printer_id: Optional supported printer model id. When provided, printer intelligence supplies the build volume. :param output_path: Output path. Defaults to overwriting input. :returns: Dict …

Search across all connected 3D model marketplaces simultaneously. Searches Thingiverse, MyMiniFactory, Cults3D, and MakerWorld in parallel and returns interleaved results from all sources. Note that MakerWorld returns a search URL (no direct API access) while other sources return actual model results. Args: query: Search keywords (e.g. "raspberry pi case", "benchy"). page: Page number (1-based, default 1). per_page: Results per source (default 10). sort: Sort order — "relevant", "popular", or "newest". sources: Optional list to restrict search (e.g. ["thingiverse", …

Search the local model cache by name, source, tags, or prompt text. Args: query: Free-text search against file name, prompt, and tags. source: Filter by source (e.g. ``"thingiverse"``). tags: Comma-separated tags to filter by. limit: Maximum results (default 20). The response declares its ``scope``: this cache is local to this machine, so the count is what THIS install has cached, not everything the user has ever downloaded or generated.

Search design versions by prompt, notes, or design name. Scans all design directories under ``~/.kiln/designs/`` for versioned recipe files whose prompt, notes, or name fields contain the query string (case-insensitive). Args: query: The search term (literal substring, not regex). limit: Maximum number of results to return (default 10). Returns: A list of matching version records, newest first, plus a ``scope`` block saying which store was searched and whether the user's cloud-side versions were included. A miss here is only a miss in the stores ``scope`` names.

Search Thingiverse for 3D-printable models. Args: query: Search keywords (e.g. "raspberry pi case", "benchy"). page: Page number for pagination (1-based, default 1). per_page: Results per page (default 10, max 100). sort: Sort order — "relevant", "popular", "newest", or "makes". Returns a list of model summaries including name, creator, thumbnail, and download/like counts. Use ``model_details`` with the ``id`` to get full information, and ``model_files`` to see downloadable files.

Declare which curated hardware variant your machine actually is. This is how an operator with a modified printer gets an accurate ceiling WITHOUT typing one. You say which hardware you have; Kiln supplies the limit from curated, manufacturer-sourced data. There is no argument here that accepts a temperature, which is the point: a limit Kiln enforces is always a limit Kiln verified. Check ``requires`` on the variant first — a ceiling is only true if its preconditions are met. Several variants need a firmware change as well as the part, and selecting the variant is your statement that you h…

Open Kiln's interactive 3D stage on a file that already exists. The door for "let me see it" when nothing needs making: a mesh from an earlier session, a download, or the sliced print file about to go to the printer. Nothing is re-made, re-sliced, imported or written. Free on every install, like the stage. What the stage draws (``shows`` says which, in words): - An STL, OBJ or 3MF is drawn as itself; a STEP file is drawn from Kiln's mesh of it. - A sliced ``.gcode.3mf`` is drawn as the model it carries — the file going to the printer, in its paint — with the slicer's skirt, brim, pr…

Reduce mesh triangle count for faster preview or smaller files. Uses vertex-clustering decimation to merge nearby vertices. The result is a lower-resolution version of the same shape. :param file_path: Path to the STL file. :param target_ratio: Target fraction of original triangles (0.01-1.0). :param output_path: Output path (defaults to ``<name>_simplified.stl``). :returns: Dict with original/simplified triangle counts and reduction percentage.

Primary estimation tool — slice a 3D model and return time, filament, cost, and printability analysis. For G-code files (already sliced), use ``estimate_cost`` instead. For quick volume-based estimates without slicing, use ``estimate_material_cost``. Slices the model using PrusaSlicer or OrcaSlicer, parses the output G-code for time and filament metadata, runs printability analysis on the file as it was sliced (a STEP file as Kiln's mesh of it), and returns adhesion recommendations — all without uploading or starting a print. When the analysis could not be made, ``printability`` is null and…

Slice a 3D model (STL/3MF) + upload + print in one step (basic pipeline). ``version_id`` / ``design_id`` / ``branch_id`` name the kept design this file came from, when there is one: the print's record then lands on that version's history (what printed, on which machine, how it ended) instead of on a bare file name. A file that is not a Kiln design passes none and is recorded by file alone. Colour is a promise kept here. A part made in a colour (the ``color`` the make was asked for, or the one its source named) prints from a loaded spool of that colour: on a printer with an AMS the slot is …

Slice a 3D model (STL/3MF/STEP) to G-code using PrusaSlicer or OrcaSlicer. Args: input_path: Path to the input file (STL, 3MF, STEP, OBJ, AMF). output_dir: Directory for the output G-code. Defaults to the system temp directory. profile: Path to a slicer profile/config file (.ini or .json). printer_id: Optional printer model ID for bundled profile auto-selection (e.g. ``"prusa_mini"``). slicer_path: Explicit path to the slicer binary. Auto-detected if omitted. material: Filament material for this slice (``"PLA"``, ``"PETG"``, ``"TPU"``,…

Generate from template + structural analysis + print settings (recommended for functional parts). Higher-level than ``generate_from_template`` — adds structural risk analysis and auto-reinforcement. This is the **one-step design-to-print-ready** pipeline: 1. Generates STL from a parametric template (like ``generate_from_template``) 2. Runs structural risk analysis (thin necks, cantilevers, sharp corners) 3. Optionally auto-applies reinforcements (fillets, wall thickening, etc.) 4. Infers optimal slicer settings tuned to the design's structural profile 5. Returns the STL path + recommended se…

Solve parametric constraints to find valid template parameters. Given a template and constraints (min/max/equals/ratio), iteratively adjusts parameters to satisfy all constraints while staying within the template's declared parameter ranges. :param template_id: Template identifier (e.g., "shelf_bracket"). :param constraints: JSON object mapping param names to constraint dicts. Example: ``{"width": {"min": 20, "max": 50}, "height": {"equals": 30}}`` Supported keys: min, max, equals, ratio (e.g. ``{"ratio": ["width", 0.5]}``). :returns: Dict with solved_params, satisfied/violated const…

Splice two meshes at a z-plane: top from one STL, bottom from another. Takes geometry ABOVE *z_plane* from *top_path* and geometry BELOW *z_plane* from *bottom_path*. Triangles crossing the boundary are clipped cleanly. No boolean ops -- works on non-manifold meshes. **Use case:** Combine a body with the correct top (e.g. logo from v5.3) with a body that has the correct bottom (e.g. larger pocket from v5.4) to create the next design iteration. :param top_path: STL providing geometry above z_plane. :param bottom_path: STL providing geometry below z_plane. :param z_plane: Z height (mm) wher…

Split a multi-component mesh into separate STL files. Identifies disconnected bodies (components) using shared-edge analysis and writes each as a separate file. :param file_path: Path to mesh file (.stl). :param output_dir: Directory for output files. Defaults to input directory. :returns: Dict with component count and file paths.

Check the progress of a split plan. Args: plan_id: The plan ID returned by submitting a split plan.

Exchange an SSO authorization code for user identity and role. Enterprise feature. After the user completes IdP login, exchange the auth code to get their identity, email, groups, and mapped Kiln role. Args: code: The authorization code from the IdP callback.

Get the SSO login URL to redirect users to the identity provider. Enterprise feature. Returns the IdP authorization URL for OIDC or the SAML AuthnRequest redirect URL. Args: state: Optional opaque state parameter for CSRF protection.

Check current SSO configuration status. Enterprise feature. Returns whether SSO is configured, the protocol, issuer, allowed domains, and role mapping.

Open a small test cube on Kiln's 3D stage. Diagnostic: makes a 20mm cube and hands it back the same way a real design would, so the only question left is whether this app renders the panel.

Start a real-time G-code interception session for a printer. Automatically loads safety-profile-based rules (temperature limits, feedrate caps, blocked commands) for the printer. Use ``add_interception_rule`` to add custom rules after starting. Args: printer_name: Target printer name (e.g. "ender3", "voron-350"). Returns a session ID and initial rule set. AGENT CONTRACT: when ``coverage_warnings`` is non-empty this session is running with reduced protection (generic temperature limits, or no bed-fit rules because the build volume is unknown). Relay those warnings to the user verbatim…

Start a print and automatically monitor the first layer. This is the recommended way to start prints autonomously. It combines start_print with first-layer monitoring in a single operation: 1. Starts the print 2. Waits for the configured delay (default 2 minutes) 3. Captures snapshots during first layers 4. Returns snapshots for you to visually inspect 5. Optionally auto-pauses if you report a failure Use this instead of start_print when operating autonomously (Level 1/2) to satisfy the first-layer monitoring safety requirement. Args: file_name: Name of the file to print (must exist on…

Begin executing a recovery plan. Creates a recovery session that tracks the recovery lifecycle. Args: plan_id: The plan_id from a plan_failure_recovery result. failure_id: The failure_id this recovery addresses.

Extract metadata from a STEP file without converting it. Parses the STEP ASCII header to extract product names, estimated body count, file schema, and other metadata. This is fast and requires no external backend. Use this to inspect a STEP file before deciding whether to import it. Args: file_path: Path to the STEP/STP file.

Stop a G-code interception session. Args: session_id: The session ID returned by ``start_gcode_interception``. Returns the final session stats.

Stop a background print watcher and return its final state. Signals the watcher thread to exit and removes it from the active watchers registry. Args: watch_id: The watcher ID returned by ``watch_print``.

Encrypt and store a credential (API key, webhook secret, etc.). The value is encrypted at rest using PBKDF2 + XOR stream encryption. Only metadata is returned — the plaintext is never exposed. Args: credential_type: Type of credential (api_key, webhook_secret, stripe_key, marketplace_token, printer_password). value: The plaintext secret to store. label: Human-readable description.

Submit a print job to the queue. ``version_id`` / ``design_id`` / ``branch_id`` name the kept design the file came from, when there is one; the scheduler hands them to the start so the print's record lands on that version's history. Free tier allows up to 10 queued jobs for single-printer use. Pro tier unlocks unlimited queue depth with multi-printer scheduling. Args: file_name: G-code file name (must already exist on the printer). printer_name: Target printer name, or omit to let the scheduler pick any idle printer. priority: Higher values are scheduled first (default 0…

Suggest a material when ordering a print from a fulfillment provider. Use this when routing a print job to a fulfillment provider and need to pick the right material + technology for the order. **Which material tool to use:** - Ordering a print from a service? → ``suggest_material_for_order`` (this tool) - Designing a part and need engineering specs? → ``recommend_design_material`` - Quick intent-based pick for your own printer? → ``recommend_material`` Args: use_case: What the part is for. Options: decorative, functional, mechanical, prototype, miniature, jewelry, enclosure, w…

Suggest the best printer for a job based on historical outcomes. Rankings are based on success rates from previously recorded outcomes, optionally filtered by file hash or material type. Cross-references the printer registry for current availability. **Note**: Suggestions are advisory. They do NOT override safety limits or preflight checks. Always run preflight validation before starting a print regardless of learning data. Each suggestion also says ``has_room``: whether that printer's plate, as Kiln's record has it, can take a print right now (a clear plate; a part still on it, or no re…

Suggest minimal spool swaps to run all queued jobs. Compares what the jobs need with what is loaded and says which shelf spools to load, and where. On one machine it answers for that machine; across several machines it plans the fewest physical spool changes between them (Kiln Business, https://kiln3d.com/pricing). Args: jobs: List of job dicts with ``material_type`` and ``required_grams``.

List all countries supported for fulfillment shipping. Returns ISO country codes and full names for all 23+ countries where Kiln fulfillment providers can ship manufactured parts.

Preview the complete price breakdown — including tax — before placing an order. Terms §7 contract: "Preview the tax for any order with the ``tax_estimate`` tool before placing it. We display the full fee + tax breakdown before charging. No hidden fees." This tool fulfills that contract by returning the same line items the order will commit to at charge time. Per Terms §7 tax is computed on the orchestration fee ONLY — never on the manufacturer's quoted total. The manufacturer is responsible for any taxes on their own charges. Two calling shapes are supported: 1. **Canonical preview** (…

Look up tax details for a specific region (rate, type, B2B exemptions). Args: code: Jurisdiction code (e.g. "US-CA", "DE", "GB", "AU"). Use ``tax_jurisdictions`` to browse all codes.

List all 22 supported regions so the agent can match the user's location. Returns jurisdiction codes, tax types, and rates for the US (8 states), EU (7 countries), UK, Canada (4 provinces), Australia, and Japan. Pass the matching code to ``fulfillment_order`` or ``tax_estimate`` to include tax in the price breakdown.

Thicken a part's walls by moving every surface out *amount_mm*. Two routes, and the reply says which ran: * **The CAD file** -- pass the part's STEP file (``.step`` / ``.stp``), or a mesh Kiln converted from one that still sits beside it. The CAD kernel moves every face exactly, and round holes keep their size so screws still fit. Walls gain twice the amount; the outside grows twice the amount on every axis. * **A mesh** with no CAD file -- vertices are moved and the result is MEASURED against the input: the thinnest wall must gain at least the amount, the surface must stay clo…

Close leftover Kiln servers left behind by closed sessions. Every agent session spawns its own background Kiln server; client apps don't reliably close them when a session ends, so they accumulate and quietly hold memory. This is the cleanup the pile-up warning (health_check / kiln_health / get_started) offers. WHY THIS IS SAFE: closing a server never stops a physical print — the printer keeps going regardless. What a close can end is MONITORING (a running watch loop). So this refuses to act while any printer has a job in flight, and otherwise the worst case is that a still-open session reco…

Diagnose a 3D printing problem by material and symptom. Searches the troubleshooting knowledge base for matching issues and returns root causes, prioritised fixes, prevention tips, and storage/drying requirements for that specific symptom. Use this when a user reports a print failure, quality issue, or asks "why is my print doing X?" Examples: material="pla", symptom="stringing" material="petg", symptom="poor layer adhesion" material="abs", symptom="warping" Args: material: Material ID (e.g. "pla", "petg", "abs", "tpu", "nylon", "polycarbonate", "asa", "cf_nylon"). …

Add a printer hostname/IP to the trusted whitelist. Trusted printers are flagged during network discovery. Connecting to an untrusted printer should raise a warning. Args: host: The hostname or IP address to trust.

Update a parameter in OpenSCAD code and recompile to STL. The complete parametric tweaking workflow: changes a dimension variable, validates against material limits, and compiles a new STL — all in one step. Perfect for "make it 5mm wider" requests. A tweak that leaves a piece floating with nothing under it is refused like a compile is (``code: "FLOATING_PIECES"``, the fix in ``error``). ``color`` shows the part in the colour the user asked for, as on ``compile_scad``. Args: brief_id: The saved goal's id from ``design_session``; pass it so this make joins the goal (recorded aga…

Pull filament out of the hotend — back into the AMS on Bambu, a heated retract elsewhere. Same temperature gate, verification, ``outcome`` vocabulary and wait bound as ``load_filament``: on Bambu ``extrusion_verified`` is ``True`` once the AMS reports no tray feeding the nozzle (``tray_now`` 255); on Klipper an ``UNLOAD_FILAMENT`` / ``M702`` macro is used when the config has one; otherwise the hotend is heated and ``length_mm`` is retracted (default 80). Args: material / temperature / length_mm / wait_seconds / keep_hot / printer_name: as ``load_filament``. Unload never retracts…

Unlock a previously locked safety profile. Enterprise feature. Allows community profile modifications for this printer model again. Args: printer_model: Profile identifier to unlock.

Remove a printer hostname/IP from the trusted whitelist. Args: host: The hostname or IP address to untrust.

Push a telemetry snapshot to an active interception session. Telemetry is used by rules that evaluate live device state (temperature thresholds, thermal runaway detection, flow anomalies). Call this periodically during printing (e.g. every few seconds). Args: session_id: Active session ID. hotend_temp: Current hotend temperature (C). hotend_target: Target hotend temperature (C). bed_temp: Current bed temperature (C). bed_target: Target bed temperature (C). position_x: Current X position (mm). position_y: Current Y position (mm). position_z: Current Z position …

Start a firmware update on a specific printer by name (fleet-level, supports version pinning). Use this in multi-printer setups. For single-printer setups, use ``update_firmware`` instead. Args: printer_name: Printer to update. target_version: Specific version to update to (latest if None).

Assign a printer to a physical site/location with optional tags. Args: name: Registered printer name. site: Physical site or location label (e.g. ``"nyc-lab"``, ``"chicago-floor-2"``). tags: Comma-separated key=value pairs for metadata (e.g. ``"building=A,floor=3,owner=team-alpha"``). Requires Enterprise license.

Update a parameter value in OpenSCAD code. Finds the named variable declaration and replaces its value, preserving comments and formatting. Use this to tweak dimensions without regenerating the entire model. A derived parameter is refused with a message naming its formula and the parameters to change instead. Args: scad_code: OpenSCAD source code string. parameter_name: Name of the variable to update. new_value: New numeric value for the parameter.

Update the Kiln package to the latest version — for the user. The Apple-grade upgrade path. When a newer Kiln is available (or a hosted call returns an upgrade-required signal), OFFER to handle it: ask "want me to update Kiln for you now?" and call this with confirm=True once they agree. Don't make the user run a pip command. AGENT CONTRACT (important): * NEVER call this while a print is active — wait until it finishes. Swapping Kiln mid-print is unsafe. * Confirm with the user first; this changes their installed software. Pass confirm=True only after they say yes. * On success…

Get rolling uptime statistics and SLA status. Enterprise feature. Shows uptime percentages for 1h, 24h, 7d, and 30d windows, average response times, and whether the 99.9% SLA target is being met.

Comprehensive validation pipeline for any 3D model before printing. Runs format check, mesh analysis, watertight check, auto-repair, printability analysis, structural assessment, bed-fit check, and (optionally) material-specific checks. Returns a detailed pass/fail report with actionable recommendations plus a numeric printability score (0-100). Works with any model — AI-generated, downloaded from marketplaces, or created in CAD. Every model passes Kiln's engineering review before it touches your printer. Each step is resilient — if a step's underlying module is unavailable the step is ski…

Full validation pipeline: validate, repair, analyze, and prepare a mesh for printing. **See also:** ``validate_and_prepare`` for a more comprehensive 10-step pipeline (format, mesh, scale, repair, printability, structural, bed-fit, material, and cost estimation). Runs every AI-generated mesh through Kiln's engineering review before it reaches the slicer or printer. Chains validation → auto-repair → printability analysis → build volume check into a single quality gate. **Use this instead of ``validate_generated_mesh`` when you want the full pipeline** — repair, printability scoring, build v…

Validate an assembly for correctness and printability. Runs clearance checks and joint validations on the assembly, returning the validated assembly state with results populated. Args: assembly_json: JSON string of the current assembly state. printer_id: Optional printer identifier (e.g. ``"bambu_a1"``). When supplied AND kiln-pro is installed, each joint that drives a screw into a printed part gains a ``screw_hole`` block with the compensated hole diameter, thread engagement, install-torque ceiling, and lead-in chamfer (Bambu-calibrat…

Validate a 3D model against functional design requirements. Checks that a generated STL/OBJ model meets the structural, dimensional, and manufacturability constraints implied by the requirements. Returns pass/fail per check with specific fix suggestions for any failures. Call this AFTER generating a model and BEFORE printing it. If validation fails, use the fix suggestions to improve the generation prompt and regenerate. Args: file_path: Path to STL or OBJ file. requirements: Same requirements text used for analyze_design_requirements. material: Optional material (e.g. "petg").

Validate G-code syntax and basic safety (generic, no printer-specific limits). For printer-specific safety validation (PTFE temp caps, speed limits), use ``validate_gcode_safe`` with a ``printer_id`` instead. Args: commands: One or more G-code commands separated by newlines. Returns a JSON object with: - ``valid``: whether all commands passed safety checks - ``commands``: the parsed command list - ``errors``: blocking issues (temperature limits, firmware commands) - ``warnings``: non-blocking advisories (Z below bed, high feedrate) - ``blocked_commands``: specific commands that were blo…

Validate G-code with printer-specific safety limits (PTFE temp caps, speed limits). Preferred over ``validate_gcode`` when you know the target printer — uses that printer's safety profile for accurate limits. Without a printer_id, falls back to conservative generic defaults. Args: commands: G-code commands separated by newlines. printer_id: Optional printer model ID for profile-aware validation.

Validate a 3D mesh file for printing readiness. Checks that the file is a valid STL, OBJ, GLB, or 3MF, has reasonable dimensions, an acceptable polygon count, and is manifold (watertight). Args: file_path: Path to an STL, OBJ, GLB, or 3MF file.

Validate print quality after a completed print job. Captures a webcam snapshot (if available), examines the job record and events, and produces a quality assessment with recommendations. Args: job_id: The completed job's ID. If omitted, uses the most recent completed job. printer_name: Target printer name (omit for default printer). save_snapshot: Optional file path to save the post-print snapshot. Returns a quality report with snapshot data, job metrics, and any detected issues.

Validate OpenSCAD parameters against material design limits. Checks if parameter values (wall thickness, hole diameter, etc.) violate the design limits for the specified material. Catches issues before compilation and printing. Args: scad_code: OpenSCAD source code string. material: Optional material ID (e.g. "pla", "petg") to check against material-specific limits.

Validate and normalize a shipping address for fulfillment orders. Args: street: Street address (e.g. "123 Main St"). city: City name. country: ISO 3166-1 alpha-2 country code (e.g. "US", "GB", "DE"). state: State/province (recommended for US addresses). postal_code: ZIP/postal code (validated per country format). Checks required fields, validates postal codes per country (US ZIP, Canadian postal, UK postcode), and returns warnings for missing optional fields. Use the ``normalized`` address in the response when placing fulfillment orders.

Verify HMAC signatures on all safety audit log entries. Checks each audit log row against its stored HMAC signature to detect tampering. Returns counts of valid, invalid, and total entries along with an overall integrity status.

Start background monitoring of an in-progress print. Launches a background thread that polls the printer state every *poll_interval* seconds and captures webcam snapshots every *snapshot_interval* seconds. Returns immediately with a ``watch_id`` that can be used with ``watch_print_status`` and ``stop_watch_print``. The watcher finishes automatically when: 1. **Print terminal state** -- completed, failed, cancelled, or offline. 2. **Snapshot batch ready** -- *max_snapshots* images collected. 3. **Timeout** -- the print has not finished within *timeout* seconds. 4. **cancel_at_percent** -- i…

Check the current status of a background print watcher. Returns progress, collected snapshots, and whether the watcher has finished. By default returns immediately with the current state. Set ``block_until_event=True`` to wait server-side until a new event fires on the bus matching this watcher's printer (or ``timeout`` seconds elapse). Loop a single blocking call instead of polling every N seconds — roughly 50× fewer tool invocations on a multi-hour print. Args: watch_id: The watcher ID returned by ``watch_print``. block_until_event: If True, block until a matching event …

Clean the nozzle tip on the printer's own wipe pad. Heats to the loaded material's window (or the temperature given), parks over the purge chute while heating, snaps the tail with the vendor's own retract, then runs the wipe-pad pass the machine's start sequence runs and reports where the head ended up. Only where the declared model's pad pass is served one plan at a time through Kiln's hosted service for a printer paired to your Kiln sign-in, free, and kept on your machine so it works offline (``printer_model`` in config.yaml names the model). Any other model is refused with the reason rat…