sumeetm10.github.io

{
  "name": "get_wired_future_state",
  "kind": "answer",
  "impl": "imperative",
  "description": "Read the complete live state of the Wired Future 3D canvas: grid and accent colours, which hero model is floating, wave velocity and amplitude, fog density, the camera rig and the drifting node cluster. Returns a short natural-language description of what is currently on screen alongside the exact numbers and the legal range for every parameter. Call this first whenever you need to make a relative change (\"make it faster\", \"darker\", \"twice as many nodes\") so you are adjusting from the real value instead of guessing.",
  "inputSchema": {
    "type": "object",
    "properties": {},
    "additionalProperties": false,
    "description": "Takes no arguments."
  },
  "page": "/wired-future/"
}

{
  "name": "modify_wired_future_environment",
  "kind": "act",
  "impl": "imperative",
  "description": "Restyle the Wired Future world: recolour the hologram (stage rings, floor grid and the glow of the car), swap the hero model between the cyber-car and the engine block, and retune how fast the stage rings turn, how bright they glow and how thick the fog sits. This is the main creative control - reach for it whenever someone asks the scene to look different. Every property is optional and you must supply at least one; anything you leave out keeps its current value. Numeric values outside their documented range are clamped rather than rejected. The same change appears instantly in the human control panel, so the person watching sees exactly what you did.",
  "inputSchema": {
    "type": "object",
    "additionalProperties": false,
    "description": "Supply at least one property. Omitted properties are left untouched, so partial updates are the normal case.",
    "properties": {
      "gridColorHex": {
        "type": "string",
        "description": "Hex colour for the hologram: stage rings, floor grid, the glow and edge lines of the car, and the primary light. Accepts #rgb or #rrggbb, for example \"#00f0ff\" or \"#0ff\". This is the dominant colour of the whole scene, so change it first when asked for a different mood. CSS colour names such as \"cyan\" are rejected - convert to hex yourself."
      },
      "accentColorHex": {
        "type": "string",
        "description": "Hex colour for the secondary highlight: model trim and the horizon glow. Same #rgb / #rrggbb format. Works best as a contrasting hue to gridColorHex, for example magenta \"#ff2bd6\" against cyan."
      },
      "modelType": {
        "type": "string",
        "enum": [
          "car",
          "engine"
        ],
        "description": "Which hero model hovers above the landscape. \"car\" is a low-poly cyber-car silhouette; \"engine\" is a segmented engine-block module. Nothing else is valid."
      },
      "waveVelocity": {
        "type": "number",
        "minimum": 0,
        "maximum": 5,
        "description": "How fast the hologram platform rings under the car turn, 0 to 5. 0 holds them still, 1 is the calm default, 5 spins them fast. (Named for the wave landscape this stage replaced.) Out-of-range values are clamped."
      },
      "waveAmplitude": {
        "type": "number",
        "minimum": 0,
        "maximum": 4,
        "description": "Brightness of the hologram platform and floor grid, 0 to 4. 0 is nearly dark, 1 is the default, 4 is a blazing stage. (Named for the wave landscape this stage replaced.) Clamped."
      },
      "fogDensity": {
        "type": "number",
        "minimum": 0,
        "maximum": 0.12,
        "description": "Exponential fog density, 0 to 0.12. 0 is crystal clear to the horizon, 0.035 is the default haze, 0.12 buries everything a few units out for a claustrophobic look. Clamped."
      }
    }
  },
  "page": "/wired-future/"
}

{
  "name": "pulse_reality_wave",
  "kind": "act",
  "impl": "imperative",
  "description": "Fire a one-off shockwave through the world: the terrain waves spike, the neon light flares, and everything eases back to where it was. Nothing is permanently changed, so this is the safe way to punctuate a moment, react to something the person said, or show off that the bridge is live. Use a low intensity for a heartbeat and a high one for an explosion.",
  "inputSchema": {
    "type": "object",
    "additionalProperties": false,
    "properties": {
      "intensity": {
        "type": "number",
        "minimum": 0.2,
        "maximum": 5,
        "default": 2.4,
        "description": "How hard the shockwave hits, 0.2 to 5. 0.5 is a subtle heartbeat, 2.4 is the default punch, 5 is a full detonation. Clamped."
      },
      "durationMs": {
        "type": "number",
        "minimum": 200,
        "maximum": 8000,
        "default": 1600,
        "description": "How long the wave takes to rise and settle, in milliseconds, 200 to 8000. 400 is a snap, 1600 is the default swell, 8000 is a long slow breath. Clamped."
      }
    }
  },
  "page": "/wired-future/"
}

{
  "name": "set_camera_view",
  "kind": "act",
  "impl": "imperative",
  "description": "Move the virtual camera around the Wired Future scene. Pick a framing preset, push in or pull back, raise or drop the eye line, and turn the slow automatic orbit on or off. Use this when someone wants a closer look at the model, a map-like view of the terrain, or a still frame to inspect. Every property is optional; only what you supply is changed. Pair it with capture_scene_snapshot when you want to actually see the result.",
  "inputSchema": {
    "type": "object",
    "additionalProperties": false,
    "description": "Supply at least one property. Omitted properties keep their current value.",
    "properties": {
      "preset": {
        "type": "string",
        "enum": [
          "orbit",
          "top",
          "close",
          "wide"
        ],
        "description": "Framing preset. \"orbit\" is the default three-quarter hero angle; \"top\" looks almost straight down and reads the terrain like a map; \"close\" sits low and tight on the hero model; \"wide\" pulls far back so the whole landscape and node cluster fit in frame."
      },
      "distance": {
        "type": "number",
        "minimum": 6,
        "maximum": 48,
        "description": "How far the camera sits from the scene centre, 6 to 48. 6 is nose-to-the-glass, 16 is the default, 48 is a distant establishing shot. Clamped."
      },
      "height": {
        "type": "number",
        "minimum": -6,
        "maximum": 30,
        "description": "Camera eye height, -6 to 30. Negative values look up at the terrain from below, 6 is the default eye line, 30 is a near top-down bird view. Clamped."
      },
      "autoOrbit": {
        "type": "boolean",
        "description": "When true the camera drifts slowly around the scene; when false it locks in place. Turn it off before capturing a snapshot you want to compare against another one."
      }
    }
  },
  "page": "/wired-future/"
}

{
  "name": "configure_node_cluster",
  "kind": "act",
  "impl": "imperative",
  "description": "Reshape the swarm of glowing nodes that drifts above the terrain. Change how many there are, how far they scatter, how fast they bob, and what colour they glow. This is the cheapest way to change the density and mood of the sky: a handful of slow far-flung nodes reads as lonely and vast, a hundred fast tight ones reads as a busy data storm. Every property is optional.",
  "inputSchema": {
    "type": "object",
    "additionalProperties": false,
    "description": "Supply at least one property. Omitted properties keep their current value.",
    "properties": {
      "count": {
        "type": "number",
        "minimum": 0,
        "maximum": 160,
        "description": "How many nodes exist, 0 to 160, rounded to a whole number. 0 empties the sky entirely, 40 is the default, 160 is a dense swarm. Clamped."
      },
      "spread": {
        "type": "number",
        "minimum": 6,
        "maximum": 60,
        "description": "Radius the nodes scatter across, 6 to 60. 6 packs them into a tight knot above the model, 26 is the default, 60 flings them out to the horizon. Clamped."
      },
      "floatSpeed": {
        "type": "number",
        "minimum": 0,
        "maximum": 5,
        "description": "How fast the nodes bob and drift, 0 to 5. 0 freezes them mid-air, 1 is the default gentle float, 5 is agitated. Clamped."
      },
      "colorHex": {
        "type": "string",
        "description": "Hex colour the nodes glow, #rgb or #rrggbb, for example \"#8b5cff\". CSS colour names are rejected - convert to hex first."
      }
    }
  },
  "page": "/wired-future/"
}

{
  "name": "apply_scene_preset",
  "kind": "act",
  "impl": "imperative",
  "description": "Flip the entire world to a hand-tuned look in one call - colours, wave motion, fog, camera rig and node cluster all at once. Prefer this over a pile of individual edits when someone describes a mood rather than a number (\"make it warmer\", \"something cold and empty\", \"go full sci-fi hologram\"). It overwrites every parameter the preset covers, so use modify_wired_future_environment afterwards if you want to tweak one detail.",
  "inputSchema": {
    "type": "object",
    "additionalProperties": false,
    "required": [
      "preset"
    ],
    "properties": {
      "preset": {
        "type": "string",
        "enum": [
          "neon-noir",
          "solar-flare",
          "deep-void",
          "hologram"
        ],
        "description": "Which look to apply. \"neon-noir\" is the signature cyan-on-black cyberpunk default with a magenta horizon and a calm orbiting camera. \"solar-flare\" is hot orange and yellow, fast high waves, a wide shot and a dense swarm of red nodes - loud and energetic. \"deep-void\" is cold deep blue with mint accents, almost still water, heavy fog, only eighteen far-flung nodes and a locked close camera - lonely and quiet. \"hologram\" is pale ice-white and near-transparent, almost no fog, a top-down view and ninety-six fast nodes - clinical and futuristic."
      }
    }
  },
  "page": "/wired-future/"
}

{
  "name": "capture_scene_snapshot",
  "kind": "act",
  "impl": "imperative",
  "description": "Render the live 3D canvas to an image and return it, so you can actually look at the scene instead of inferring it from numbers. Use it to verify a change landed the way you intended, to compare a before and after, or when the person asks what the scene looks like right now. Changes nothing. If the canvas has not finished mounting yet this returns an error rather than a blank frame - wait a moment and try again.",
  "inputSchema": {
    "type": "object",
    "additionalProperties": false,
    "properties": {
      "maxWidth": {
        "type": "number",
        "minimum": 240,
        "maximum": 1280,
        "default": 640,
        "description": "Longest edge of the returned image in pixels, 240 to 1280. 640 is the default and is plenty to judge colour and composition; go higher only when you need to read fine wireframe detail. Clamped."
      }
    }
  },
  "page": "/wired-future/"
}

{
  "name": "reset_wired_future",
  "kind": "act",
  "impl": "imperative",
  "description": "Restore every scene parameter - grid and accent colour, model, wave velocity and amplitude, fog, camera framing and the whole node cluster - to the Wired Future defaults. Use this when the person asks to start over, undo everything, or put it back the way it was. This is the exact same Reset control the human has in the Control Deck; no preset reproduces it, because presets do not restore the default model type.",
  "inputSchema": {
    "type": "object",
    "additionalProperties": false,
    "properties": {}
  },
  "page": "/wired-future/"
}

{
  "name": "place_object",
  "kind": "act",
  "impl": "imperative",
  "description": "Move, turn or resize the centre-stage object. World units: the stage is about 120 units across, the object is roughly 5 units long, and the camera orbits at 16 units. Y is up and 0 is ground level. Rotation is in DEGREES; yaw (rotationDeg.y) is the one you usually want. This is the same placement a person produces by dragging the on-screen gizmo, so call get_wired_future_state first when making a relative move like \"push it back a bit\".",
  "inputSchema": {
    "type": "object",
    "additionalProperties": false,
    "description": "Supply at least one of position, rotationDeg or scale.",
    "properties": {
      "position": {
        "type": "object",
        "additionalProperties": false,
        "description": "Absolute world position. Omit an axis to leave it where it is.",
        "properties": {
          "x": {
            "type": "number",
            "description": "Left/right, -24 to 24."
          },
          "y": {
            "type": "number",
            "description": "Up/down, -3 to 18. 0 rests on the ground."
          },
          "z": {
            "type": "number",
            "description": "Near/far, -24 to 24."
          }
        }
      },
      "rotationDeg": {
        "type": "object",
        "additionalProperties": false,
        "description": "Euler angles in degrees. Values wrap, so 370 becomes 10.",
        "properties": {
          "x": {
            "type": "number",
            "description": "Pitch in degrees."
          },
          "y": {
            "type": "number",
            "description": "Yaw in degrees. The usual one."
          },
          "z": {
            "type": "number",
            "description": "Roll in degrees."
          }
        }
      },
      "scale": {
        "type": "number",
        "description": "Uniform scale, 0.15 to 5. 1 is the natural size."
      }
    }
  },
  "page": "/wired-future/"
}

{
  "name": "set_edit_mode",
  "kind": "act",
  "impl": "imperative",
  "description": "Change what the PERSON's mouse does on the canvas. 'orbit' lets them fly the camera around the scene; 'translate', 'rotate' and 'scale' arm a drag gizmo on the object so they can place it by hand. This changes their controls rather than the scene, so say why you switched - for example, arm 'rotate' when you have asked them to aim the car themselves.",
  "inputSchema": {
    "type": "object",
    "additionalProperties": false,
    "required": [
      "mode"
    ],
    "properties": {
      "mode": {
        "type": "string",
        "enum": [
          "orbit",
          "translate",
          "rotate",
          "scale"
        ],
        "description": "orbit = camera control. translate = move gizmo. rotate = turn gizmo. scale = resize gizmo."
      }
    }
  },
  "page": "/wired-future/"
}

{
  "name": "set_car_body",
  "kind": "act",
  "impl": "imperative",
  "description": "Choose which car is on stage. 'real' loads a genuine glTF concept car with PBR paint, glass and rims; it streams an 11 MB asset, so the parametric car shows for a second or two first. 'parametric' is the built-in geometric car, which loads instantly and sits closer to the wireframe aesthetic. Also switches the hero model to the car.",
  "inputSchema": {
    "type": "object",
    "additionalProperties": false,
    "required": [
      "variant"
    ],
    "properties": {
      "variant": {
        "type": "string",
        "enum": [
          "real",
          "parametric"
        ],
        "description": "real = loaded glTF concept car. parametric = built-in editable mesh."
      }
    }
  },
  "page": "/wired-future/"
}

{
  "name": "reconstruct_photo_object",
  "kind": "act",
  "impl": "imperative",
  "description": "Inspect or control the photo-to-3D reconstruction. A person can drop a photo of an OBJECT onto this page and a depth model running inside their browser rebuilds it as 3D relief geometry on the stage. You cannot upload an image yourself - if none exists, ASK the person to drop one onto the Photo to 3D panel. Use action 'status' to see whether a reconstruction is ready and what it is of, 'show' to put it on stage, and 'clear' to discard it and return to the car. People and animals are declined by design; only inanimate objects are reconstructed.",
  "inputSchema": {
    "type": "object",
    "additionalProperties": false,
    "required": [
      "action"
    ],
    "properties": {
      "action": {
        "type": "string",
        "enum": [
          "status",
          "show",
          "clear"
        ],
        "description": "status = report what has been reconstructed (read-only). show = display it on stage. clear = discard it and go back to the car."
      }
    }
  },
  "page": "/wired-future/"
}

{
  "name": "configure_car_rig",
  "kind": "act",
  "impl": "imperative",
  "description": "Open, strip and take apart the concept car. It is a real glTF asset built from 97 separate named parts, so this genuinely articulates it rather than faking an animation. finish 'print' swaps all paint, glass and trim for one matte resin grey - the 3D-print view, which is how you actually read the shape. explode fans every assembly out along its own axis into a parts diagram (0 assembled, 1 fully apart). doorLeft, doorRight and hood each swing on their real hinge from 0 shut to 1 wide open. Only affects the 'real' car body - call set_car_body with variant 'real' first if the parametric car is showing.",
  "inputSchema": {
    "type": "object",
    "additionalProperties": false,
    "description": "Supply at least one field. Omitted fields are left alone.",
    "properties": {
      "finish": {
        "type": "string",
        "enum": [
          "hologram",
          "paint",
          "print"
        ],
        "description": "hologram = glowing projected light with every edge traced, the default look. paint = the asset's own PBR bodywork. print = matte resin grey with the glass made solid, like an unpainted 3D print."
      },
      "explode": {
        "type": "number",
        "description": "How far apart the assemblies fly, 0 (assembled) to 1 (full parts diagram). 0.35 reads as a cutaway; 1 is a full teardown."
      },
      "doorLeft": {
        "type": "number",
        "description": "Left door angle, 0 shut to 1 fully open."
      },
      "doorRight": {
        "type": "number",
        "description": "Right door angle, 0 shut to 1 fully open."
      },
      "hood": {
        "type": "number",
        "description": "Hood angle, 0 shut to 1 fully raised."
      }
    }
  },
  "page": "/wired-future/"
}

{
  "name": "set_car_parts",
  "kind": "act",
  "impl": "imperative",
  "description": "Detach or refit individual assemblies of the concept car - take the wheels off, drop the body shell to expose the interior and engine, remove the glass. Assemblies: body (Body Shell), doorLeft (Left Door), doorRight (Right Door), hood (Hood), roof (Roof Panel), glass (Glass), interior (Interior), engine (Engine + Axles), lights (Lights), wheelFL (Wheel Front L), wheelFR (Wheel Front R), wheelRL (Wheel Rear L), wheelRR (Wheel Rear R). action 'remove' hides the listed parts, 'refit' puts them back, 'only' shows ONLY the listed parts, and 'reset' refits everything. Nothing is destroyed - a removed part is always one call away from returning.",
  "inputSchema": {
    "type": "object",
    "additionalProperties": false,
    "required": [
      "action"
    ],
    "properties": {
      "action": {
        "type": "string",
        "enum": [
          "remove",
          "refit",
          "only",
          "reset"
        ],
        "description": "remove = detach the listed parts. refit = put them back. only = show just these. reset = refit everything (ignores parts)."
      },
      "parts": {
        "type": "array",
        "items": {
          "type": "string",
          "enum": [
            "body",
            "doorLeft",
            "doorRight",
            "hood",
            "roof",
            "glass",
            "interior",
            "engine",
            "lights",
            "wheelFL",
            "wheelFR",
            "wheelRL",
            "wheelRR"
          ]
        },
        "description": "Assembly ids. Required for remove / refit / only; ignored for reset. Example: [\"wheelFL\",\"wheelFR\",\"wheelRL\",\"wheelRR\"] takes all four wheels off."
      }
    }
  },
  "page": "/wired-future/"
}

{
  "name": "inspect_car_part",
  "kind": "act",
  "impl": "imperative",
  "description": "Measure one assembly of the concept car from its actual triangles: triangle and vertex counts, surface area, bounding-box dimensions, centroid, whether the mesh is watertight, and the estimated mass in every available engineering material. Real geometry, computed in the browser - not a lookup table. Call this before proposing an upgrade so your suggestion is grounded in the part true size and mass rather than a guess. Lengths come back in metres (the car is normalised to 5.2 model units for a real length of about 4.6 m). MASS IS A SHELL ESTIMATE: automotive parts are pressed panels and castings, not solid billets, so mass is surface area x wall thickness x density, defaulting to a 2 mm wall. Pass wallThicknessMm to model a thicker casting or a thinner skin. The enclosed volume is also returned, but for an open shell it is geometrically meaningless and is flagged as such.",
  "inputSchema": {
    "type": "object",
    "additionalProperties": false,
    "required": [
      "part"
    ],
    "properties": {
      "part": {
        "type": "string",
        "enum": [
          "body",
          "doorLeft",
          "doorRight",
          "hood",
          "roof",
          "glass",
          "interior",
          "engine",
          "lights",
          "wheelFL",
          "wheelFR",
          "wheelRL",
          "wheelRR"
        ],
        "description": "Which assembly to measure."
      },
      "wallThicknessMm": {
        "type": "number",
        "description": "Wall thickness used for the mass estimate, in millimetres. Default 2. Typical: 0.8-1.2 for a steel body panel, 3-6 for a cast alloy wheel, 2-4 for a structural carbon panel."
      }
    }
  },
  "page": "/wired-future/"
}

{
  "name": "modify_car_part",
  "kind": "act",
  "impl": "imperative",
  "description": "Reshape one assembly of the car by rewriting its vertices. scaleX/Y/Z stretch it about its own centre, so scaling a wheel widens the tyre without moving it off the axle. inflate offsets every vertex along its surface normal, which thickens a panel or puffs a shell outward. twistDeg rotates the part progressively about the vertical axis, distributed over its height. material re-specifies it in a real engineering material, changing both its look and its calculated mass. Edits are ABSOLUTE and rebuilt from the pristine geometry each time, so sending scaleX 1.2 twice leaves it at 1.2, and reset returns it exactly to the shipped part. Measure first with inspect_car_part so you know what you are changing.",
  "inputSchema": {
    "type": "object",
    "additionalProperties": false,
    "required": [
      "part"
    ],
    "description": "Supply part plus at least one change, or part plus reset:true to restore it.",
    "properties": {
      "part": {
        "type": "string",
        "enum": [
          "body",
          "doorLeft",
          "doorRight",
          "hood",
          "roof",
          "glass",
          "interior",
          "engine",
          "lights",
          "wheelFL",
          "wheelFR",
          "wheelRL",
          "wheelRR"
        ],
        "description": "Which assembly to reshape."
      },
      "reset": {
        "type": "boolean",
        "description": "Restore this part to the shipped geometry and material, discarding every edit."
      },
      "scaleX": {
        "type": "number",
        "description": "Scale across the car, 0.2 to 3. 1 is untouched."
      },
      "scaleY": {
        "type": "number",
        "description": "Vertical scale, 0.2 to 3."
      },
      "scaleZ": {
        "type": "number",
        "description": "Scale along the car, 0.2 to 3."
      },
      "inflate": {
        "type": "number",
        "description": "Offset along surface normals in model units, -0.12 to 0.12. One model unit is about 0.88 m, so 0.02 is roughly 18 mm of added thickness."
      },
      "twistDeg": {
        "type": "number",
        "description": "Twist about the vertical axis over the part height, -180 to 180 degrees."
      },
      "material": {
        "type": "string",
        "enum": [
          "steel",
          "aluminium",
          "titanium",
          "carbon",
          "abs",
          "glass",
          "rubber"
        ],
        "description": "Re-specify the part: steel (7850 kg/m3), aluminium (2700 kg/m3), titanium (4430 kg/m3), carbon (1600 kg/m3), abs (1040 kg/m3), glass (2500 kg/m3), rubber (1100 kg/m3)."
      }
    }
  },
  "page": "/wired-future/"
}

{
  "name": "list_car_parts",
  "kind": "answer",
  "impl": "imperative",
  "description": "Enumerate every individually addressable mesh of the concept car - over a hundred of them, down to individual door handles, wing mirrors, wipers, brake discs, steering wheel spokes and pedals. Returns each part id, its human label and which assembly it belongs to. Call this before place_car_part or detach_car_parts, because those address parts by id and the ids are asset-specific. Optionally filter by assembly or by a substring of the label.",
  "inputSchema": {
    "type": "object",
    "additionalProperties": false,
    "properties": {
      "assembly": {
        "type": "string",
        "enum": [
          "body",
          "doorLeft",
          "doorRight",
          "hood",
          "roof",
          "glass",
          "interior",
          "engine",
          "lights",
          "wheelFL",
          "wheelFR",
          "wheelRL",
          "wheelRR"
        ],
        "description": "Only parts belonging to this assembly."
      },
      "search": {
        "type": "string",
        "description": "Case-insensitive substring of the label, e.g. \"handle\", \"wiper\", \"disc\"."
      }
    }
  },
  "page": "/wired-future/"
}

{
  "name": "select_car_part",
  "kind": "act",
  "impl": "imperative",
  "description": "Point the on-screen transform gizmo at a part, so the PERSON can drag it by hand. Selecting an assembly (a whole door) or a single mesh (that door's handle) changes what their mouse grabs. This is a handoff: use it when you want them to position something themselves, and say so. Pass nothing to clear the selection.",
  "inputSchema": {
    "type": "object",
    "additionalProperties": false,
    "properties": {
      "assembly": {
        "type": "string",
        "enum": [
          "body",
          "doorLeft",
          "doorRight",
          "hood",
          "roof",
          "glass",
          "interior",
          "engine",
          "lights",
          "wheelFL",
          "wheelFR",
          "wheelRL",
          "wheelRR"
        ],
        "description": "Select a whole assembly. Ignored when part is given."
      },
      "part": {
        "type": "string",
        "description": "A part id from list_car_parts, for single-mesh selection. Wins over assembly."
      }
    }
  },
  "page": "/wired-future/"
}

{
  "name": "place_car_part",
  "kind": "act",
  "impl": "imperative",
  "description": "Move, turn or resize ONE individual mesh - lift a wing mirror off, rotate a wheel rim, shrink a door handle. Offsets are relative to the part’s rest position in model units (one unit is about 0.88 m), so the part keeps riding its assembly when a door swings or the car explodes. Absolute, not cumulative: sending the same offset twice leaves it in one place. Pass reset:true to put it back. Get part ids from list_car_parts.",
  "inputSchema": {
    "type": "object",
    "additionalProperties": false,
    "required": [
      "part"
    ],
    "properties": {
      "part": {
        "type": "string",
        "description": "Part id from list_car_parts."
      },
      "reset": {
        "type": "boolean",
        "description": "Return this part to its rest position and scale."
      },
      "x": {
        "type": "number",
        "description": "Offset across the car, -12 to 12."
      },
      "y": {
        "type": "number",
        "description": "Offset up/down, same range."
      },
      "z": {
        "type": "number",
        "description": "Offset along the car, same range."
      },
      "rotY": {
        "type": "number",
        "description": "Yaw in degrees. Values wrap."
      },
      "scale": {
        "type": "number",
        "description": "Scale, 0.1 to 6. 1 is untouched."
      }
    }
  },
  "page": "/wired-future/"
}

{
  "name": "detach_car_parts",
  "kind": "act",
  "impl": "imperative",
  "description": "Remove or refit individual meshes by id - take off just the wing mirrors, or hide every window while leaving the frames. Distinct from set_car_parts, which works on whole assemblies. Nothing is destroyed; a detached part is one call from returning.",
  "inputSchema": {
    "type": "object",
    "additionalProperties": false,
    "required": [
      "action"
    ],
    "properties": {
      "action": {
        "type": "string",
        "enum": [
          "remove",
          "refit",
          "reset"
        ],
        "description": "remove = hide the listed parts. refit = show them. reset = refit everything (ignores parts)."
      },
      "parts": {
        "type": "array",
        "items": {
          "type": "string"
        },
        "description": "Part ids from list_car_parts. Required for remove and refit."
      }
    }
  },
  "page": "/wired-future/"
}