Lists all available physics logic archetypes in the Grasshopper library. Use this tool first to discover what logic IDs are available before calling get_logic_by_id.

Returns: JSON list of logic IDs available (e.g., ["catenary", "bending", "01_simplebeam"]).

Retrieves parsed physics context for a specific Kangaroo2 or Karamba3D archetype. Returns detected components, descriptions, and metadata extracted from the Grasshopper binary file.

Args: logic_id: The filename (without extension) of the Grasshopper file. Use list_library() first to see available IDs. Examples: catenary, bending, 01_simplebeam Returns: JSON string with detected physics components and context, or error.

Lists furniture in the controlled IKEA Singapore model library.

Args: category: Optional exact category filter such as "chair", "sofa", or "storage". Returns: Compact paginated asset cards. Use get_ikea_furniture only for a selected asset that needs full metadata.

Searches IKEA furniture by product language and room-fit dimensions.

Use this before placing furniture. Prefer exact-dimension matches for final layouts; series-only matches are useful for concept design but are labelled as such.

Returns one IKEA furniture asset's dimensions, provenance, and availability.

Lists representation-only entourage and graphic proxy assets.

Drawing assets are intentionally isolated from IKEA product search and do not participate in room collision checks unless explicitly registered.

Searches only the controlled architectural drawing-asset library.

Returns one drawing asset's provenance, scale guidance, and availability.

Lists compact audited layer, lineweight, projection, and export recipes.

Returns one complete audited drawing recipe.

Returns compact diagnostics for the local structured retrieval system.

Creates a persistent scene handle for a house or interior generation. Scene metadata remains local and is retrieved by ID instead of being repeated in the model context.

Returns a token-efficient scene summary by stable handle.

Creates or updates a room in the local scene ledger. bounds_mm is [min_x, min_y, min_z, max_x, max_y, max_z].

Registers or moves an asset instance in millimetres without retransmitting its full metadata. Returns a stable instance handle and scene revision.

Runs local R-tree broad-phase collision and room-containment checks. Only compact violations are returned; geometry remains in Rhino.

Creates a dependency-ordered local plan. scope may be house, interior, structure, or drawing. The plan stores handles and step state rather than verbose repeated context.

Returns a compact dependency graph and current step states.

Advances a generation step after its dependencies complete. Input and output references should be stable scene, room, asset, instance, or Rhino GUID handles.

Imports an indexed IKEA SketchUp model into Rhino 8 as a reusable block and places an instance.

The asset is imported only when its block definition does not already exist. Subsequent calls create lightweight instances. Position uses the active Rhino document units; rotation is around world Z. The tool never accepts an arbitrary file path.

Places an indexed representation asset as a reusable Rhino block.

Drawing assets are placed on ALMOND-DRAW::ASSETS and remain distinct from IKEA product blocks. The tool accepts only files resolved from the controlled DrawingAssetfiles manifest.

Creates or updates the Rhino layer hierarchy, plot weights, colours, and linetypes defined by an audited drawing recipe.

Imports the AutoCAD-style .pat hatch definitions of an indexed drawing asset into the active Rhino document's hatch pattern table.

The tool accepts only .pat files resolved from the controlled DrawingAssetfiles manifest, mirroring the placement tools' security boundary.

Lists available vector and CAD diagram assets (people, trees, symbols).

Searches the diagram asset library.

Returns one diagram asset's metadata.

Places an indexed diagram asset (SVG, DWG, DXF).

Sends a C# RhinoCommon script to the Rhino 3D Bridge for compilation and execution. The script is compiled by Roslyn inside Rhino and executed natively as JIT-compiled C#.

The script MUST define a class with a static Run method that returns created GUIDs:

public class Script
{
    public static List<Guid> Run(RhinoDoc doc)
    {
        var guids = new List<Guid>();
        // Use doc.Objects.AddSphere(), doc.Objects.AddBrep(), etc.
        // Append each GUID: guids.Add(guid);
        return guids;
    }
}

Available namespaces (auto-imported if not present): System, System.Collections.Generic, System.Linq, Rhino, Rhino.Geometry, Rhino.DocObjects

Args: script: C# source code containing a class with public static List Run(RhinoDoc doc). Returns: JSON with status (success/compile_error/runtime_error), created GUIDs, or error trace.

Validates AI-generated geometry against Karamba3D structural analysis. Call this AFTER execute_rhino_script to verify the generated structure is buildable.

The bridge tries three analysis pathways in strict order of confidence and always tells you which one actually ran: analysis_method "api" — direct Karamba 3.1 API solve, confidence "high" analysis_method "template" — audited capsule GHX template, confidence "medium" analysis_method "rule_based" — heuristic span/slenderness rules, confidence "low" The verdict string names the method (e.g. "[RULE-BASED ESTIMATE, LOW CONFIDENCE] ..."). Treat rule_based/low results as estimates, NOT finite element analysis, and say so when reporting to the user.

If the structure FAILS, modify the design (add supports, increase member size, change material) and call execute_rhino_script + validate_structure again. When worst_member_guids is present, edit only those offending members instead of regenerating everything. Iterate up to 3 times before reporting the best attempt.

Args: guids: List of Rhino object GUID strings from execute_rhino_script output. structure_type: Analysis template to use. Options: "beam" — simple beam bending/deflection "truss" — axial force/buckling analysis "shell" — shell stress/displacement "frame" — moment/shear frame analysis "canopy" — cantilevered canopy "gridshell" — large deformation gridshell "membrane" — form-finding membrane "highrise" — high-rise structural systems load_kn: Applied load in kN (default 10.0). material: Material type: "Steel", "S355", "Concrete", "Wood", "Aluminium" (default "Steel"). Returns: JSON passed through untouched from the bridge. Top-level fields: status ("pass"|"fail"|"error"), passed (bool), verdict (text), suggestions, confidence ("high"|"medium"|"low"), warnings, and worst_member_guids (up to 5 Rhino GUIDs of the most over-utilized members — edit those first). The results object carries the numbers: max_deflection_mm, deflection_limit_mm, utilization_ratio, max_stress_mpa, yield_stress_mpa, span_m, analysis_method ("api"|"template"|"rule_based"), reactions_kn (total vertical reaction, api path only), and per_element_utilization — a list of {source_guids, utilization} entries (utilization 1.0 = at capacity) keyed back to the Rhino objects that produced each element.

Lists Grasshopper capsules: GH definitions with a typed, audited input/output contract that can be executed via run_gh_definition.

Call this FIRST to discover what capsules exist before calling run_gh_definition. Each entry is a compact card with capsule_id, capability, structure_type, audited flag, and the reserved ALMOND_IN_* / ALMOND_OUT_* port names. Only capsules with audited=true can actually run; audited=false capsules are retrieval context only (read them via get_logic_by_id instead).

Args: capability: Optional filter: "analyze", "generate", "form_find", or "aggregate". audited_only: When true, list only capsules that run_gh_definition will accept. Returns: JSON with total and a list of compact capsule cards.

Runs an audited Grasshopper capsule (GH definition + typed contract) through the Rhino bridge and returns its declared outputs.

Workflow: call list_capsules() first to pick a capsule_id and see its input/ output port names. Create any geometry with execute_rhino_script, then pass the returned GUIDs here. Inputs are validated client-side against the capsule manifest before anything is sent to Rhino, so errors from this tool name the exact port at fault.

Input value forms (keyed by the exact ALMOND_IN_* port name):

• Geometry ports (point/curve/mesh/brep and their [] list forms): {"guids": ["", ...]} referencing objects already in the Rhino document.

• number / integer / string / bool ports: the raw JSON value.

• number[] / integer[] / string[] ports: a flat JSON list. Units are declared per port in the manifest — supply values in those units; nothing is guessed or auto-converted client-side. Optional inputs may be omitted; the capsule's declared defaults then apply inside the definition.

Only audited capsules run. audited=false means the GHX has no verified ALMOND_IN_*/ALMOND_OUT_* harness params yet; this tool refuses it (see capsules/AUTHORING.md for how to harness one).

The response's "outputs" object is keyed by ALMOND_OUT_* names; interpret each value using the manifest's semantics field (e.g. max_nodal_displacement, per_element_utilization) and declared units. The response also carries analysis_method (api|template|rule_based), confidence (high|medium|low), warnings, and baked_guids — report method and confidence honestly; rule_based/low means an estimate, not FEA.

Args: capsule_id: Stable capsule identifier from list_capsules (e.g. "karamba_beam_v1"). inputs: Object mapping ALMOND_IN_* port names to values (forms above). seed: Optional integer seed for stochastic definitions; omit for deterministic ones. timeout_s: Solver budget in seconds (default 60, max 600). Returns: JSON with status, capsule_id, outputs, baked_guids, analysis_method, confidence, warnings, and error — or a validation error naming the offending input and the valid port names.

Exports specific Rhino objects as one GLB and publishes them to Chestnut.

Use this after execute_rhino_script (and optionally validate_structure), passing the returned object GUIDs. Reusing asset_id updates the existing Chestnut asset without changing placements that already reference it.

Args: guids: Rhino object GUIDs to export. Unrelated document objects are excluded. asset_name: Human-readable name shown in Chestnut. asset_id: Stable optional ID for linked updates. Generated deterministically from the Rhino document and GUIDs when omitted. body_type: "static" for architecture, "dynamic" for loose props, or "kinematic" for script-driven objects. collider: Collider intent: "box", "convex", "compound", or "trimesh". Chestnut currently falls back to a box where needed. preserve_scale: Keep Rhino's real-world dimensions instead of normalizing the model to a one-metre display prop. mass: Physics mass in kilograms. Static bodies always use zero. Returns: JSON containing the stable Chestnut asset ID, URL, metadata, and whether the operation created or updated the asset.

Publishes Rhino objects to Chestnut using safe semantic defaults.

This is the preferred publishing tool for normal use. It hides collider, scale, mass, and rigid-body details. Call it when the user says things such as "publish that to Chestnut".

Args: guids: Rhino object GUIDs returned by execute_rhino_script. asset_name: Human-readable asset name. behavior: Optional semantic preset: "auto" — infer architecture versus movable object from name "architecture" — fixed building, terrain, structure, or enclosure "object" — movable physical prop affected by gravity "animated" — script-driven door, lift, platform, or mechanism asset_id: Optional stable link ID. Omit for a deterministic Rhino link.