Koskamo

GripForge MCP

GripForge MCP allows AI agents to generate production-ready game assets including rigged animated characters, weapons, textures, terrain, VFX, and HUDs. It exports assets as GLB for Unity, Unreal Engine, and Godot, and provides playable game kits. The server supports tool usage for attaching weapons to rigs, generating seamless textures, and building modular game projects.

Endpoint and access

No sign-in to connect and list tools. Individual tools may still need a vendor account, credentials, or permissions; check the documented prerequisites.

GripForge MCP logo, by JOE ASSISTANT SASCommunity listingStreamable HTTPNo sign-inEndpoint checked 2026-11-07Published by JOE ASSISTANT SAS
You need:Point any remote-capable MCP client at https://gripforge.ai/mcp with your API key
MCP endpoint (Streamable HTTP)
https://gripforge.ai/mcp
Vendor documentation

What its tools do

241 tools, grouped by the hints the server advertises. Hints are self-declared, not verified behavior.

Read-only (102)

Can change data (139)

241 of 241 have a description · 241 of 241 declare behavior hints · 136 of 237 with parameters document them all

Checks and signals

Each line is separate evidence, not a trust score.

  • Passed Endpoint answered the live check ·
  • Availability 1 of 1 checks passed in 30 days

What you can do with it

  • Attach weapons to rigged characters and export GLB files
  • Generate seamless tileable textures from prompts or images
  • Create playable game kits for Unity, Godot, or Unreal
  • Generate terrain maps and VFX/HUD assets

Source and maintenance

Community listingRegistry 0.1.166
mcp-registry: io.github.gripforgeai/mcp@0.1.166Source repositoryProject website
Maintenance checked

Protocol and capabilities

Server
gripforge 0.1.8
MCP protocol negotiated in check
2025-11-25
Tools
241 advertised
Resources
Not advertised
Resource templates
Not advertised
Prompts
Not advertised
Server-advertised capabilities
{
  "tools": {
    "listChanged": true
  }
}

Server-provided instructions

Untrusted server output shown for inspection. It is not Koskamo guidance and is excluded from knowledge search.

Reuse what exists first: the project's installed Game Kits, then catalogue kits, Community and Library assets, existing models and templates; install, configure or remove kits yourself, and create or generate (credits) only what is missing. Doing otherwise (recoding what a kit covers, not using or replacing an installed kit, generating what already exists) needs a one-sentence justification in your reply; remove a kit the user installed only when the user asks. Game creation orchestration (shared web/CLI): - Every way of working is welcome and can be mixed: from zero or on the user's existing local project (gripforge game-attach, any engine), all at once or step by step, from a brief, from the user's whole plan or pieces of it, with kits or without some of them, and with the user's AI writing some parts itself. Follow the user's way; the tools below save work, they are not a required path. In every case, analyse the project or the plan and actively recommend the kits that fit, each with what it brings, and offer to plug them in yourself, also into an existing local project (gripforge_gamekit_install, then gripforge game-attach): "these kits would help: shall I plug them in?". Never impose them, and never block when the user or their AI does otherwise. - The hosted orchestration, when the user wants it: gripforge_game_creation (or gripforge game-create). After establishing the engine, create the saved brief, quote plan (or use_plan), accept the exact quote within the user's authorization, and poll get. The server worker owns its creation phases, production tasks, checkpoints, budget reservations and verification; while one of its tasks runs, do not run a second copy of the same task locally. A Game Kit project made directly (gripforge_game_project, gripforge mcp call) and parts coded by the user's AI are just as valid. - When the user already has their own plan, whole or in pieces (design documents, chosen kits, chosen assets), supply it instead of quoting plan: use_plan with plan_document (gripforge game-create use-plan --plan <file>) is free and uses no AI; missing parts are completed by suggestions, never a refusal. Show its plan_review diagnostics and suggestions, and apply only the suggestions the user picks (apply_plan_suggestions). Never rewrite the user's plan yourself nor send it through the AI plan step. - When continuing a saved creation, get its gc_ id in the same workspace first. Preserve its project, engine, design, world, assets and completed work. Drive select/review, quote/accept and quote_continuation/accept_continuation through this same workflow. For a built web game, quote develop to continue its saved work queue; do not independently implement that queue in the terminal while its worker runs. Do not create a duplicate project to work around a failed task: retry it, continue step by step, or make that part in the project. - Display the server estimate and missing assets before acceptance. Existing explicit spending authorization remains valid within its scope; a CLI inference --budget is not authorization for a creation quote. Forward the exact quote_token. Mutations use the revision just reviewed; on conflict reread and reconsider, never retry a stale selection automatically. Retry the existing job and forward preparation_resume.resume_token when offered; preserve all completed checkpoints. Watching/getting never accepts a quote or restarts work. - Task status ready only means no task is running. Read delivery, audit and verification blockers before claiming completion. Concept/model approval requires actual visual review. Native targets use the same saved planning, selection and assembly; native import and custom-code execution still require their engine adapter and cannot be claimed as executed by the web worker. Existing standalone project maintenance and asset-only work retain their normal tools. An authoring task already dispatched by the server implements only its assigned task and must not call this orchestration recursively. - GripForge never refuses a game for its size, length, genre or shape: a long game is built step by step (the first playable step first). On any creation or plan error or failed job (gripforge_game_creation or gripforge game-create): explain the error to the user and offer the ways on (retry, step by step, or that part made by you in the project), then continue as the user chooses. - GripForge never refuses a game action for a business reason: when something blocks, it goes on without it and returns warnings [{ code, message, skipped, howToFix }] (applied=false when nothing could be done). Read every warning, tell the user what was skipped, and follow howToFix or offer it; never treat a warning as a finished result. Only security refusals (sign-in, rights, paths outside the sandbox, payment quotas, data of others) remain errors. - Creation mode is explicit, never guessed silently: when the user has not said it, ask whether the game is generated at once or built step by step. At once: quote build covers the whole saved queue; show its size and maximum price to the user (the first level is playable early, progress.playable). Step by step: each step is quoted, accepted and validated on its own: quote build for the foundation and the first playable level, then quote develop with a message naming the next step, one step at a time; the total duration or size plays no role. A game asked at once that is too long for one build switches to step by step, and the user is told; it is never refused. For an infantry or military FPS on web, inspect fps.tactical + fps.deathmatch + fps.armory (preset fps_military). The shared player supplies an operator lobby, class editor, 3D attachment workshop, combat HUD, results, local career, remapping, standard gamepad and graphics/accessibility settings. Core owns weapon fire modes, per-class stats, capsule hit regions, light penetration, five grenades, slide/vault and domination. Do not rebuild those systems inside the exported game. Add fps.network when private multiplayer is requested: game-export includes npm run server, with authoritative rooms, client prediction and reconnect. Public matchmaking, ranked account security and native parity are separate work. Inspect actual weapon mechanics/sight metadata and animations; never claim AAA quality from a kit list or passing tests. A generated asset still needs visual review. Update an existing project by installing/configuring these kits and re-exporting, preserving its map, theme and asset bindings. GripForge game creation policy (3d-production-v35): - Build the engine of the game, never the game in code. The code holds only generic systems: plugged kits, rules set by parameters, hooks. All content is data loaded at run time: levels and scenes, characters, weapons, items, balance values, texts, assets and inputs, in data files or through modding (the game.engine contract), changeable without recompiling, on every engine (Bevy, Godot, Unity, Unreal) and on a local project. Adding a weapon, a level or an enemy is adding data, not code. Each asset is described by its passport (asset.meta, the mesh passport: skeleton, clips, colliders, LOD, weapon grips, sizes): the game reads clips, bones, grips and sizes from it and never writes a clip name, a bone or a scale in code; changing an asset is changing its passport, not the code (gripforge assets show <lib_id> shows it and says what it lacks). Recommend kits with this in mind: the ones whose config, registries and documents carry the content as data. - Plan world structure independently of visual style: open world, connected regions, linear level, enclosed arena, interiors or circuit. Choose the existing world kit(s) for that structure, then configure scale, traversal, limits, start points, paths and actual level documents through their real schemas. A seed change or an installed world kit alone is not a designed map. Hosted creation returns its saved world plan (configuration, data and remaining work); reuse it when continuing in the CLI/MCP instead of regenerating geography. Replace demo rooms/runs, circuits or platform courses with the game's own documents and wire their IDs into the kit configuration. Keep unfinished buildings, encounters, gates and mixed-world transitions explicit until implemented and playtested; preserve reviewed geography on unrelated refinements. - GripForge currently supports creating 3D games only. This applies to the playable world, units, buildings and environment. - If the user explicitly requests a 2D game, explain in their language that 2D game creation is not supported yet. In French: "La création de jeux 2D n'est pas encore prise en charge par GripForge." GripForge does not refuse it: the creation goes on as a 3D game and returns the warning 2d_not_supported. Offer the 3D version (a top-down or side camera keeps the 2D feel) and wait for the user's agreement before any quote is accepted; never switch silently. - Before creating a game, establish the engine from the user's explicit choice in this conversation or the existing project's actual files (Unity ProjectSettings, project.godot, an Unreal .uproject, a Rust crate using Bevy, or an existing GripForge Bevy game). An existing project made of three.js files is not a supported engine: say so and offer Bevy (the GripForge player) instead. Read-only project inspection is allowed. A default API target, an empty folder, a genre, a camera angle or a browser/mobile platform is not an engine choice. - If the engine is unspecified, ambiguous or conflicts with the existing project, ask in the user's language: "Quel moteur veux-tu utiliser : Bevy (lecteur GripForge), Godot, Unity ou Unreal Engine ?" Wait for the answer before creating game files, creating a Game Kit project, installing engine dependencies or generating assets. Never silently select the GripForge player. Three.js is not offered and is not supported as a game engine. Remember the answer for this project and subsequent turns; do not ask again unless the user requests an engine change or the context becomes ambiguous. For an asset-only request, do not require a game engine unnecessarily. - Carry the selected engine through planning and tool calls: Unity → target unity, Godot → target godot, Unreal Engine → target unreal, Bevy (lecteur GripForge, Rust/Bevy, WebGPU + WebGL2) → target web (gripforge game-create --engine bevy). Pass target explicitly to game kit search, project creation and delivery. A missing adapter or preset is not permission to switch engines: explain the limitation and obtain agreement before an alternative. - A local engine project already on this machine (project.godot, Unity ProjectSettings, an Unreal .uproject, a Bevy crate or a GripForge Bevy game folder) is worked on in place: GripForge is attached to it, the game is never exported. Run gripforge game-attach <gkp_id or gc_id> <project folder> whatever the engine: Godot gets the addon gripforge_kits and the game under gripforge/ (project.godot, scenes and scripts never written; keep the game's own rules in its GDScript); Unity the package ai.gripforge.kits and the game under Assets/StreamingAssets/gripforge (Packages/manifest.json only gets the dependencies it lacks); Unreal the plugin GripForgeKits and the game under Content/GripForge (the .uproject only gets the plugin entry); a GripForge Bevy game folder is updated in place, and a Bevy crate of the user gets the game under gripforge/ with its sources untouched. Run it again after installing or configuring kits on the Game Kit project (gripforge_gamekit_install / gripforge_gamekit_configure): the folder remembers its game, --check previews. Without the CLI, gripforge_gamekit_deliver_local (target godot / unity / unreal) delivers kits in place too. The whole creation can be done at once or step by step on the same project: each step changes the Game Kit project, then game-attach brings it into the folder. A folder with no engine project yet: ask the user which engine (Bevy, Godot, Unity or Unreal) and run game-attach with --engine. Never run gripforge game-export (any target) or gripforge_game_web_export to obtain a copy of a game whose engine project already exists here; a notice export_not_needed says exactly that: follow its howToFix. If game-attach reports manual_setup_found (kits already wired by hand), follow its howToFix before any --force. The MCP tools are reachable from any shell with the login of the CLI: gripforge mcp tools, gripforge mcp call <tool> '<json>'. - Files the CLI downloads on the user's machine (addon, kit libraries, desktop player, interface engine) stay on the disk of the project: a project on another disk than the user profile gets them in <project>/.gripforge-cache (ignored by git and Godot), GRIPFORGE_CACHE_DIR or gripforge cache dir <folder> moves them, gripforge webui-engine prepare --dir <folder on the project's disk> (or --project <project>) puts the interface engine there. Never propose downloading to the user profile or to another disk; when space is short, offer GRIPFORGE_CACHE_DIR, gripforge cache clean (gripforge cache clean --old removes only the old versions of the addon and of the player; done by itself after an install) or fewer platforms. game-attach without --platforms keeps exactly the platforms the project already has (this machine's only for a first attachment): add a platform only when the user asks for it (--platforms). - When the user's engine project serves a capability itself (its own terrain for world.ground, its own camera…), declare it in the project instead of keeping or removing kits: gripforge game-host <gkp_id> add world.ground (MCP gripforge_game_host_provides), with --remove-kit <kit> to drop the provider kit alone; never remove character or interaction kits because a world kit goes (a removal refused with details.hostable names what the game can serve). The game then serves it at run time (host.provide_service in GDScript, Provide in Unity, ProvideService in Unreal, gfk_provide in C). - For game requests without an explicit dimension, create a real 3D scene in the selected engine. An isometric, top-down, side-view or 2.5D camera can view a 3D world; those camera choices do not authorize a flat 2D game. When Bevy (the GripForge player) is selected, use the GripForge Rust/Bevy web player (WebGPU with WebGL2 fallback) and the reusable GripForge kits; never write a Three.js renderer. Respect an existing 3D engine. - Missing genre kits or matching assets never justify falling back to Canvas 2D, flat sprites, SVG or HTML shapes for the game world. Keep missing capabilities explicit and implement the needed gameplay on the 3D foundation. Search Library/Community, then manufacture missing assets within the authorized generation budget. - Treat "create a game" as delivery of a playable, visually developed game, even when a primitive prototype already exists. Inspect and preserve working mechanics, but do not narrow the request to fixing a few rules/tests or say that no assets are needed without examining the actual visuals. Only an explicit mechanics-only or blockout request permits that narrower scope. - A game is whatever the user wants: it may have no character, no enemy or mob, no level, no win or lose, no fixed length and no known genre (a toy, a sandbox, a walking scene, a puzzle box, an art piece…). Read the user's game first and build that; never add a hero, enemies, combat or levels it did not ask for. When the game belongs to a known genre, its definition of done (the preset's `done`, GET /api/v1/gamekits/completeness, evaluated by gripforge_game_audit) is a list of proposals of what players of that genre take for granted ("a MOBA" usually means distinct heroes, minions, towers, a shop…): offer them, the user picks. Likewise the common frame most games have (a title / pause / end screen, sound, a HUD, touch controls, a loop playable from start to end, a way to win or to lose when the game has an end) is proposed, not imposed. A default kit the game keeps should be filled (audio.core with its sounds, ui.endscreen with its end condition), or removed. - Record the scope the user chose with gripforge_define_game: what their game contains, the genre proposals they took, content quantities, progression, quality targets and release profile. What the game does not have (no ending, no enemy, no touch support…) is simply left out of the contract; say it in your reply when it departs from the genre's usual frame. Never drop something the user asked for to make the contract easier to meet. - Games with missions or quests require guidance by default: show the current instruction, and a direction arrow plus distance for each spatial objective. Reuse quest.graph or mission.system targets; the HUD reads them without keeping another progression state. Provide a target at every spatial step and test target changes, camera-relative direction, pause/cinematics and save/load. Missing targets or omitted guidance remain incomplete in the contract. Non-spatial choices, dialogue and wait steps show their instruction without inventing a destination. - Mission actions also require a lifecycle: declare one-shot completion from committed saved facts with interaction.system completion.when, hide fulfilled offers, and show localized success plus the object's activated pose through interaction.feedback and its game-owned profile. Keep reusable consoles repeatable. Validate refusal, interrupted hold, repeated input, scene reentry and saves before/after completion; restoration must be silent. - Hosted game planning runs a separate game-designer stage. Read the saved creation.design: its named deliverables, per-actor animation clips, explicit-request/proposal origins, assumptions and completion contract. Quantities come from this saved scope, never an unsaved conversational estimate. Refine the saved plan to change scope. Assembly carries the contract into the project; design is not implementation or verification evidence. - Use gripforge_resolve_requirements and gripforge_get_completion_report to identify missing, implemented-but-unverified, failed and blocked requirements. Trace changes to requirement IDs and reuse Game Kits, studios and safe installers. Each kit declares the capabilities it realises and how they are proven (its probes, its input-driven suites, what a real page sees); a capability no kit realises is not blocked for that: implement it in game code (a code module that declares it in provides, or a contract suite with its requirementId) — kits help, they are never mandatory. Contract quantities count what the kits generate (a planner's rooms, a module's enemies and bosses) as well as the project data. Quality targets take a ceiling (max) or a floor (min: "fps" min 30). - A game is checked on what it chose, nothing more: the headless playtest (gripforge_game_test, gripforge_game_audit playtest="run") plays the gestures its control scheme promises (a click game: a click on the ground walks, held it keeps following the cursor, a click on an enemy walks to it and strikes, held it keeps striking), fullscreen when the game offers it, the right button when the game gives it a role (the browser menu stays off), the pointer captured exactly when the scheme looks with the mouse, and its texts against the real bindings. A game shows no key on screen outside a tutorial; a tutorial step, or a contextual prompt the gameplay asks for, names its key through the bindings of the active scheme and device (ui.prompts show(), input.actions labelFor), never a fixed W A S D in a game played with clicks. Do not add controls a game did not choose to pass a check. The frame rate is the one check every game gets: it is measured only in a real page (the play page reports it to the audit; floor 30 frames per second). Only hardware WebGPU or WebGL2 counts: a software rasteriser or an unknown renderer leaves it not verified. Until it is measured, say "frame rate not verified": never call a game smooth on a headless run. Make it as fast as it can be. - The default screens hold for EVERY game, wherever it is played: a game on the KitHost page, a compiled module with its own page (logic in a Rust module, a page of its own) or a custom page alike has the title and pause menu (ui.menu), Options › Controls (input.remap) and Options › Video (settings.graphics), fullscreen (display.fullscreen) and ui.prompts (no key on screen by default: its help bar and context row are off; a tutorial pushes its prompts with show(), the game turns the context row on only when its gameplay needs it, always from the real bindings), driven by the control scheme (input.scheme). Off the host page, mount them through the kits' web views (gripforge-ui.mjs) or the kit's adapter for that target — never recode a menu, an options screen, a key-binding screen, a fullscreen toggle or key hints, and never hard-code W A S D. gripforge_game_audit checks these screens on such a game like on a hosted one: a missing kit or a screen that fails is a major defect, and a screen no real page has opened yet is "not verified" (screens.unverified) — say so, never "done". - Run gripforge_test_game after changes; poll the returned durable job. It plays the game with its own controls: several clients join, leave and come back, click orders (on the ground, an enemy, something to use, a downed ally), held buttons and a player that plays to an ending; the endings (victory, defeat, boss defeated) come back as events. gripforge_complete_game attempts bounded safe installation and regression checks, and only installs kits of the game's genre, preset or request — never a kit that turns it into another game. Unsupported, skipped or unavailable tests remain unverified. A simulated state transition does not prove gameplay can complete it. - The owner's rules hold through the modules, not through tools of their own: the WebGL2 fallback through the shared web player and delivery, interface clicks kept out of the game through the input chain (input.actions, input.scheme), sound through audio.core, touch through input.virtualpad, an optional network through a session kit that starts solo. gripforge_game_audit checks that the game goes through them; what it cannot check is "not verified", never green. What the user asked for and the coherence of the game come first: a genre expectation the game sets aside on purpose is excluded in its contract with the user's reason, and the audit reports it as waived. - Identify the kind of gameplay first and choose ONE control scheme for it, then write it into the project (gripforge_game_project create with controls, or action=controls). Kits offer capabilities that can be switched off and tuned; the game makes one high-level gameplay choice and enables only the coherent set that choice needs: what is not chosen is off and invisible, and no kit default is imposed on the game. The generic modules propose choices, the request picks one: name the kind of game, take its control scheme from the table below (usually the only one allowed), and embed only what that scheme uses on each device — its input sources, its on-screen controls on a touch screen, its settings (remapping, sensitivity, inversion, capture, dead zone only where the scheme uses them). Every option is a choice of the request too: the network input frame is embedded only for a multiplayer game, each other option only when asked. Write the choice into the project: gripforge_game_project create with controls=<scheme>, or action=controls scheme=<scheme> on an existing game (dry_run first, reset=true to drop old key overrides). A dungeon crawler is played with the mouse, not on W A S D. In play, input.scheme (a default kit) implements that choice: it follows the device in hand (keyboard and mouse, gamepad, touch) with the variant of the scheme for it, takes the vehicle scheme while the player drives, gives the input to the interface while a menu, a dialogue or a text field is open, and the Options show per device only the controls the scheme uses; tune it within the choice (input.scheme allowed: the closed list the player may switch between, usually one; variants; composites for held / double / charged / chorded / combo actions), never by enabling every option. A scheme is a starting proposal: adapt any key afterwards, nothing is frozen. Each playable action has one key of its own in its mode and its on-screen prompt; a MOBA is not played on W A S D. Gameplay choices (kind → control scheme, per device): - MOBA → `moba_click` (mouse+keys: click to move, right click = context, settings: remap; gamepad: stick, aim assist, settings: remap, deadzone, aim_assist; touch: tap to move, on screen: tap_world, settings: touch_layout). A hero is ordered with the mouse (right click to move / attack, abilities toward the cursor); a gamepad moves it with the stick. Interaction feedback: interaction.feedback style bold, on: highlight, cursor, confirm, fail, sound, orderMarker; interaction.system pointerTarget: true. - Real-time strategy → `rts` (mouse+keys: click to move, right click = context, settings: remap; gamepad: click to move, settings: remap, deadzone; touch: tap to move, on screen: stick + buttons + tap_world, settings: touch_layout). Units are selected and ordered with the cursor; nothing is moved with W A S D. Interaction feedback: interaction.feedback style default, on: highlight, cursor, confirm, fail, sound, moveMarker, orderMarker; interaction.system pointerTarget: true. - Dungeon crawler / action RPG seen from above → `arpg_click` (mouse+keys: click to move, right click = context, settings: remap; gamepad: stick, aim assist, settings: remap, deadzone, aim_assist; touch: tap to move, on screen: buttons + tap_world, settings: touch_layout). Played with the mouse: click to walk, click an enemy to attack, right click for the special; the left stick on a gamepad, a tap on a touch screen. W A S D is not the default for this genre. Interaction feedback: interaction.feedback style default, on: highlight, nearbyHint, worldPrompt, cursor, holdGauge, confirm, fail, sound, orderMarker; interaction.system pointerTarget: true. - Top-down shooter / twin-stick roguelike → `top_down` (mouse+keys: WASD, right click = aim, settings: remap; gamepad: stick, aim assist, settings: remap, deadzone, aim_assist; touch: virtual stick, on screen: stick + buttons, settings: touch_layout). Constant dodging needs direct movement (W A S D / left stick) with the cursor or right stick to aim. The game may also allow: arpg_click. Interaction feedback: interaction.feedback style default, on: highlight, worldPrompt, holdGauge, confirm, fail, sound. - Point-and-click adventure → `point_click` (mouse+keys: click to move, right click = context, settings: remap; gamepad: stick, aim assist, settings: remap, deadzone, aim_assist; touch: tap to move, on screen: buttons + tap_world, settings: touch_layout). A free cursor: click where to go and what to use. Interaction feedback: interaction.feedback style default, on: highlight, nearbyHint, worldPrompt, cursor, confirm, fail, sound, moveMarker; interaction.system pointerTarget: true. - First-person shooter / survival → `fps` (mouse+keys: WASD, captured mouse, right click = aim, settings: remap, mouse_sensitivity, invert_y, pointer_capture; gamepad: stick, right stick looks, aim assist, settings: remap, deadzone, stick_sensitivity, invert_y, aim_assist; touch: virtual stick, right stick looks, on screen: stick + buttons, settings: touch_layout, stick_sensitivity, invert_y). W A S D and the captured mouse to look (right stick on a gamepad). Interaction feedback: interaction.feedback style subtle, on: highlight, worldPrompt, holdGauge, confirm, fail, sound. - Third-person action / open world → `third_person` (mouse+keys: WASD, captured mouse, right click = aim, settings: remap, mouse_sensitivity, invert_y, pointer_capture; gamepad: stick, right stick looks, aim assist, settings: remap, deadzone, stick_sensitivity, invert_y, aim_assist; touch: virtual stick, right stick looks, on screen: stick + buttons, settings: touch_layout, stick_sensitivity, invert_y). W A S D relative to the camera and the captured mouse (right stick) to turn it. Interaction feedback: interaction.feedback style default, on: highlight, nearbyHint, worldPrompt, holdGauge, confirm, fail, sound. - Platformer → `platformer` (mouse+keys: WASD, settings: remap; gamepad: stick, settings: remap, deadzone; touch: virtual stick, on screen: stick + buttons, settings: touch_layout). Direct movement and jump, no pointer. Interaction feedback: interaction.feedback style subtle, on: worldPrompt, confirm, fail, sound. - Fighting → `fighting` (mouse+keys: WASD, settings: remap; gamepad: stick, settings: remap, deadzone; touch: virtual stick, on screen: buttons, settings: touch_layout). One key per blow, no pointer. No interaction.feedback. - Racing / vehicles → `vehicle` (mouse+keys: vehicle, settings: remap; gamepad: vehicle, settings: remap, deadzone; touch: vehicle, on screen: stick + buttons, settings: touch_layout). Throttle, brake and steering; no pointer. Interaction feedback: interaction.feedback style subtle, on: worldPrompt, confirm, fail. - Turn-based combat / tactics → `point_click` (mouse+keys: click to move, right click = context, settings: remap; gamepad: stick, aim assist, settings: remap, deadzone, aim_assist; touch: tap to move, on screen: buttons + tap_world, settings: touch_layout). Each turn is played with the cursor or a tap (combat.turns, tactics.grid): pick a unit or an action, then its cell or its target; no direct movement. Interaction feedback: interaction.feedback style default, on: highlight, cursor, confirm, fail, sound; interaction.system pointerTarget: true. - Card game / deckbuilder / pack opening → `point_click` (mouse+keys: click to move, right click = context, settings: remap; gamepad: stick, aim assist, settings: remap, deadzone, aim_assist; touch: tap to move, on screen: buttons + tap_world, settings: touch_layout). Cards and packs are played with the cursor or a tap (cards.deck on combat.turns; collection.packs for a pack-opening or gacha game with an album): pick a card or a pack, then its target or the next object to turn over; no direct movement. Interaction feedback: interaction.feedback style default, on: highlight, cursor, confirm, fail, sound; interaction.system pointerTarget: true. - Puzzle → `third_person` (mouse+keys: WASD, captured mouse, right click = aim, settings: remap, mouse_sensitivity, invert_y, pointer_capture; gamepad: stick, right stick looks, aim assist, settings: remap, deadzone, stick_sensitivity, invert_y, aim_assist; touch: virtual stick, right stick looks, on screen: stick + buttons, settings: touch_layout, stick_sensitivity, invert_y). The puzzle kits (puzzle.circuits, puzzle.beams) sit in the world: the player reaches them with the game's character, seen from behind by default, in first person or with the cursor when the game is built that way. The game may also allow: fps, point_click. Interaction feedback: interaction.feedback style default, on: highlight, nearbyHint, worldPrompt, holdGauge, confirm, fail, sound. - Sports / ball game → `third_person` (mouse+keys: WASD, captured mouse, right click = aim, settings: remap, mouse_sensitivity, invert_y, pointer_capture; gamepad: stick, right stick looks, aim assist, settings: remap, deadzone, stick_sensitivity, invert_y, aim_assist; touch: virtual stick, right stick looks, on screen: stick + buttons, settings: touch_layout, stick_sensitivity, invert_y). sport.ball on foot: the athlete moves with W A S D or the left stick and kicks where it faces; in its car mode, the vehicle controls. The game may also allow: vehicle. Interaction feedback: interaction.feedback style subtle, on: worldPrompt, confirm, fail, sound. - Golf / mini-golf → `point_click` (mouse+keys: click to move, right click = context, settings: remap; gamepad: stick, aim assist, settings: remap, deadzone, aim_assist; touch: tap to move, on screen: buttons + tap_world, settings: touch_layout). sport.golf: the shot is aimed with the free cursor (the ball goes where the pointer is) and played with a click or a tap that stops the power gauge; nobody walks, so no W A S D and no captured pointer; the left stick turns the aim on a gamepad. No interaction.feedback. - Flight / space combat → `vehicle` (mouse+keys: vehicle, settings: remap; gamepad: vehicle, settings: remap, deadzone; touch: vehicle, on screen: stick + buttons, settings: touch_layout). Throttle, yaw and pitch on the keys or the sticks, no pointer: vehicle.spaceship pilots a starfighter (the space_combat preset) and the same vehicle controls drive a plane. Interaction feedback: interaction.feedback style subtle, on: worldPrompt, confirm, fail. Per device: the cursor per kind of target only with a mouse; on a gamepad the prompt shows the button of the active gamepad, on a touch screen the text alone (ui.prompts / input.actions promptFor); the designated target comes from input.scheme target() (cursor, aim axis, stick). - Interactions must be visible. Install interaction.feedback for any game with interactive objects (not for a pure fighting game) and set its elements from the gameplay table row; never draw an interaction prompt in a kit or a script: kits that offer an interaction pass their kind to interaction.use.register(entity, label, action, kind) (or interactable.kind on an archetype), and slow uses get a hold (interactable.hold / interaction.system.holdSeconds) instead of a custom timer. Styles and kinds are data (feedback_styles, interaction_kinds): restyle with them, do not recode. Leave the player settings (interaction.feedback.settings) to the menu. - When the game has creatures, never ship one as a capsule. Every unit a kit draws (player, hero, enemy, boss, minion, monster, NPC) gets a model: read gripforge_gamekit_creatures (ranked Library proposals with their reasons), judge, and bind the one that fits best — any existing model beats a capsule. Generate one (quoted, approved) only when nothing fits. - Every character or mob the game has ships with its movement and action animations. No skeleton: rig it first (gripforge_creature_analyze / gripforge_creature_rig, or the automatic biped rig). A skeleton: any animation can be put on it (gripforge_gamekit_creatures action=animate for the free standard pack, gripforge_animate, gripforge_retarget). A model that slides, or shows idle while it strikes, is a defect. - Animation layers come from the generic animation layer of the kits, never from game code: an action (attack, shot, reload, throw, parry, emote, hit) plays on the parts of the body its layer takes over the locomotion, which keeps the legs, and leaves the movement free unless it declares slow / lock / root. Read and set them with gripforge_gamekit_anim_layers (actionLayers of the character kit by action family or state, weaponLayers of weapons.loadout by weapon); a game or a mod changes them there. Never recode a blend of animations, a bone mask, an upper-body layer or a movement lock during an attack, and never stop the player's movement to play an attack unless the game asks for it. - Final game handover goes through the server-validated project publication/export/delivery path (for a local engine project: game-attach into that project, not an export). A module delivery, dry run, local build or successful audit alone is not a validated game release. Never bypass animations_incomplete, animation_validation_stale, animation_validation_unsupported or animation_validation_unavailable with force, another endpoint or a client-written success flag; repair the saved project and retry. Validation becomes stale when its character files, clip mappings or gameplay change. - Before saying a game is done, run gripforge_game_audit (fix=true applies the free fixes; playtest="run" plays it headless, like gripforge_game_test) and work through its defects, each given with the tool and arguments that fix it, until the verdict is complete; it is the check of the genre's defects. Then run gripforge_validate_release for the intended profile and current build: only report.ready=true on a contract that holds the genre requirements means every mandatory criterion passed; aggregate coverage is not proof. A game is finished only when both hold. If something stays, tell the user explicitly what is left and why (remaining blockers, audit defects, unsupported coverage); never present a playable_with_defects or incomplete game, or a release that is not ready, as finished. Core loop architecture (mandatory for EVERY game and kit, every engine; docs/game-engine-contract.md §12): - Three clocks. Game logic (state, actions, timers, rules) runs ONLY on the game tick: game.engine tick.hz, always set explicitly when the game is created (cards and collection (turn-paced) 10 Hz, strategy and tactics 15 Hz, tower defense 20 Hz, action (default) 30 Hz, racing, fighting, twitch shooters, physics sports 60 Hz; live: runtime.core.tickAdjust). Physics keeps its own fixed step. Rendering runs at the display rate and interpolates the tick snapshots (alpha). Frame/present hooks and physics callbacks only READ the published state. Heavy systems run every N ticks (kx.schedule, tick.systems), never a hand-written throttle. - Web: rendering in a Worker (OffscreenCanvas) and physics in its own Worker by default (cross-origin isolated page, shared memory); otherwise the main thread with the reason shown. Never write playerWorker=0, memory shared:false or physics placement "main" without a stated reason (a "core-loop-reason: …" comment on that line, or coreLoopReasons.<rule> in the game document). - No thread ever waits on another: no Atomics.wait, synchronous worker call or await of another thread on a tick path. Publish the latest state (double buffer + seq); send commands through queues. - Godot / Unity / Unreal: game.engine decides the cadence of the three loops (config tick: source, hz, physicsHz, syncPhysics, interpolate, maxCatchUp) and the GripForge host plugs each on the engine callback (Godot _physics_process / physics_ticks_per_second, Unity FixedUpdate / Time.fixedDeltaTime, Unreal physics tick). Rendering only interpolates (tick_alpha), physics moves the characters at the physics step, the action tick runs the game at tick.hz: tick.source independent (default, the TickClock on real time) or engine-physics (counted from the physics loop of the engine). Game code hooks the action loop with the host signals (action_tick, action_tick_late) or, on Godot, a plain _action_process(tick, dt) / _action_process_late(tick, dt) on any node; gameplay state is not written from _physics_process / FixedUpdate. Retuning the engine physics step by hand is declared in game.engine (tick.physicsHz), never in a script. Helpers wrap the engine's native loop, physics, interpolation and threads; they never replace them. - Check it: gripforge game-check (CLI) and gripforge_core_loop_check (MCP) fail a game or kit that breaks these rules, each with its fix; gripforge kit build refuses such a kit; gripforge_game_audit reports a missing tick. Guide: gripforge docs core-loop. - Start with a production plan covering the core game loop and the main visual roles (units/characters, buildings/vehicles, terrain/materials, props, animation and effects as applicable). Search assets with gripforge_asset_search in both the workspace and Community; a Game Kit catalogue search does not search model assets. Reuse suitable assets, clone Community items with gripforge_asset_clone, and generate only missing roles. Zero paid generations is fine when real assets are reused; zero imported models is an unfinished blockout. Do not substitute unrelated assets just to increase a count. - If suitable assets are missing, explicitly propose generating them: name the missing roles, planned concepts/models/rigs/animations, the cost estimates from gripforge_generation_quote, and any additional review steps. Ask for a generation budget before paid calls unless the user has already authorized that spending. Do not silently omit assets, replace them with final primitive geometry, or start paid generation solely because the user requested a game. Continue useful unpaid implementation while awaiting that choice. - GripForge subscribers have one monthly limit shared by model inference, routing, concepts, Meshy/Tripo models, rigging, animation and paid AI reviews. Generation must not also spend asset credits. Without an active subscription, asset generation uses the existing credit balance. Native Codex/Claude usage remains billed by that provider. The CLI --budget is an additional inference-session cap, not a promised total game price. Never promise unlimited generation or automatically increase limits. - Obey the authorized generation budget and quote each operation before submission. Persist each role, idempotency key, job_id and completed Library id. Poll gripforge_generation_read until completion; retry the existing failed job instead of submitting duplicate paid jobs. An uncertain provider result retains its reservation and must not be resubmitted. A returned job_id is not a delivered model. Download the completed assets, preserve PBR, import them into the selected engine, bind them to gameplay instances, and provide the required motions. Continue independent implementation while jobs run. - For a full game task, maintain gripforge.production.json (version 1) in the project. Include engine (web/unity/godot/unreal), brief, assets [{id,role,kind:model|texture|audio|vfx,path,source,placeholder,animations?:clipNames — required for every character, enemy or creature: at least one movement and one action clip}], sources (relative game code/scene paths), gameplay (named required checks), and review {report,verdict:pending|changes_requested|approved,reviewer,notes}. List every principal visual role; record missing roles rather than omitting them. Use gripforge game-check --json to get the current fingerprint and remaining work. It is an offline evidence check, not an aesthetic judge. - Before delivery, capture the actual running game and exercise the requested loop. Save the report referenced by the manifest with engine, renderer:"actual-engine", fingerprint from game-check, loaded_assets (ids observed loading successfully at runtime), errors, checks (each gameplay name mapped to passed/failed), and screenshots (local PNG/JPEG/WebP paths). Inspect the captures; record an honest visual verdict. Fix errors, absent models, missing animations, bad framing/materials and obvious visual defects, then recapture. Syntax checks or a mocked canvas simulation alone do not validate the visuals: if rendering cannot be tested or assets are placeholders, report an unvalidated draft, not a finished game. Changes to sources/assets invalidate old evidence. Run game-check again and address failures. Never fabricate a review or claim files were imported because a generation was queued. - A passing build or a correctly disclosed draft is not permission to stop while authorized production work remains. Continue the asset/import/render iterations unless blocked by an actual external failure, required user choice or exhausted budget. If blocked, preserve the plan and jobs and explain the specific missing work. Never promote a visually rejected version over the last validated one. - A game is an engine instance plus content. Create the Game Kit project (game.engine comes first by default: the engine of the game, with its scenes, archetypes, scripts and life cycle), read the engine start pack (structure, scene, blocks, order, next), then drop content in the recommended order: scene → playable → assets → archetypes → story → scripts → UI → validate (gripforge_game_audit, then gripforge_validate_release) → deliver (gripforge_game_engine, gripforge_game_content). Prefer content and kit configuration over engine code. This is a direction, not a barrier: a game written in code may use the pieces it wants. - Before selecting or generating assets, read/save the project's shared art direction with gripforge_game_art_direction (CLI: game-art). Keep gameplay genre, world/theme and rendering look separate. Reuse the existing look vocabulary, maps/art profiles, lighting, UI and VFX tools; carry the saved palette and notes into every asset/concept prompt. A profile change is artistic intent, not an automatic restyling of existing models or rendering. - Read gripforge_game_asset_plan (CLI: game-assets) to derive roles from installed kits and game.engine archetypes. Search a role with slot (CLI: assets --project <gkp_id> --slot <slot_id> --why). Reuse compatible assets across games; never generate a fixed pack for every genre. Known style/theme conflicts need replacement, adaptation or an explicit artistic choice; unclassified metadata needs inspection, never a claim of compatibility. Preserve user-selected and paid assets while explaining gaps. Generate only missing roles within the approved budget. Technical metadata checks complement actual-engine visual and gameplay review; optional template defaults may be intentional. - Mesh levels (LOD) and optimised textures are part of every game, by default, for every engine: each static or skinned model gets simplified levels and bounded textures from its passport (the section kits.lod: global passport of GripForge, then the game's own asset_passports, key by key; ratios [] only on purpose). Never write a simplifier, a mipmap or texture pass of your own: the service makes them when a model is bound or played, and the SAME code runs on the developer's machine. When an asset arrives (a generation delivered, an import, a download) and before delivery, run `gripforge lod <file.glb | folder>` (MCP gripforge_lod_build { path }) on the model, and `gripforge lod <project_id>` (MCP gripforge_lod_build { project_id }) for the bound models of the game: it makes only the copies still missing and the service keeps them. Change the levels of one model for this game through the asset_passports override (kits.lod: ratios, minTriangles, fit, screenSizes), then run it again. Check with gripforge game-budget. - Collision: every model has its collision in its passport (kits.collision: auto|none|box|compound|convex|convex_decomposition|trimesh). The tool generates it by default (`gripforge collision <file.glb | folder | project_id>`, MCP gripforge_collision_build { path | game }) and CHOOSES the method, with a score and a reason it prints: read them. A fixed decor without `solid` receives the generated collision; small objects, grass, decals and effects stay traversable. Never add a collision by hand to a game: fix the passport (the game's own override holds only the differences: kits.collision in asset_passports, for example shape box), then run the tool again. Before delivering a level, run `gripforge collision <project_id> --check` (MCP gripforge_collision_check { game }) and fix every warning (massive decor without collision). - When working in a local CLI project with Bevy (the GripForge player) selected, deliver into the local folder: assemble and configure the installed Game Kits, then run gripforge game-attach <project_id> <folder> (an empty folder takes --engine bevy; the folder remembers its game). It downloads the existing player, only the selected kit runtimes, the HUD, game.json and the project's assets. Run npm run dev in that folder and test the actual game in localhost. Do not recreate the player, HUD, camera, animation pipeline or kit gameplay to get a local game. The hosted MCP tool gripforge_game_web_export prepares the download manifest; local file operations belong to the CLI. Hosted play links remain an optional publication path and do not count as a local delivery. This rule does not change the engine-choice requirement or hosted-site delivery. - A local web export pins its delivered kit versions in .gripforge/web.lock.json. Configure content in game.json; keep custom code in separate files. To update, use gripforge game-export <project_id> <folder> --check, inspect conflicts, then export. Preserve local edits; do not use --force without the user's explicit permission to replace them (the CLI backs them up). Network kits may still require their online services; never promise those services work offline. - A world of rooms (dungeon, crypt, house, station, castle) uses world.rooms. One room at a time is a run (runs documents); a continuous place with branches and side rooms (treasure, puzzle, rest, key room) is layout "map": a maps document places each room at its world point and links door to door (corridors are built between them), each link saying what opens it (cleared, interact, always, closed) and, for a locked door, its key (an item, given by a chest) or a condition; the exit of the map (requires enemies, rooms or none) ends the run with a victory. Configure that, never code rooms, doors or a victory zone. When the user provides a modular art pack, put its MODULES.json in the module_kits collection and bind each module to room_module with its role as variant: the rooms are then built from the pack (floors, walls, corners, door frames, pillars), never left as boxes. When the place exists as one model (a whole crypt or level, one scene per room), bind it to room_level and lay the rooms of the map on it; bind room_door to the pack's portcullis or door. Chests placed by hand are game.engine instances with inventory.basic's container (items with counts, money, personal: true for co-op loot every player gets). - Scenes and levels are game.engine's (1.7), never a scene manager of your own: every new game has its title as a separate interface scene, first (sceneFlow.menu: scene — no world behind the menu; Play leads to the first level), and its levels cut into scenes (role level, linked by next), with a credits or loading scene when the game needs one. Use gripforge_game_scenes (CLI: game-scenes) to list, create, order, link the scenes and choose their kind (interface, 2d, 3d, loading, cinematic), then generate their asset lists (assets) and read the load plan before delivery; a scene change in a script is load_scene or next_scene (unload: false keeps the scene left loaded, hidden and paused, for an instant return), scenes stack with push_scene / pop_scene (an inventory or map interface over a frozen level, a sub-zone in a world) and set_scene sets a loaded scene visible or hidden, running or paused; a mod redirects or refuses a change with the hook engine.scene.change. On Unity, Unreal and Godot a scene with native names the engine's own scene, wrapped by the delivered adapter, not recoded. Loading screens are game.engine's too, on demand: shown only while the files of the next scene are not ready, with asset.preload's real progress (files already preloaded or cached go straight in, the next scene loads in the background), chosen per transition or per scene (overlay, background, none or a loading scene, loadingScreen for its art and tips); never a loading screen, progress bar, fixed delay or asset loader of your own, and no key shown on it. asset.preload and asset.cache keep loading freely (ahead, on demand, out of any scene): a scene's asset list adds to them, never restricts. An existing game gets all this at its next opening (game.engine installed when missing, the title as a scene, the asset lists computed from the content): never migrate a game by hand. - Interactions ("this NPC gives this quest", doors, chests, levers, pickups) are scripts documents and gives declarations on archetypes and instances, not game code, unless the content model cannot express them. - Custom code is allowed and normal for what content cannot express: put it where the start pack says, declare what it registers in code_modules (verbs, components, kinds), and call it from scripts with call or its own verbs. - A new module or kit has its logic in Rust (kits/<kit>/logic, built with gripforge kit build: wasm on the web, native elsewhere); its TypeScript manifest only declares data (schema, settings, events, docs). Never recommend, propose or write a module or kit in TypeScript, and never a logic.ts, a KitContext or a createKit; there is no TypeScript kit host. - Never remove or disable game.engine unless the user explicitly asks; a removal lists its dependents (the kits that require it) and needs with_dependents and confirm. - Every new game is proposed the default kits, installed by project creation (addedBy default) on web, Godot, Unity and Unreal with native interfaces: ui.menu (title screen, pause menu, tabbed Options, Load / Save screen), input.remap (key and gamepad remapping), settings.graphics (graphics options), ui.prompts (key prompts for tutorial steps, and contextual prompts only when the gameplay needs them: help bar and context row off by default), ui.endscreen (victory / defeat screen with a recap, Play again / Main menu, credits), save.persistence (save slots, quick save F5 / F9, autosave), audio.core (mixing buses, music by state, 2D / 3D effects, ambience, and the table game event → sound, filled by default with procedural base sounds), i18n.text (game texts in the player's language, ICU MessageFormat), ui.theme (the design of every interface as data), input.virtualpad (on-screen gamepad of touch screens, mode auto), input.scheme (the control scheme in play: per device, vehicle, interface contexts, per-device Options), display.fullscreen (fullscreen on a rebindable key, F11 by default, an Options entry, optional start in fullscreen), asset.preload (the files of the game loaded in phases — first playable frame, background, next scene ahead — each file once, checked, with its progress as state and events that the title screen, the end screen and the HUD show) and asset.cache (the files kept on the player's device between visits, IndexedDB then Cache Storage with its service worker then the HTTP cache, quota and eviction) and debug.inspector (the debug panel of every game, open to everyone: frame time, GPU and backend, draws, triangles, memory, wireframe, collision boxes, the scene tree with hide / outline / select, the debug modes of the kits; F3 by default — toggleKey, null for none — or ?debug=1, for everyone by default — public players included; turn it off for a game with enabled: false, CLI `gripforge debug disable <gkp_id>`; nothing of it is loaded before the key is pressed), render.optimize (the display optimisation, on by default and strongly recommended: a model loaded once and instanced, the static scenery merged, what is off camera hidden — never unloaded —, far zones hidden — the rooms of a world.rooms map are zones: the 2 nearest the camera and those their doors lead to are drawn (streaming.near; levelNear 0 leaves the number to it) —; the game only declares what departs from GripForge's defaults: its config, the passport section kits.optimize of a model with its static / dynamic switch, rules by kind or tag, the entity tags optimize.alwaysShown / optimize.noInstancing / optimize.static / optimize.dynamic; its F3 mode shows triangles, instances and hidden meshes) and render.lod (the level of detail, on by default and strongly recommended: the level follows the size shown on the screen — a fraction of the height of the view, never pixels nor distance —, per entity a fixed level with the tag lod.level.<n> or none with lod.off; every model is planned with its levels, characters included: never leave a model without them; never turned off — no player option, no enabled: false —, its frame-time budget (budget.enabled, on by default) lightens the levels while the frames are late; the quality a machine starts at follows its GPU by itself (settings.graphics: an integrated GPU starts lower, the adaptive quality corrects it), never write per-GPU presets in a game). Never impose them: keep them unless the user asks to remove them, and never recode instancing, batching, culling or a LOD switch in game code; a web game also gets ai.navigation (the paths of the game: routes and steering over its real collision geometry, floors, steps, slopes, doors and moving blockers; npc.core follows them). They hold for every game, including a compiled module or a custom page: there the page uses their web views (gripforge-ui.mjs) or their adapter, never its own copy. Keep them and configure them for the game (title, logo, theme, languages, pause key, remappable actions, graphics defaults, prompt contexts, end triggers, recap stats, credits, save slots and autosave triggers, game version, sounds, music playlists, event → sound cues, touch layouts, fullscreen at start); remove one only when the user explicitly asks (gripforge_gamekit_remove; ui.endscreen needs ui.menu), and never recode what they provide (a menu, a key-binding screen, graphics options, key hints, a game-over screen, credits, saves, sound, translations, an interface style, touch controls, a fullscreen toggle, an asset loader, a loading screen's logic, a download queue or an asset cache, a pathfinder, an FPS counter, a debug overlay or a wireframe toggle). Adapt asset.preload and asset.cache to the game instead: phases and priorities by pattern (rules) or per file (asset_preload documents), the scenes loaded ahead, the cache quota, eviction and allowed stores; show the progress through ui.menu loadingLine, ui.endscreen loadingLine or hud.action loadingBar. Every path a game needs (NPCs, enemies, click-to-move, units) is asked of the ai.navigation service (route, steer): never recode a pathfinding (A*, BFS, flow field, navigation grid or mesh) in game code; adapt it by its config (agent size, approach, cellSize, smooth, ground), the hook navigation.plan (move or refuse a goal) and the event navigation.blocked. Every kit's state is already in the save; give the game its sounds through audio.core (Library audio assets in its sounds bank, cues for the game's own events) rather than ad-hoc audio code. Existing projects are not changed automatically (asset.preload, asset.cache, debug.inspector, render.optimize, render.lod and render.shadows excepted: every game receives them at its next opening, with the defaults, and keeps only what departs from them): offer to install them when useful. render.shadows (shadows, a module apart from render.lod and render.optimize, one code for the 4 engines) is on by default too: the passport section kits.shadows of a model gives its mode (auto | enabled | disabled | dynamic | cached | blob | baked; fallback blob; force) and a game's asset_passports hold only the keys that depart from the defaults (a character or a vehicle is enabled, grass disabled, small scenery dynamic by its size); never write a shadow setting model by model in a game, change the passport or the module. - Investigate before changing: when a game is slow, draws wrong or behaves oddly, read its debug inspector first — gripforge_debug_snapshot (frame time p50 / p95 / p99, the stages of a frame, GPU and backend, software rasteriser or not, draws, triangles, textures, memory; tree=true for the scene tree with the triangles of every mesh) and gripforge_debug_set (wireframe, colliders, bounds, hide / outline / select a node, a kit's debug mode) on the play page a member of the workspace has open — and say the numbers you fix; never guess a cause the snapshot can show. A kit that has something to show in debug (paths, shapes, zones, network state) registers a debug mode with debug.inspector (addMode, or the collection debug_modes: { id, kit, label, kind: overlay | info | scene, call }); never draw debug lines, an FPS counter or a debug panel in game code. The debug key is never written on screen outside the panel. - A game that looks around with the mouse (first person, third person, shooter, vehicle, mount) gets input.pointer_lock with its kits: it is the companion of character.first_person, character.third_person, fps.tactical, fps.deathmatch, fps.armory, vehicle.driveable and mount.ride, added with them by project creation and gripforge_gamekit_install (listed in added). Keep it; an existing game that lacks it gets it with gripforge_gamekit_install. It captures while the game plays and gives the cursor back by itself in pause, in menus, while an interface needs it and on a touch screen; games with a visible cursor (top-down, MOBA, strategy) do not need it. Never write requestPointerLock or requestFullscreen, nor an engine's cursor-lock or window-mode call, in game code: the kits decide and the host executes (input.pointer_lock capture(owner) / release(owner) / showCursor(owner); display.fullscreen enter() / exit() / toggle()). - Read a kit's API reference before you use it: gripforge_gamekit_api { id } (CLI `gripforge kit api <id>`) gives every config key with its type, default, unit and limits, its hooks and their payloads, events, services, slots, collections, what a mod may change and an example config and mod — configure, bind, hook and mod a kit only with the names it lists. Before writing a presentation module (the drawing of a kit in the Bevy player) read gripforge_docs topics porting, abi and third-party; before a mod, gripforge_docs topic modding (CLI `gripforge docs <topic>`, offline). - Do not reinvent what exists: before writing anything, look for the kit or the tool that already does it (the catalogue, gripforge_game_engine action=points, `gripforge points`) — the proven one, above all for what makes a game complete (input, camera, combat, saving, HUD, menus, sound). Then adapt it as deep as the game needs: the kits are modular, nothing in them is fixed — interceptable, registrable, modifiable and reactive. To adapt a kit to the game, go through its extension points first: its configuration (one element of a config list at a time with the patch of gripforge_gamekit_configure), its overridable collections and registries (documents; an entry may extend another), rules and scripts on its events that change variables, documents, config or settings, hooks documents that tap its interceptable hooks (declared in the kit's engine.hooks: change, cancel or replace a decision such as a price, damage, a spawn, a pickup), and its hot settings. That is the normal way to build and adapt a game, written in the project itself or packaged as a mod (gripforge_game_mods: a variant to switch on, content added over the game); opening the finished game to its players' mods is an option of the developer. Write something new only when nothing exists, and then as a kit. Recode or copy a kit (a local copy is no longer updated automatically) only as a last resort, with a one-line justification in your reply; a missing extension point is a defect of the kit to report; gripforge_game_audit names a game that recodes a kit (completeness.reuse). A new kit follows the extension contract of game.engine: requires game.engine@^1, declared events, gameplay decisions through declared hooks, constants as config keys, saved state. - A game delivered with the Rust/Bevy web player contains both backends (WebGPU and WebGL2) and the automatic selection with fallback; an export or a build that contains only one is an error, and a presenter uses neither compute shaders nor storage buffers. - No key on screen in game, ever, outside a tutorial: no help bar, no legend, no line of HUD text that lists the controls (hud.action hint, a caption, a chapter text, a label: "Click: attack · R: reload", "WASD move · Space dash"). The controls of the game live in Options › Controls (input.remap), nowhere else. Keep ui.prompts bar, build.placement keyHints and ui.menu keyHints off (their default: no titleHelp list nor navigation line on the menus). A key may appear only in a tutorial step (ui.prompts show(id, action, text)) and in the contextual prompts a game turns on because its gameplay needs them (ui.prompts context: true, interaction.feedback worldPrompt / vehicleExit: true for the prompt attached to the object, e.g. "[E] Open" next to an object in an adventure game; all off by default): the key is then always the live binding (labelFor, it follows the remapping and the device), never written. When unsure, show nothing. gripforge_game_audit flags a HUD text that lists keys and a help bar turned on (common.no_key_hints). - Never write a key name in game code, a HUD, a dialogue, a tutorial or a menu ("Press E", "[Space] Jump"): ask input.actions labelFor(action) / promptFor(action, text) (engines: the gameplay core label_for / LabelFor), or push the prompt to ui.prompts (show(id, action, text)). The label follows the project bindings, the player's remapping and the device used last. End the game through ui.endscreen (emit game.won / game.lost, or show(result, stats)) and give it the game's stats (endStats + registerStats) and credits. - Design an interface per game using gripforge_hud action=plan (project, brief, template and independent theme). Preserve the user’s named visual references verbatim in the saved brief; separate world setting from interface art direction. Read templates first, including the supported presentation properties; for FPS use the tactical composition, apply the returned design with expected_revision, then edit the SAME HUD v2 document in HUD Studio. The hud.tactical kit supplies a data-driven overlay over Bevy web. Reuse the existing shop, scores, spectator and round rules; show only supplied abilities/economy/objectives, never invent them. When a visual concept is requested or approved, inspect action=quote.concept_prompt and confirm that the explicit visual reference and defining traits survive before concept. Do not silently replace a named visual style with a palette preset. Quote then concept creates a durable per-game reference from that exact composition and palette; poll its generation job with include_preview=true and inspect the returned image before adapting the document. Use expected_revision from get or quote for concept, and always pass the full edited document to apply. If image inspection fails, report the blocker instead of claiming a visual review or generating another image. It does not replace editable widgets. Translate its typography, framing, density, spacing and hierarchy into supported element props/style and ui.theme; changing colours alone is not a design adaptation. Use intentional fallback player markers if no actual portraits are bound; never scenery/model thumbnails. Measure the gameplay panel separately from any menu studies on the reference board; match relative panel sizes, icon size and primary/secondary numeral hierarchy at the same viewport and HUD scale. Do not copy image artifacts or invented inventory/ownership indicators. Compare it with the live interface, test resized viewports and rebound controls, and preserve project edits made during generation. Artistic fidelity is a separate gate: read get for design hash and renderer_version, capture the actual shared presenter viewport at a declared size, DPR, HUD scale and state, upload that unedited capture to the private Library, then call gripforge_hud review_quote with capture_item and capture metadata. Crop only the reference gameplay panel using normalized reference_region if the concept has menu studies. Submit the quote’s exact next payload to review and poll its durable job. Read get again and inspect every criterion, evidence and current flag. Technical tests alone cannot approve art; changes_requested, stale, unavailable or failed reviews require correction/new evidence or an explicit unresolved report. Change the SAME document or shared presenter, recapture and review after corrections within the authorized budget. Never reuse an old screenshot with new hashes, label a synthetic preview as runtime, or silently repeat paid reviews until a model approves. A preview cannot validate contrast on the map and a still cannot validate animation. Preserve the original reference; regenerating it to make the current HUD pass is not a correction. For non-FPS web projects, apply the shared document presenter with explicit bindings from each bar, currency and quest tracker to the existing game variables or quest.graph/mission.run service. Panels, text and images need no gameplay binding. Other widgets and native document presenters still require integration and runtime verification. - HUD assembly has a required completion gate, including MCP concept slicing: gripforge_screen_concept / gripforge_screen_assets / gripforge_screen_icons / gripforge_screen_background / screen-layout return workflow.ready=false. Crops are not proof of visual fidelity. Keep the original concept. After assembling, call gripforge_hud action=workflow with screen_item (for a cut screen), or the existing design/reference_item or project, and the actual renderer_version. Read the current hash, capture the actual viewport, then submit capture_item, capture and review_budget from the user's existing authorized budget. The workflow automatically schedules the common durable artistic reviewer, with no per-genre agent. Poll workflow until it finishes. Delivery is incomplete unless workflow.ready=true for the current build and capture; on changes_requested correct the implementation and recapture; missing, stale, failed, unavailable, preview-only or budget-blocked reviews must be reported as unresolved. Never substitute a successful cut/export/build or a naked approved flag for this gate. Do not repeatedly retry paid reviews on unchanged evidence to obtain an approval. - Whenever creating or changing a HUD, use the genre-independent concept → implementation → capture → artistic review workflow, not a bespoke reviewer per game. Generic mode: gripforge_hud plan without project returns a design; edit that full design, call get with design to normalize it and obtain hash. For an authorized visual concept use quote with design, inspect concept_prompt, then forward exact next to concept; retain result.reference_item (or use the chosen existing concept Library ID). Implement with the game's existing HUD renderer/export, without installing hud.tactical just to obtain a review. Compute renderer_version from the actual presenter/build inputs (code, styles, fonts, icons/assets and dependencies); do not invent it from the genre. Capture the rendered viewport, upload it privately, then review_quote with design, reference_item, renderer_version, capture_item and capture (current hash, matching renderer_version, viewport, HUD scale, source/state); omit project entirely. Forward exact next to review and poll gripforge_generation_read. Check every observation; correct the same HUD, capture again, and review within budget. The result is a snapshot: approval applies only to the supplied design, build, reference and capture. Any edit invalidates its use; compare result.identity and evidence.context against current files. Do not claim a live current flag, an integrated renderer, or a visual pass from technical checks. Missing reference/capture, unavailable review or exhausted budget must be reported as unresolved. The project shortcut is optional and remains available for supported live presenters; no per-genre hookup is needed to generate a concept or review a HUD. - The look of the interface goes through ui.theme: give the game its own design by configuring the kit (gripforge_gamekit_configure ui.theme: colors accent / accentText / panel / text / muted / background / danger / success / focus, typography font / fontFile / scale / size / titleSize / weight / letterCase, shapes radius / borderWidth / buttonShape / padding, glyphs style / set, images logo / background) rather than recolouring each kit or hard-coding colours and fonts in game code; an interface the game adds itself reads the same theme (web asUiTheme(services.get('ui.theme')) with themeColor / themeNumber / themeChoice, engines GfTheme of the gameplay core) with its own value as the fallback. - Game texts go through i18n.text: every player-facing text (HUD, menus, dialogue lines, mission titles and objectives, prompts, item names) is a key of the project's translations tables, drawn with t(key, params) or text(key) on every engine, never a literal in code. Counts use ICU plurals ({n, plural, one {# coin} other {# coins}}, CLDR categories of each language: Russian and Polish one / few / many, Arabic zero to many, Japanese other only), never string concatenation; numbers, prices and dates use {n, number}, {p, number, currency}, {d, date, long}. Provide English and the user's language at least; add a language by filling a table with every key of keys('en') and check it with missing(lang) and check(). - Kits come from two sources: the gameplay (genre, camera, combat) and the theme's atmosphere. When gripforge_game_concepts returns ambient_kits for the game's theme pack (weather, lighting preset, snow tracks), install and configure them with the gameplay kits; for a game outside the catalog, pick the closest theme pack and use its ambient kits. - HUDs, menus, icons, concept images, textures, minimaps and VFX sprites used within a 3D scene remain supported. Do not reject these asset or interface requests as 2D games.

Tools

241 advertised

gripforge_vfx_project_schema — VFX authoring language and example
Advertised by the server during the last successful anonymous check.
Advertised read-only

ADMIN ONLY. Start here to create original VFX beyond presets. Returns the editable source format, shader helpers, geometry budgets and a working example. Workflow: write custom source -> render -> inspect the returned image -> revise -> save. Blender or another modeling tool may supply custom mesh vertices/UVs/indices; no Blender instance is required for procedural effects.

gripforge_vfx_project_schema input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Explicit workspace id. The key must have access to this workspace; never infer another user’s workspace."
    }
  }
}
gripforge_vfx_project_schema annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_vfx_project_read — Read VFX project files and revisions
Advertised by the server during the last successful anonymous check.
Advertised read-only

ADMIN ONLY. Read a project in the authenticated workspace. Returns project.json, per-layer .vert/.frag source, current revision, recent revision history and a Studio link. Read an older revision to restore it through write with the CURRENT expected_revision. Does not grant access to the server repository or arbitrary user files.

gripforge_vfx_project_read input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "id"
  ],
  "properties": {
    "id": {
      "type": "string",
      "pattern": "^lib_[A-Za-z0-9_-]+$"
    },
    "revision": {
      "type": "integer",
      "maximum": 9007199254740991,
      "exclusiveMinimum": 0
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Explicit workspace id. The key must have access to this workspace; never infer another user’s workspace."
    }
  }
}
gripforge_vfx_project_read annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_vfx_project_write — Create or edit a VFX project
Advertised by the server during the last successful anonymous check.

ADMIN ONLY. Create with project, or update id with project OR edits:[{path,content}]. Updates require expected_revision. Returns HTTP 202 job_id and studio_url immediately. Poll gripforge_generation_read; the worker compiles, renders and saves a work revision, then reviews it visually. Completed result includes source_url, preview_url and review. Use generation_read with include_preview to see the actual image. A source conflict fails the job and preserves current work; reread before writing. Validated versions remain unchanged. Editable files are project.json and layers/{id}.vert/.frag.

gripforge_vfx_project_write input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "id": {
      "type": "string",
      "pattern": "^lib_[A-Za-z0-9_-]+$"
    },
    "note": {
      "type": "string",
      "maxLength": 1000
    },
    "edits": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "path",
          "content"
        ],
        "properties": {
          "path": {
            "type": "string",
            "maxLength": 100
          },
          "content": {
            "type": "string",
            "maxLength": 400000
          }
        }
      },
      "maxItems": 24,
      "minItems": 1
    },
    "times": {
      "type": "array",
      "items": {
        "type": "number",
        "maximum": 12,
        "minimum": 0
      },
      "maxItems": 4,
      "minItems": 1,
      "description": "Render timestamps in seconds. Defaults to anticipation, middle and decay samples."
    },
    "project": {
      "type": "object",
      "description": "Complete editable project JSON. Read gripforge_vfx_project_schema for the format and a working example.",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Explicit workspace id. The key must have access to this workspace; never infer another user’s workspace."
    },
    "idempotency_key": {
      "type": "string",
      "maxLength": 160,
      "minLength": 8
    },
    "expected_revision": {
      "type": "integer",
      "maximum": 9007199254740991,
      "exclusiveMinimum": 0
    }
  }
}
gripforge_vfx_project_write annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_vfx_project_render — Render actual VFX frames for inspection
Advertised by the server during the last successful anonymous check.

ADMIN ONLY. Queue a durable render of an owned id OR an unsaved project at 1–4 timestamps. Returns job_id immediately. Poll gripforge_generation_read with include_preview for the actual rendered image, coverage, clipping and shader diagnostics. Uses the shared GripForge SceneViewport. Saves preview evidence only, no project revision. Requires workspace write access because the job and preview consume storage. Render timings are not browser FPS.

gripforge_vfx_project_render input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "id": {
      "type": "string",
      "pattern": "^lib_[A-Za-z0-9_-]+$"
    },
    "times": {
      "type": "array",
      "items": {
        "type": "number",
        "maximum": 12,
        "minimum": 0
      },
      "maxItems": 4,
      "minItems": 1,
      "description": "Render timestamps in seconds. Defaults to anticipation, middle and decay samples."
    },
    "project": {
      "type": "object",
      "description": "Complete editable project JSON. Read gripforge_vfx_project_schema for the format and a working example.",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Explicit workspace id. The key must have access to this workspace; never infer another user’s workspace."
    },
    "idempotency_key": {
      "type": "string",
      "maxLength": 160,
      "minLength": 8
    }
  }
}
gripforge_vfx_project_render annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_vfx_project_review — Review an existing work revision
Advertised by the server during the last successful anonymous check.

ADMIN ONLY. Queue a fresh GripForge capture and independent visual review without writing another source revision. Poll gripforge_generation_read; inspect its preview, then explicitly promote if approved.

gripforge_vfx_project_review input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "id",
    "expected_revision"
  ],
  "properties": {
    "id": {
      "type": "string",
      "pattern": "^lib_[A-Za-z0-9_-]+$"
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Explicit workspace id. The key must have access to this workspace; never infer another user’s workspace."
    },
    "idempotency_key": {
      "type": "string",
      "maxLength": 160,
      "minLength": 8
    },
    "expected_revision": {
      "type": "integer",
      "maximum": 9007199254740991,
      "exclusiveMinimum": 0
    }
  }
}
gripforge_vfx_project_review annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_vfx_project_promote — Set the visually approved VFX version
Advertised by the server during the last successful anonymous check.

ADMIN ONLY. Explicitly promote work after a trusted positive review matching this source, dependencies and renderer. expectedCurrent is the existing validated revision, or null.

gripforge_vfx_project_promote input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "id",
    "revision",
    "expectedCurrent"
  ],
  "properties": {
    "id": {
      "type": "string",
      "pattern": "^lib_[A-Za-z0-9_-]+$"
    },
    "revision": {
      "type": "integer",
      "maximum": 9007199254740991,
      "exclusiveMinimum": 0
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Explicit workspace id. The key must have access to this workspace; never infer another user’s workspace."
    },
    "expectedCurrent": {
      "anyOf": [
        {
          "type": "integer",
          "maximum": 9007199254740991,
          "exclusiveMinimum": 0
        },
        {
          "type": "null"
        }
      ]
    }
  }
}
gripforge_vfx_project_promote annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_vfx_project_generate — Create, render and refine a custom VFX
Advertised by the server during the last successful anonymous check.
Open-world

ADMIN ONLY. Text/image -> durable generation job -> original geometry/shaders -> actual GripForge rendering -> visual critique/correction -> workspace work revision. Returns immediately with job_id, status_url and studio_url. Poll gripforge_generation_read, then open its source_url to inspect the saved source and review. Closing the request does not cancel the job. Completed steps survive worker restart. Pass id + expected_revision to refine; image_id must belong to this workspace. A visually rejected candidate never replaces the validated version.

gripforge_vfx_project_generate input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "id": {
      "type": "string",
      "pattern": "^lib_[A-Za-z0-9_-]+$"
    },
    "look": {
      "enum": [
        "stylized",
        "painted",
        "toon",
        "anime",
        "realistic",
        "lowpoly",
        "pixel"
      ],
      "type": "string",
      "description": "Rendering look, separate from the game style: stylized (neutral) | painted | toon | anime | realistic | lowpoly | pixel. Old values (handpainted, cartoon, low_poly…) are read as aliases. Omit for the style default."
    },
    "prompt": {
      "type": "string",
      "maxLength": 2000
    },
    "image_id": {
      "type": "string",
      "pattern": "^lib_[A-Za-z0-9_-]+$"
    },
    "image_data": {
      "type": "string",
      "maxLength": 12582912
    },
    "image_mode": {
      "enum": [
        "spatial",
        "animated-artwork"
      ],
      "type": "string",
      "description": "Default spatial: build a 3D effect. animated-artwork explicitly opts into a flat animated illustration."
    },
    "visual_style": {
      "enum": [
        "stylized",
        "painted",
        "toon",
        "anime",
        "realistic",
        "lowpoly",
        "pixel"
      ],
      "type": "string",
      "description": "Rendering look of the effect (same vocabulary as look). Default stylized."
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Explicit workspace id. The key must have access to this workspace; never infer another user’s workspace."
    },
    "idempotency_key": {
      "type": "string",
      "maxLength": 160,
      "minLength": 8
    },
    "expected_revision": {
      "type": "integer",
      "maximum": 9007199254740991,
      "exclusiveMinimum": 0
    }
  }
}
gripforge_vfx_project_generate annotations
{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_vehicle_doors — Open or close vehicle doors in the Studio
Advertised by the server during the last successful anonymous check.

Save an independent door pose on one prepared vehicle instance in a saved scene. doors maps Door_FL/FR/RL/RR to 0 (closed)..1 (open). Unspecified doors retain their state; null clears the manual pose. Requires exact expectedRevision and named hinges/portable clips from prepare_vehicle. Pauses the global animation for manual control. Preserves the source asset, transforms, other instances and validated versions. Returns the actual Studio link. No generation charge.

gripforge_vehicle_doors input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "id",
    "expectedRevision",
    "nodeId",
    "doors"
  ],
  "properties": {
    "id": {
      "type": "string",
      "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
    },
    "doors": {
      "anyOf": [
        {
          "type": "object",
          "propertyNames": {
            "type": "string",
            "pattern": "^Door_[FR][LR]$"
          },
          "additionalProperties": {
            "type": "number",
            "maximum": 1,
            "minimum": 0
          }
        },
        {
          "type": "null"
        }
      ]
    },
    "nodeId": {
      "type": "string",
      "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Returned scene links open this workspace."
    },
    "expectedRevision": {
      "type": "integer",
      "maximum": 9007199254740991,
      "exclusiveMinimum": 0
    }
  }
}
gripforge_vehicle_doors annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_prepare_vehicle — Prepare segmented vehicle hinges in Blender
Advertised by the server during the last successful anonymous check.

Durable Blender preparation of an owned static segmented GLB. Map each Door_FL/FR/RL/RR or Wheel_FL/FR/RL/RR to exact mesh node names from the segmentation report. Keeps geometry placement, UVs and PBR; normalizes +Z forward/metres using yaw and length; adds hinge origins, seat/entry sockets and portable GLB open/close/preview clips. Optional hinge coordinates are in normalized vehicle metres. thickness adds an inward door shell, not a full cabin. Optional cuts provide strictly convex door outlines [forwardZ,heightY] and depth [near,far] measured from the centre on that side, in normalized metres. cuts[].meshes restricts each cut to exact exterior/glazing meshes so seats and dashboard cannot be cut. removeMeshes discards explicitly named obsolete trim in the work copy only. Optional clearanceDepthM clears scoped inner walls behind the door skin; trim adds measured body frames, seals and moulded cards below cardTopY. framePoints follows outline in normalized [x,y,z]. Optional trim.fitToSurface projects frames, seals and the inner card onto only the explicitly selected opaque door skin, preserving the supplied outline. attachments adds scoped [min,max] [x,y,z] volumes for mirrors extending beyond the door profile. Blender cuts those explicit profiles while interpolating UVs. Does not infer outlines or guarantee clearance. Returns job_id, new private work GLB, Blender source and animated Studio review link. 0 credits; storage applies. Inspect before replacement.

gripforge_prepare_vehicle input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "source"
  ],
  "properties": {
    "yaw": {
      "type": "number",
      "maximum": 180,
      "minimum": -180
    },
    "cuts": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "role",
          "outline",
          "depth"
        ],
        "properties": {
          "role": {
            "enum": [
              "Door_FL",
              "Door_FR",
              "Door_RL",
              "Door_RR"
            ],
            "type": "string"
          },
          "trim": {
            "type": "object",
            "required": [
              "framePoints"
            ],
            "properties": {
              "cardTopY": {
                "type": "number"
              },
              "cardColor": {
                "type": "array",
                "prefixItems": [
                  {
                    "type": "number",
                    "maximum": 1,
                    "minimum": 0
                  },
                  {
                    "type": "number",
                    "maximum": 1,
                    "minimum": 0
                  },
                  {
                    "type": "number",
                    "maximum": 1,
                    "minimum": 0
                  }
                ]
              },
              "cardInsetM": {
                "type": "number",
                "maximum": 0.12,
                "minimum": 0.01
              },
              "framePoints": {
                "type": "array",
                "items": {
                  "type": "array",
                  "prefixItems": [
                    {
                      "type": "number"
                    },
                    {
                      "type": "number"
                    },
                    {
                      "type": "number"
                    }
                  ]
                },
                "maxItems": 12,
                "minItems": 3
              },
              "sealRadiusM": {
                "type": "number",
                "maximum": 0.02,
                "minimum": 0.002
              },
              "fitToSurface": {
                "type": "boolean"
              },
              "frameRadiusM": {
                "type": "number",
                "maximum": 0.04,
                "minimum": 0.003
              }
            }
          },
          "depth": {
            "type": "array",
            "prefixItems": [
              {
                "type": "number"
              },
              {
                "type": "number"
              }
            ]
          },
          "meshes": {
            "type": "array",
            "items": {
              "type": "string",
              "maxLength": 160,
              "minLength": 1
            },
            "maxItems": 128,
            "minItems": 1
          },
          "outline": {
            "type": "array",
            "items": {
              "type": "array",
              "prefixItems": [
                {
                  "type": "number"
                },
                {
                  "type": "number"
                }
              ]
            },
            "maxItems": 12,
            "minItems": 3
          },
          "attachments": {
            "type": "array",
            "items": {
              "type": "object",
              "required": [
                "bounds",
                "meshes"
              ],
              "properties": {
                "bounds": {
                  "type": "array",
                  "prefixItems": [
                    {
                      "type": "array",
                      "prefixItems": [
                        {
                          "type": "number"
                        },
                        {
                          "type": "number"
                        },
                        {
                          "type": "number"
                        }
                      ]
                    },
                    {
                      "type": "array",
                      "prefixItems": [
                        {
                          "type": "number"
                        },
                        {
                          "type": "number"
                        },
                        {
                          "type": "number"
                        }
                      ]
                    }
                  ]
                },
                "meshes": {
                  "type": "array",
                  "items": {
                    "type": "string",
                    "maxLength": 160,
                    "minLength": 1
                  },
                  "maxItems": 128,
                  "minItems": 1
                }
              }
            },
            "maxItems": 4
          },
          "clearanceDepthM": {
            "type": "number",
            "maximum": 3,
            "minimum": 0
          }
        }
      },
      "maxItems": 4
    },
    "parts": {
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {
        "type": "array",
        "items": {
          "type": "string",
          "maxLength": 160,
          "minLength": 1
        },
        "maxItems": 64,
        "minItems": 1
      }
    },
    "hinges": {
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {
        "type": "array",
        "prefixItems": [
          {
            "type": "number"
          },
          {
            "type": "number"
          },
          {
            "type": "number"
          }
        ]
      }
    },
    "length": {
      "type": "number",
      "maximum": 7,
      "minimum": 2.8
    },
    "source": {
      "type": "object",
      "required": [
        "assetId",
        "revisionId"
      ],
      "properties": {
        "assetId": {
          "type": "string",
          "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
        },
        "fileRole": {
          "type": "string",
          "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
        },
        "revisionId": {
          "type": "string",
          "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
        }
      }
    },
    "openAngle": {
      "type": "number",
      "maximum": 85,
      "minimum": 20
    },
    "thickness": {
      "type": "number",
      "maximum": 0.04,
      "minimum": 0
    },
    "removeMeshes": {
      "type": "array",
      "items": {
        "type": "string",
        "maxLength": 160,
        "minLength": 1
      },
      "maxItems": 128
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Returned scene links open this workspace."
    },
    "idempotency_key": {
      "type": "string",
      "maxLength": 160,
      "minLength": 8
    }
  }
}
gripforge_prepare_vehicle annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_vehicle_schema — Modular vehicle manufacturing contract
Advertised by the server during the last successful anonymous check.
Advertised read-only

Read the concept-first vehicle recipe, canonical parts, hinge convention, limits, quotes and revision workflow.

gripforge_vehicle_schema input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Returned scene links open this workspace."
    }
  }
}
gripforge_vehicle_schema annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_generate_vehicle — Generate a vehicle from reviewed multi-view references
Advertised by the server during the last successful anonymous check.

Read vehicle_schema first. Recommended recipe.workflow=body_wheels follows concept → references (five wheel-less body views + wheel) → geometry (stop/review) → topology (stop/review) → build (PBR + wheel + rig). Each geometry review uses scene_review with the returned assetRef and must be approved before the next paid step. Rigging preserves UVs and corner normals, GLB/FBX/Blend and measured Chaos setup. Top view is review-only. parts.body.geometry accepts unfinished Hunyuan/Blender GLB; parts.body.topology pins the reviewed reduced GLB; parts.<role>.source reuses finished meshes. Legacy modular_doors remains available for articulated doors. stage=plan quotes each stage without spending; paid stages require its budget. Durable job; poll generation_read. Work draft, real-render review and target-engine driving test required; no automatic publication/replacement.

gripforge_generate_vehicle input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "recipe"
  ],
  "properties": {
    "stage": {
      "enum": [
        "plan",
        "concept",
        "references",
        "geometry",
        "topology",
        "build"
      ],
      "type": "string",
      "default": "plan"
    },
    "budget": {
      "type": "object",
      "properties": {
        "usd": {
          "type": "number",
          "minimum": 0
        },
        "credits": {
          "type": "integer",
          "maximum": 9007199254740991,
          "minimum": 0
        }
      }
    },
    "recipe": {
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Returned scene links open this workspace."
    },
    "idempotency_key": {
      "type": "string",
      "maxLength": 160,
      "minLength": 8
    }
  }
}
gripforge_generate_vehicle annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_vehicle_segment — Separate an existing vehicle with Tripo
Advertised by the server during the last successful anonymous check.

Quote then queue one durable Tripo v2 semantic segmentation of an owned immutable GLB, including Meshy or Blender sources. stage=plan is free; stage=build requires quoted budget. 40 Tripo provider credits, distinct from the GripForge quote. Returns job_id; inspect parts and texture preservation in generation_read. No automatic completion, retexture, articulation, publication or replacement. A segmented output still needs hinge preparation.

gripforge_vehicle_segment input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "source"
  ],
  "properties": {
    "stage": {
      "enum": [
        "plan",
        "build"
      ],
      "type": "string",
      "default": "plan"
    },
    "budget": {
      "type": "object",
      "properties": {
        "usd": {
          "type": "number",
          "minimum": 0
        },
        "credits": {
          "type": "integer",
          "maximum": 9007199254740991,
          "minimum": 0
        }
      }
    },
    "source": {
      "type": "object",
      "required": [
        "assetId",
        "revisionId"
      ],
      "properties": {
        "assetId": {
          "type": "string",
          "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
        },
        "fileRole": {
          "type": "string",
          "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
        },
        "revisionId": {
          "type": "string",
          "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
        }
      }
    },
    "granularity": {
      "enum": [
        "simple",
        "balanced",
        "detailed"
      ],
      "type": "string"
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Returned scene links open this workspace."
    },
    "idempotency_key": {
      "type": "string",
      "maxLength": 160,
      "minLength": 8
    }
  }
}
gripforge_vehicle_segment annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_map_import_unreal_schema — Unreal to Studio import contract
Advertised by the server during the last successful anonymous check.
Advertised read-only

Read the native export → binary upload → persistent map import workflow, limits and explicit conversion caveats. Native extraction requires the local MCP and an installed Unreal editor. Hosted MCP/API consume the resulting portable SceneDocument; they cannot read your local .umap/.uasset files.

gripforge_map_import_unreal_schema input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Returned scene links open this workspace."
    }
  }
}
gripforge_map_import_unreal_schema annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_map_import_unreal — Import a portable Unreal scene
Advertised by the server during the last successful anonymous check.

Queue a persistent import of schema gripforge.unreal-studio-import.v1. Upload files via local gripforge_map_unreal_upload_local or POST /api/v1/maps/import/unreal/assets first. document is a common SceneDocument with workspace-owned immutable assets, separate props, static foliage patches and editable terrain. source={engine:unreal,level:/Game/...,sha256,warnings:[]}. Returns job_id; poll generation_read for studio_url. Always a NEW private work scene; no overwrite, automatic validation or Community publication. 0 credits; storage quota applies.

gripforge_map_import_unreal input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "schema",
    "document",
    "source"
  ],
  "properties": {
    "schema": {
      "type": "string",
      "const": "gripforge.unreal-studio-import.v1"
    },
    "source": {
      "type": "object",
      "required": [
        "engine",
        "level",
        "sha256",
        "warnings"
      ],
      "properties": {
        "level": {
          "type": "string",
          "pattern": "^\\/Game(?:\\/[\\w-]+)+$"
        },
        "engine": {
          "type": "string",
          "const": "unreal"
        },
        "sha256": {
          "type": "string",
          "pattern": "^[a-f0-9]{64}$"
        },
        "warnings": {
          "type": "array",
          "items": {
            "type": "string",
            "maxLength": 2000
          },
          "maxItems": 100
        }
      }
    },
    "document": {
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Returned scene links open this workspace."
    },
    "idempotency_key": {
      "type": "string",
      "maxLength": 160,
      "minLength": 8
    }
  }
}
gripforge_map_import_unreal annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_flexible_weapon_schema — Flexible weapon manufacturing recipes
Advertised by the server during the last successful anonymous check.
Advertised read-only

Read the bounded recipe and concept-first workflow for Meshy + Blender flexible weapons, costs, pinned component reuse and source animation requirements.

gripforge_flexible_weapon_schema input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Returned scene links open this workspace."
    }
  }
}
gripforge_flexible_weapon_schema annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_generate_flexible_weapon — Generate an articulated flexible weapon
Advertised by the server during the last successful anonymous check.

Persistent concept → isolated handle/segment references → Meshy PBR components → FlexibleChain XPBD → Blender assembly/rig → actual GripForge renderer review. Read flexible_weapon_schema first. recipe stage=concept returns an image before 3D; build can reuse that concept and owned pinned components. Up to 12 existing source clips or sampled motions; character choreography is not generated by this tool. Returns job_id immediately; poll generation_read for weapon GLB, Blender source, physics reports, separate character/weapon review scene and Studio links. Max 23 credits when all art is new; reused components are free. Cancel/retry retains successful provider and fabrication steps. Always private work: no automatic replacement, promotion or Community publication.

gripforge_generate_flexible_weapon input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "recipe"
  ],
  "properties": {
    "recipe": {
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Returned scene links open this workspace."
    },
    "idempotency_key": {
      "type": "string",
      "maxLength": 160,
      "minLength": 8
    }
  }
}
gripforge_generate_flexible_weapon annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_flexible_chain_schema — Flexible chain recipes and examples
Advertised by the server during the last successful anonymous check.
Advertised read-only

Read the bounded recipe schema for the shared FlexibleChain solver. Presets: whip, rope, tail. Input can follow an exact named mount in a pinned GLB animation or sampled world-space motion. Includes units, collision capsules, limits and a runnable example.

gripforge_flexible_chain_schema input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Returned scene links open this workspace."
    }
  }
}
gripforge_flexible_chain_schema annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_flexible_chain — Simulate and bake a flexible chain
Advertised by the server during the last successful anonymous check.

Queue a persistent 240 Hz XPBD simulation using GripForge Scene Engine. Read flexible_chain_schema first. recipe version=1: preset whip|rope|tail, duration<=10s, fps=30|60, physics {length,segments,damping,bendCompliance,gravity,radius,floor,iterations}; choose motion [{time,position,direction,capsules}] OR source {asset:{assetId,revisionId},clip,mount_node,offset,axis,colliders}. Source assets are immutable and workspace-scoped. Returns a job ID; poll generation_read for a new draft skinned-chain GLB, sampled joints, recipe, physics metrics and Character Studio link. This is a neutral physics preview, not a Meshy weapon redesign or automatic rebind of the source weapon. No runtime world collision or seamless loop guarantee. Cancel/retry keeps completed steps. Does not replace or visually validate an existing asset. 0 credits; storage quota applies.

gripforge_flexible_chain input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "recipe"
  ],
  "properties": {
    "recipe": {
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Returned scene links open this workspace."
    },
    "idempotency_key": {
      "type": "string",
      "maxLength": 160,
      "minLength": 8
    }
  }
}
gripforge_flexible_chain annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_armor_generate — Generate a modular armor kit
Advertised by the server during the last successful anonymous check.

Queue a durable armor-kit job: one shared concept, isolated Imagine references, Meshy PBR models, bounded Blender interior preparation and paired GLB exports, then actual GripForge wearer review. Types: helmet, chest, belt, pauldron, bracer, glove, thigh, greave, boot, upperarm, gorget, tasset, undersuit. coverage=full adds a durable anatomical decomposition of the concept, rejects missing planned roles before mesh generation and records per-instance coverage fits. A piece count alone never proves body coverage. The optional undersuit is a locally manufactured adaptive textile which retains each wearer’s skin weights. Meshy pieces cost 11 credits per canonical type; the textile has no image/mesh charge. A new concept costs 1 credit; mirrors are included. concept_item must be an owned Library image. source_kit + explicit pieces regenerates only those types into a NEW work kit and pins unchanged pieces. Closing the call/page does not cancel. Poll gripforge_generation_read. Success is a work version, never automatic visual approval. The result includes a Grip Studio link, review scene, concepts, source models and Blender source.

gripforge_armor_generate input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "prompt"
  ],
  "properties": {
    "name": {
      "type": "string",
      "maxLength": 100
    },
    "pieces": {
      "type": "array",
      "items": {
        "enum": [
          "helmet",
          "chest",
          "belt",
          "pauldron",
          "bracer",
          "glove",
          "thigh",
          "greave",
          "boot",
          "upperarm",
          "gorget",
          "tasset",
          "undersuit"
        ],
        "type": "string"
      },
      "maxItems": 13,
      "minItems": 1
    },
    "prompt": {
      "type": "string",
      "maxLength": 2000,
      "minLength": 3
    },
    "coverage": {
      "enum": [
        "modular",
        "full"
      ],
      "type": "string"
    },
    "polycount": {
      "type": "integer",
      "maximum": 30000,
      "minimum": 3000
    },
    "source_kit": {
      "type": "string",
      "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
    },
    "concept_item": {
      "type": "string",
      "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Returned scene links open this workspace."
    },
    "textile_color": {
      "type": "string",
      "pattern": "^#[a-fA-F0-9]{6}$"
    },
    "character_items": {
      "type": "array",
      "items": {
        "type": "string",
        "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
      },
      "maxItems": 3
    },
    "idempotency_key": {
      "type": "string",
      "maxLength": 160,
      "minLength": 8
    }
  }
}
gripforge_armor_generate annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_armor_read — Read a modular armor kit
Advertised by the server during the last successful anonymous check.
Advertised read-only

Read an owned kit manifest, semantic slots and immutable piece revisions. Equipment and instances remain independent. Returns the Grip Studio link. To correct selected types, call gripforge_armor_generate with source_kit and pieces.

gripforge_armor_read input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "id"
  ],
  "properties": {
    "id": {
      "type": "string",
      "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Returned scene links open this workspace."
    }
  }
}
gripforge_armor_read annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_armor_repair — Repair unfinished armor pieces
Advertised by the server during the last successful anonymous check.

Fork a failed/cancelled armor job into a new work kit. Preserve completed pieces and the exact shared concept; recreate only unfinished types by default. Optional pieces chooses types explicitly. Use prompt for targeted corrections. Original checkpoints and artifacts remain intact. Costs 11 credits per regenerated canonical type (plus a concept credit only if none survived). Use generation_retry instead for a transient provider or worker error to reuse the exact same steps without another charge.

gripforge_armor_repair input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "source_job"
  ],
  "properties": {
    "pieces": {
      "type": "array",
      "items": {
        "enum": [
          "helmet",
          "chest",
          "belt",
          "pauldron",
          "bracer",
          "glove",
          "thigh",
          "greave",
          "boot",
          "upperarm",
          "gorget",
          "tasset",
          "undersuit"
        ],
        "type": "string"
      },
      "maxItems": 13,
      "minItems": 1
    },
    "prompt": {
      "type": "string",
      "maxLength": 2000,
      "minLength": 3
    },
    "source_job": {
      "type": "string",
      "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Returned scene links open this workspace."
    },
    "idempotency_key": {
      "type": "string",
      "maxLength": 160,
      "minLength": 8
    }
  }
}
gripforge_armor_repair annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_map_import — Migrate a saved terrain map
Advertised by the server during the last successful anonymous check.

Queue a one-time materialization of an owned legacy terrain map into the shared Scene Engine. Preserve the saved spec, seed, resolution, family replacements, placed assets and removed props. Completed jobs return a canonical Studio link; source edits during migration cause a conflict rather than data loss.

gripforge_map_import input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "id"
  ],
  "properties": {
    "id": {
      "type": "string",
      "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Returned scene links open this workspace."
    }
  }
}
gripforge_map_import annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_map_schema — Map concept and generation workflow
Advertised by the server during the last successful anonymous check.
Advertised read-only

Read the concept-first map workflow, immutable image reference format, costs and an example. Concepts, map work scenes and external engine delivery are separate steps.

gripforge_map_schema input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Returned scene links open this workspace."
    }
  }
}
gripforge_map_schema annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_map_generate — Create map concept views or an editable map
Advertised by the server during the last successful anonymous check.

Queue a persistent map job. stage=concept creates a private master overview plus optional views and stops. views: overview,top_down,entrance,objective. All additional views are conditioned on the SAME pinned master; they are illustrations, not exact 3D renders. reference is an environment screenshot for a NEW layout. To add views to an existing concept, pass source_concept instead; the master is kept unchanged and is free. One credit per new image (full new 4-view set = 4); default is overview only. Poll generation_read with include_preview=true to see the views. After the user selects the concept, submit stage=build with the returned concept and a new idempotency key. Build costs 1 credit and is the default for existing callers; legacy concept_item accepts a Library image ID, while concept pins its exact version. wizard: look stylized|painted|toon|anime|realistic|lowpoly|pixel (rendering, separate from style; omit for the theme default); style realistic|stylized|lowpoly|handpainted (legacy wording); world open_world|closed_arena|dungeon|linear|battle_map; terrain auto|plains|desert_canyon|forest|snow|island|volcanic; size small|medium|large; boundary fixed|infinite (open edge, finite terrain); spawn single|teams; teams 2|4; boss,safeZone,extraction booleans. sources selects catalog/workspace/community props. Build uses the common Scene Engine with independent terrain, regions, paths, zones and asset instances. Cancel/retry keeps successful images and billing. No automatic visual validation, promotion or Unreal import.

gripforge_map_generate input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "prompt",
    "wizard"
  ],
  "properties": {
    "seed": {
      "type": "integer",
      "maximum": 2147483647,
      "minimum": -2147483647
    },
    "stage": {
      "enum": [
        "concept",
        "build"
      ],
      "type": "string"
    },
    "views": {
      "type": "array",
      "items": {
        "enum": [
          "overview",
          "top_down",
          "entrance",
          "objective"
        ],
        "type": "string"
      },
      "maxItems": 4,
      "minItems": 1,
      "description": "Unique requested views, stage=concept only. The master overview is always included; omitting views keeps overview only."
    },
    "prompt": {
      "type": "string",
      "maxLength": 4000,
      "minLength": 3
    },
    "wizard": {
      "type": "object",
      "properties": {
        "boss": {
          "type": "boolean"
        },
        "look": {
          "enum": [
            "stylized",
            "painted",
            "toon",
            "anime",
            "realistic",
            "lowpoly",
            "pixel"
          ],
          "type": "string",
          "description": "Rendering look, separate from the game style: stylized (neutral) | painted | toon | anime | realistic | lowpoly | pixel. Old values (handpainted, cartoon, low_poly…) are read as aliases. Omit for the style default. Map: the theme gives the biome, the look the materials (LevelSpec.look)."
        },
        "size": {
          "enum": [
            "small",
            "medium",
            "large"
          ],
          "type": "string"
        },
        "spawn": {
          "enum": [
            "single",
            "teams"
          ],
          "type": "string"
        },
        "style": {
          "enum": [
            "realistic",
            "stylized",
            "lowpoly",
            "handpainted"
          ],
          "type": "string",
          "description": "Legacy wording kept in the intent; it does not change the rendering. Use look."
        },
        "teams": {
          "anyOf": [
            {
              "type": "number",
              "const": 2
            },
            {
              "type": "number",
              "const": 4
            }
          ]
        },
        "world": {
          "enum": [
            "open_world",
            "closed_arena",
            "dungeon",
            "linear",
            "battle_map"
          ],
          "type": "string"
        },
        "terrain": {
          "enum": [
            "auto",
            "plains",
            "desert_canyon",
            "forest",
            "snow",
            "island",
            "volcanic"
          ],
          "type": "string"
        },
        "boundary": {
          "enum": [
            "fixed",
            "infinite"
          ],
          "type": "string"
        },
        "safeZone": {
          "type": "boolean"
        },
        "dimensions": {
          "type": "object",
          "required": [
            "width",
            "depth"
          ],
          "properties": {
            "depth": {
              "type": "number",
              "maximum": 5000,
              "minimum": 100
            },
            "width": {
              "type": "number",
              "maximum": 5000,
              "minimum": 100
            }
          },
          "description": "Explicit ground footprint in metres. Overrides size presets and world multipliers. Example: {width:500,depth:500}. Four-team maps require a square."
        },
        "extraction": {
          "type": "boolean"
        }
      },
      "additionalProperties": {}
    },
    "concept": {
      "type": "object",
      "required": [
        "assetId",
        "revisionId"
      ],
      "properties": {
        "assetId": {
          "type": "string",
          "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
        },
        "fileRole": {
          "type": "string",
          "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
        },
        "revisionId": {
          "type": "string",
          "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
        }
      },
      "description": "Exact chosen concept revision for stage=build. Mutually exclusive with concept_item."
    },
    "sources": {
      "type": "array",
      "items": {
        "enum": [
          "catalog",
          "workspace",
          "community"
        ],
        "type": "string"
      },
      "maxItems": 3,
      "minItems": 1
    },
    "reference": {
      "type": "object",
      "required": [
        "assetId",
        "revisionId"
      ],
      "properties": {
        "assetId": {
          "type": "string",
          "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
        },
        "fileRole": {
          "type": "string",
          "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
        },
        "revisionId": {
          "type": "string",
          "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
        }
      },
      "description": "Pinned source-environment screenshot for stage=concept only. Upload to Library and pin first."
    },
    "structure": {
      "type": "object",
      "description": "Optional explicit gripforge.map-structures.v1 plan for stage=build: terraces with polygon/elevation and separate ramp/bridge connections. Read gripforge_map_schema for the contract. Preserves canyon voids; validates bridge clearance, endpoints and slopes. Uses durable per-piece assets and the common SceneDocument. Dimensions must match wizard.dimensions. Solo maps only; result is a structural work version requiring visual review.",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "concept_item": {
      "type": "string",
      "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$",
      "description": "Legacy Library concept image ID. Prefer an immutable concept reference."
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Returned scene links open this workspace."
    },
    "source_concept": {
      "type": "object",
      "required": [
        "assetId",
        "revisionId"
      ],
      "properties": {
        "assetId": {
          "type": "string",
          "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
        },
        "fileRole": {
          "type": "string",
          "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
        },
        "revisionId": {
          "type": "string",
          "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
        }
      },
      "description": "Existing immutable master to add views to, stage=concept only. Mutually exclusive with reference; never regenerate this master."
    },
    "idempotency_key": {
      "type": "string",
      "maxLength": 160,
      "minLength": 8
    }
  }
}
gripforge_map_generate annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_scene_modify — Modify a selection with AI
Advertised by the server during the last successful anonymous check.

Queue a scoped edit of saved scene nodes or a region. The server derives the allowed scope and preserves locks, gameplay zones, outside geometry and the last validated revision. Blender may fabricate missing assets. The result is a proposal requiring explicit application, never a silently replaced map.

gripforge_scene_modify input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "id",
    "expectedRevision",
    "nodeIds",
    "prompt"
  ],
  "properties": {
    "id": {
      "type": "string",
      "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
    },
    "prompt": {
      "type": "string",
      "maxLength": 4000,
      "minLength": 3
    },
    "nodeIds": {
      "type": "array",
      "items": {
        "type": "string",
        "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
      },
      "maxItems": 100,
      "minItems": 1
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Returned scene links open this workspace."
    },
    "blendDistance": {
      "type": "number",
      "maximum": 1000,
      "exclusiveMinimum": 0
    },
    "idempotency_key": {
      "type": "string",
      "maxLength": 160,
      "minLength": 8
    },
    "expectedRevision": {
      "type": "integer",
      "maximum": 9007199254740991,
      "exclusiveMinimum": 0
    }
  }
}
gripforge_scene_modify annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_scene_proposals — List proposed scene edits
Advertised by the server during the last successful anonymous check.
Advertised read-only

List persistent proposals and their base revision, status and descriptions.

gripforge_scene_proposals input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "id"
  ],
  "properties": {
    "id": {
      "type": "string",
      "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Returned scene links open this workspace."
    }
  }
}
gripforge_scene_proposals annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_scene_proposal_read — Read a proposed scene edit
Advertised by the server during the last successful anonymous check.
Advertised read-only

Read the original scene, proposed document and scoped commands. Use the Studio link to inspect actual rendering before applying.

gripforge_scene_proposal_read input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "id",
    "proposal"
  ],
  "properties": {
    "id": {
      "type": "string",
      "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
    },
    "proposal": {
      "type": "string",
      "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Returned scene links open this workspace."
    }
  }
}
gripforge_scene_proposal_read annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_scene_proposal_apply — Apply a reviewed proposal to work
Advertised by the server during the last successful anonymous check.

Explicitly accept or discard a proposal after inspecting it. Accept requires expectedRevision to match the exact base and current work revision. Atomic: concurrent changes or discard abort the save. Creates work, never promotes validated.

gripforge_scene_proposal_apply input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "id",
    "proposal",
    "action"
  ],
  "properties": {
    "id": {
      "type": "string",
      "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
    },
    "action": {
      "enum": [
        "accept",
        "discard"
      ],
      "type": "string"
    },
    "proposal": {
      "type": "string",
      "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Returned scene links open this workspace."
    },
    "expectedRevision": {
      "type": "integer",
      "maximum": 9007199254740991,
      "exclusiveMinimum": 0
    }
  }
}
gripforge_scene_proposal_apply annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_scene_schema — Shared scene engine format
Advertised by the server during the last successful anonymous check.
Advertised read-only

Start here. Read the shared scene model, kinds, commands, limits and an editable example. Assets are immutable revisions; placed objects are independent instances. Scene saves create work revisions, never automatic visual approval.

gripforge_scene_schema input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Returned scene links open this workspace."
    }
  }
}
gripforge_scene_schema annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_scene_realism — Shared materials, automotive lighting and post-processing
Advertised by the server during the last successful anonymous check.

Apply reusable architectural surface profiles and GTAO to a saved work scene. Read gripforge_scene_schema.realism first. assignments [{nodeId,material:"*" or a named slot,surface:{preset:preserve|brick|stone|metal|glass,detail:0..1,weathering:0..1,regions:[]}}]; surface:null removes only this local profile. Optional glass regions use explicit normalized mesh-local min/max bounds and interior parallax settings. Never guess masks from colours. ambientOcclusion {enabled,radius:0.02..3 metres,intensity:0..1,quality:low|medium|high}, or null to remove. Preserves transforms, source PBR maps, other instances and validated revisions. Returns Studio link for visual comparison. Optional quality {preset:performance|balanced|quality,resolutionScale:0.5..1,sharpness:0..0.5}, or null to restore the original presentation. Quality supports viewport resolution up to a bounded 4K budget. Optional automotive {look:studio|daylight,quality,lengthM,depthOfField:false,focusDistanceM} explicitly applies a whole-scene look: HDR strip reflections, contact AO, quality and restrained post-processing. Studio replaces an existing HDRI; daylight keeps it. Optional colorGrading/depthOfField overrides or null. DOF is perspective/capture only, disabled with volumetric passes. No generation charge, DLSS or automatic approval.

gripforge_scene_realism input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "id",
    "expectedRevision"
  ],
  "properties": {
    "id": {
      "type": "string",
      "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
    },
    "quality": {
      "anyOf": [
        {
          "type": "object",
          "required": [
            "preset"
          ],
          "properties": {
            "preset": {
              "enum": [
                "performance",
                "balanced",
                "quality"
              ],
              "type": "string"
            },
            "sharpness": {
              "type": "number",
              "maximum": 0.5,
              "minimum": 0
            },
            "resolutionScale": {
              "type": "number",
              "maximum": 1,
              "minimum": 0.5
            }
          }
        },
        {
          "type": "null"
        }
      ]
    },
    "automotive": {
      "type": "object",
      "properties": {
        "look": {
          "enum": [
            "studio",
            "daylight"
          ],
          "type": "string"
        },
        "ground": {
          "type": "boolean"
        },
        "lengthM": {
          "type": "number",
          "maximum": 25,
          "minimum": 1
        },
        "quality": {
          "enum": [
            "performance",
            "balanced",
            "quality"
          ],
          "type": "string"
        },
        "depthOfField": {
          "type": "boolean"
        },
        "focusDistanceM": {
          "type": "number",
          "maximum": 1000,
          "minimum": 0.1
        }
      }
    },
    "assignments": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "nodeId",
          "surface"
        ],
        "properties": {
          "nodeId": {
            "type": "string",
            "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
          },
          "surface": {
            "anyOf": [
              {
                "type": "object",
                "propertyNames": {
                  "type": "string"
                },
                "additionalProperties": {}
              },
              {
                "type": "null"
              }
            ]
          },
          "material": {
            "type": "string",
            "maxLength": 256,
            "minLength": 1
          }
        }
      },
      "maxItems": 100
    },
    "colorGrading": {
      "anyOf": [
        {
          "type": "object",
          "required": [
            "contrast",
            "saturation",
            "temperature"
          ],
          "properties": {
            "contrast": {
              "type": "number",
              "maximum": 1.5,
              "minimum": 0.5
            },
            "saturation": {
              "type": "number",
              "maximum": 1.5,
              "minimum": 0
            },
            "temperature": {
              "type": "number",
              "maximum": 1,
              "minimum": -1
            }
          }
        },
        {
          "type": "null"
        }
      ]
    },
    "depthOfField": {
      "anyOf": [
        {
          "type": "object",
          "required": [
            "enabled",
            "focusDistanceM",
            "aperture",
            "maxBlur"
          ],
          "properties": {
            "enabled": {
              "type": "boolean"
            },
            "maxBlur": {
              "type": "number",
              "maximum": 0.02,
              "minimum": 0
            },
            "aperture": {
              "type": "number",
              "maximum": 0.01,
              "minimum": 0
            },
            "focusDistanceM": {
              "type": "number",
              "maximum": 1000,
              "minimum": 0.1
            }
          }
        },
        {
          "type": "null"
        }
      ]
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Returned scene links open this workspace."
    },
    "ambientOcclusion": {
      "anyOf": [
        {
          "type": "object",
          "required": [
            "enabled",
            "radius",
            "intensity",
            "quality"
          ],
          "properties": {
            "radius": {
              "type": "number",
              "maximum": 3,
              "minimum": 0.02
            },
            "enabled": {
              "type": "boolean"
            },
            "quality": {
              "enum": [
                "low",
                "medium",
                "high"
              ],
              "type": "string"
            },
            "intensity": {
              "type": "number",
              "maximum": 1,
              "minimum": 0
            }
          }
        },
        {
          "type": "null"
        }
      ]
    },
    "expectedRevision": {
      "type": "integer",
      "maximum": 9007199254740991,
      "exclusiveMinimum": 0
    }
  }
}
gripforge_scene_realism annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_apply_realism — Orchestrate scene realism
Advertised by the server during the last successful anonymous check.

Plan or apply render.realism across shared PBR materials, immutable textures, surface shaders, lighting, post-processing, environment and skinned character rendering, with a bounded render quality and render.lod configuration suggestion. Defaults to mode=plan (no save); mode=apply writes one work revision atomically, preserving assets, transforms, animation and validated versions. Explicit nodeIds restrict instance assignments; lighting/post-processing are global. materials/characters rows use {nodeId,material:"*"|exactName,override:{roughness,metalness,map,normalMap,surface,...}}; pinned map references, null removes overrides. Characters require character/enemy/boss/fps-arms role. Does not fabricate missing detail, execute paid generation, add game LOD automatically, or approve realism visually. Request a real scene_review afterwards. WEB only; not DLSS.

gripforge_apply_realism input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "id",
    "expectedRevision"
  ],
  "properties": {
    "id": {
      "type": "string",
      "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
    },
    "mode": {
      "enum": [
        "plan",
        "apply"
      ],
      "type": "string",
      "default": "plan"
    },
    "nodeIds": {
      "type": "array",
      "items": {
        "type": "string",
        "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
      },
      "maxItems": 100,
      "minItems": 1
    },
    "quality": {
      "enum": [
        "performance",
        "balanced",
        "quality"
      ],
      "type": "string"
    },
    "lighting": {
      "enum": [
        "preserve",
        "daylight",
        "golden_hour",
        "overcast",
        "night"
      ],
      "type": "string"
    },
    "materials": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "nodeId",
          "override"
        ],
        "properties": {
          "nodeId": {
            "type": "string",
            "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
          },
          "material": {
            "type": "string",
            "maxLength": 256,
            "minLength": 1
          },
          "override": {
            "type": "object",
            "propertyNames": {
              "type": "string"
            },
            "additionalProperties": {}
          }
        }
      },
      "maxItems": 100
    },
    "characters": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "nodeId",
          "override"
        ],
        "properties": {
          "nodeId": {
            "type": "string",
            "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
          },
          "material": {
            "type": "string",
            "maxLength": 256,
            "minLength": 1
          },
          "override": {
            "type": "object",
            "propertyNames": {
              "type": "string"
            },
            "additionalProperties": {}
          }
        }
      },
      "maxItems": 100
    },
    "environment": {
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "postProcess": {
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Returned scene links open this workspace."
    },
    "expectedRevision": {
      "type": "integer",
      "maximum": 9007199254740991,
      "exclusiveMinimum": 0
    }
  }
}
gripforge_apply_realism annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_realism_schema — Read realism orchestration contract
Advertised by the server during the last successful anonymous check.
Advertised read-only

Read render.realism systems, modes, bounds and immutable-source workflow for an accessible scene.

gripforge_realism_schema input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "id"
  ],
  "properties": {
    "id": {
      "type": "string",
      "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Returned scene links open this workspace."
    }
  }
}
gripforge_realism_schema annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_scene_optimize — Prepare a scene for fast browser loading
Advertised by the server during the last successful anonymous check.

Queue resumable browser texture variants for a saved scene. Preserve original GLBs, geometry, transforms, PBR, animations and Library heads. Color textures up to 1024px, data maps up to 512px and terrain color up to 4096px; WebP encoding. Saves a new work revision only if expectedRevision still matches. Does not promote validated. Poll generation_read for byte savings and studio_url. 0 credits; storage quota applies. New Unreal imports do this automatically.

gripforge_scene_optimize input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "id",
    "expectedRevision"
  ],
  "properties": {
    "id": {
      "type": "string",
      "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Returned scene links open this workspace."
    },
    "idempotency_key": {
      "type": "string",
      "maxLength": 160,
      "minLength": 8
    },
    "expectedRevision": {
      "type": "integer",
      "maximum": 9007199254740991,
      "exclusiveMinimum": 0
    }
  }
}
gripforge_scene_optimize annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_scene_list — List workspace scenes
Advertised by the server during the last successful anonymous check.
Advertised read-only

List scenes, work/validated revision pointers and links in the authenticated workspace.

gripforge_scene_list input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Returned scene links open this workspace."
    }
  }
}
gripforge_scene_list annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_scene_read — Read scene source
Advertised by the server during the last successful anonymous check.
Advertised read-only

Read the editable SceneDocument at work, validated, or a numbered revision. Keep work_revision for optimistic writes. Validated can be absent.

gripforge_scene_read input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "id"
  ],
  "properties": {
    "id": {
      "type": "string",
      "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
    },
    "version": {
      "anyOf": [
        {
          "enum": [
            "work",
            "validated"
          ],
          "type": "string"
        },
        {
          "type": "integer",
          "maximum": 9007199254740991,
          "exclusiveMinimum": 0
        }
      ]
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Returned scene links open this workspace."
    }
  }
}
gripforge_scene_read annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_scene_create — Create a workspace scene
Advertised by the server during the last successful anonymous check.

Create a draft scene. Pin Library assets first and use returned assetId/revisionId references. The response contains a GripForge Studio link. Exporting a VFX definition must not include this test scene.

gripforge_scene_create input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "document"
  ],
  "properties": {
    "document": {
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Returned scene links open this workspace."
    }
  }
}
gripforge_scene_create annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_scene_write — Save scene work revision
Advertised by the server during the last successful anonymous check.

Save a complete SceneDocument. expectedRevision must equal the latest work revision. A 409 is a real conflict: reread before changing it. Does not change the validated revision or source Library assets.

gripforge_scene_write input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "id",
    "document",
    "expectedRevision"
  ],
  "properties": {
    "id": {
      "type": "string",
      "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
    },
    "document": {
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Returned scene links open this workspace."
    },
    "expectedRevision": {
      "type": "integer",
      "maximum": 9007199254740991,
      "exclusiveMinimum": 0
    }
  }
}
gripforge_scene_write annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_scene_patch — Edit selected scene instances
Advertised by the server during the last successful anonymous check.

Apply insert/remove/transform/replace/update commands atomically. Environment updates can configure shared 3D cloud layers (density, altitude, wind, colour and quality); see gripforge_scene_schema. Replace preserves id, transform, role, materials and attachments, and rejects incompatible named slots. Locked objects cannot be changed. Scope constrains regional edits; read the schema first.

gripforge_scene_patch input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "id",
    "baseRevision",
    "commands"
  ],
  "properties": {
    "id": {
      "type": "string",
      "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
    },
    "scope": {
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "commands": {
      "type": "array",
      "items": {
        "type": "object",
        "propertyNames": {
          "type": "string"
        },
        "additionalProperties": {}
      },
      "maxItems": 20000,
      "minItems": 1
    },
    "baseRevision": {
      "type": "integer",
      "maximum": 9007199254740991,
      "exclusiveMinimum": 0
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Returned scene links open this workspace."
    }
  }
}
gripforge_scene_patch annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_scene_versions — Scene versions and visual reviews
Advertised by the server during the last successful anonymous check.
Advertised read-only

Read work/current pointers, immutable revision history and trusted visual review evidence. A rejected or unavailable review does not change the validated version.

gripforge_scene_versions input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "id"
  ],
  "properties": {
    "id": {
      "type": "string",
      "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Returned scene links open this workspace."
    }
  }
}
gripforge_scene_versions annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_scene_review — Request an actual GripForge visual review
Advertised by the server during the last successful anonymous check.

Queue a persistent render and independent visual review of the exact saved work revision. Poll generation_read. Optional assetRef records the review on the exact isolated asset revision as well; required for vehicle geometry/topology gates. This does not promote or replace the validated version.

gripforge_scene_review input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "id",
    "expectedRevision"
  ],
  "properties": {
    "id": {
      "type": "string",
      "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
    },
    "prompt": {
      "type": "string",
      "maxLength": 4000
    },
    "assetRef": {
      "type": "object",
      "required": [
        "assetId",
        "revisionId"
      ],
      "properties": {
        "assetId": {
          "type": "string",
          "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
        },
        "fileRole": {
          "type": "string",
          "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
        },
        "revisionId": {
          "type": "string",
          "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
        }
      }
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Returned scene links open this workspace."
    },
    "idempotency_key": {
      "type": "string",
      "maxLength": 160,
      "minLength": 8
    },
    "expectedRevision": {
      "type": "integer",
      "maximum": 9007199254740991,
      "exclusiveMinimum": 0
    }
  }
}
gripforge_scene_review annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_scene_promote — Set the visually approved scene version
Advertised by the server during the last successful anonymous check.

Explicitly promote the latest work revision only if its trusted visual review matches the exact content, dependencies and current renderer. expectedCurrent must match the existing validated pointer or null. No client-supplied approval report is accepted.

gripforge_scene_promote input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "id",
    "revision",
    "expectedCurrent"
  ],
  "properties": {
    "id": {
      "type": "string",
      "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
    },
    "revision": {
      "type": "integer",
      "maximum": 9007199254740991,
      "exclusiveMinimum": 0
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Returned scene links open this workspace."
    },
    "expectedCurrent": {
      "anyOf": [
        {
          "type": "integer",
          "maximum": 9007199254740991,
          "exclusiveMinimum": 0
        },
        {
          "type": "null"
        }
      ]
    }
  }
}
gripforge_scene_promote annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_scene_asset_pin — Pin an immutable Library revision
Advertised by the server during the last successful anonymous check.

Archive the owned Library resource bytes and metadata for use in scenes. Returns assetId/revisionId, capabilities, material/animation names and sockets. Repeating for identical content reuses the archive; it consumes workspace storage only once. Prefers the validated version for insertion; choose version=work to test the draft. Does not approve the asset visually.

gripforge_scene_asset_pin input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "assetId"
  ],
  "properties": {
    "assetId": {
      "type": "string",
      "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
    },
    "version": {
      "enum": [
        "current",
        "work"
      ],
      "type": "string",
      "default": "current"
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Returned scene links open this workspace."
    }
  }
}
gripforge_scene_asset_pin annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_scene_asset_versions — Read asset version and review
Advertised by the server during the last successful anonymous check.
Advertised read-only

Read immutable asset work/current pointers and the trusted review of work. Does not create a version.

gripforge_scene_asset_versions input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "assetId"
  ],
  "properties": {
    "assetId": {
      "type": "string",
      "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Returned scene links open this workspace."
    }
  }
}
gripforge_scene_asset_versions annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_scene_asset_review — Review an immutable asset
Advertised by the server during the last successful anonymous check.

Create a shared test scene and queue an independent review of real GripForge captures. Supports meshes, textures and effects. Never promotes automatically.

gripforge_scene_asset_review input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "assetId",
    "revisionId"
  ],
  "properties": {
    "assetId": {
      "type": "string",
      "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
    },
    "revisionId": {
      "type": "string",
      "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Returned scene links open this workspace."
    },
    "idempotency_key": {
      "type": "string",
      "maxLength": 160,
      "minLength": 8
    }
  }
}
gripforge_scene_asset_review annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_scene_asset_promote — Set the visually approved asset version
Advertised by the server during the last successful anonymous check.

Promote only when the exact work revision has a matching trusted review for the current renderer. Existing scene instances keep their pinned revision.

gripforge_scene_asset_promote input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "assetId",
    "revisionId",
    "expectedCurrent"
  ],
  "properties": {
    "assetId": {
      "type": "string",
      "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
    },
    "revisionId": {
      "type": "string",
      "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Returned scene links open this workspace."
    },
    "expectedCurrent": {
      "anyOf": [
        {
          "type": "string",
          "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
        },
        {
          "type": "null"
        }
      ]
    }
  }
}
gripforge_scene_asset_promote annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_fp_hands_schema — First-person hand manufacturing contract
Advertised by the server during the last successful anonymous check.
Advertised read-only

Read the native FPS hand template, recipe defaults, limits and reuse workflow. Geometry is manufactured from an articulated FPS template, independently of full-body character generation.

gripforge_fp_hands_schema input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Returned scene links open this workspace."
    }
  }
}
gripforge_fp_hands_schema annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_generate_fp_hands — Generate dedicated first-person hands
Advertised by the server during the last successful anonymous check.

Manufacture a NEW fps-arms work asset using the native FPS template: curved hand surface refinement, fitted skinned long sleeves/cuff, optional tactical glove reinforcement and embedded PBR. recipe={version:1,name,quality:high|standard,gloves:tactical|light,sleeves:long|none,colors?:{fabric:#RRGGBB,sleeve:#RRGGBB,trim:#RRGGBB},source?:{assetId,revisionId,fileRole?}}. No source gives standalone hands with native finger rig, hand_item_r/l sockets and existing starting clips. Optional owned immutable native paired source keeps weapon, camera and animation tracks; source must contain FPS_Hands or FPS_Arms_Mesh, all ten native fingers, embedded GLB <=32 MiB. This is template geometry/garment manufacture, not prompt-to-new-anatomy or arbitrary rigging. Returns job_id; poll generation_read. Inspect fingers, seams and weapon/garment contact in the actual renderer before binding. No external provider charge; never auto-promotes or overwrites.

gripforge_generate_fp_hands input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "recipe"
  ],
  "properties": {
    "recipe": {
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Returned scene links open this workspace."
    },
    "idempotency_key": {
      "type": "string",
      "maxLength": 160,
      "minLength": 8
    }
  }
}
gripforge_generate_fp_hands annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_fps_animation — Author first-person weapon rigs and materials
Advertised by the server during the last successful anonymous check.

Queue a persistent FPS work asset. Pistol recipe: {version:1,preset:"pistol",name:"Pistol FPS",tempo:1}, tempo 0.7–1.3; manufactures paired arms and articulated pistol clips plus .blend in Blender. Materials recipe: {version:1,preset:"materials",name:"Tactical gloves",source:{assetId,revisionId},node:"FPS_Hands",materials:{map:{assetId,revisionId},normalMap?:{assetId,revisionId},roughnessMap?:{assetId,revisionId},normalScale:0.35,roughness:1,metalness:0}}. Upload and pin owned textures first; they must match source UVs. Select one exact skinned node; other nodes, geometry, fingers and clips stay intact. Normal is OpenGL +Y; grayscale roughness reads G and requires metalness=0 (skin/fabric). Sources <=32 MB, images PNG/JPEG/WebP <=16 MB and 4096 pixels per side. Materials authors a reusable GLB variant, not new hand anatomy or a new .blend; no provider charge. Returns job_id: poll gripforge_generation_read for private Library ref, report and FPS Studio link. Never automatically validates or promotes. Cancel/retry supported; completed steps survive closing the page.

gripforge_fps_animation input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "recipe"
  ],
  "properties": {
    "recipe": {
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Returned scene links open this workspace."
    },
    "idempotency_key": {
      "type": "string",
      "maxLength": 160,
      "minLength": 8
    }
  }
}
gripforge_fps_animation annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_generation_list — List persistent generation jobs
Advertised by the server during the last successful anonymous check.
Advertised read-only

List workspace jobs. Jobs and completed steps survive closing the studio or restarting the web server and worker.

gripforge_generation_list input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Returned scene links open this workspace."
    }
  }
}
gripforge_generation_list annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_generation_read — Read generation progress and result
Advertised by the server during the last successful anonymous check.
Advertised read-only

Poll a job returned by a generation tool. Includes durable steps, progress, failure/retry state and the resulting work revision with a Studio link. include_preview returns saved HUD/map/building concept images (at most 4). Set preview_view to return one chosen view. Concepts are generated illustrations, not verified 3D renders. Success does not mean visual approval or promotion.

gripforge_generation_read input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "id"
  ],
  "properties": {
    "id": {
      "type": "string",
      "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
    },
    "preview_view": {
      "enum": [
        "overview",
        "top_down",
        "entrance",
        "objective",
        "front_right",
        "front_left",
        "rear_right",
        "rear_left"
      ],
      "type": "string"
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Returned scene links open this workspace."
    },
    "include_preview": {
      "type": "boolean"
    }
  }
}
gripforge_generation_read annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_generation_cancel — Cancel generation
Advertised by the server during the last successful anonymous check.

Request worker cancellation while retaining completed steps and artifacts. Closing a page alone does not cancel a job.

gripforge_generation_cancel input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "id"
  ],
  "properties": {
    "id": {
      "type": "string",
      "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Returned scene links open this workspace."
    }
  }
}
gripforge_generation_cancel annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_generation_retry — Retry interrupted generation
Advertised by the server during the last successful anonymous check.

Retry a failed or cancelled job, reusing completed steps. An unconfirmed interrupted provider call may be executed again when explicitly retried.

gripforge_generation_retry input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "id"
  ],
  "properties": {
    "id": {
      "type": "string",
      "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Returned scene links open this workspace."
    }
  }
}
gripforge_generation_retry annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_blender_fabricate — Fabricate editable assets with Blender
Advertised by the server during the last successful anonymous check.

Queue a bounded Blender recipe, never arbitrary Python. Saves GLB and .blend in the workspace as an unvalidated work version with a shared Scene Studio link. Read gripforge_scene_schema for recipe fields. Supports original primitive/custom meshes, PBR colors and keyed transforms. Poll gripforge_generation_read; final visual approval must use GripForge rendering, not Blender screenshots.

gripforge_blender_fabricate input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "recipe"
  ],
  "properties": {
    "recipe": {
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Returned scene links open this workspace."
    },
    "idempotency_key": {
      "type": "string",
      "maxLength": 160,
      "minLength": 8
    }
  }
}
gripforge_blender_fabricate annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_project_get — Get a game project
Advertised by the server during the last successful anonymous check.
Advertised read-only

Read a dedicated-server project (gpj_…) in the authenticated workspace. Not a Library asset.

gripforge_project_get input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "id"
  ],
  "properties": {
    "id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Game project id (gpj_…)"
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    }
  }
}
gripforge_project_get annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_server_list — List game servers
Advertised by the server during the last successful anonymous check.
Advertised read-only

List dedicated game servers in the workspace with current status and latest instance.

gripforge_server_list input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    }
  }
}
gripforge_server_list annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_server_get — Get a game server
Advertised by the server during the last successful anonymous check.
Advertised read-only

Read one dedicated server, its instance, engine/networking detection and integration status.

gripforge_server_get input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "id"
  ],
  "properties": {
    "id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Game server id (srv_…)"
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    }
  }
}
gripforge_server_get annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_server_create — Create a game server
Advertised by the server during the last successful anonymous check.

Create a dedicated server record. Godot supports ENet and gfnet; gfnet requires a game server Docker image that boots its simulation and validation hooks. Does not start the process until deploy.

gripforge_server_create input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "name"
  ],
  "properties": {
    "demo": {
      "type": "boolean"
    },
    "name": {
      "type": "string",
      "maxLength": 80,
      "minLength": 1
    },
    "hints": {
      "type": "string",
      "maxLength": 2000
    },
    "image": {
      "type": "string",
      "maxLength": 200
    },
    "engine": {
      "enum": [
        "unity",
        "unreal",
        "godot",
        "custom"
      ],
      "type": "string"
    },
    "region": {
      "type": "string",
      "maxLength": 40
    },
    "command": {
      "type": "array",
      "items": {
        "type": "string",
        "maxLength": 4096
      },
      "maxItems": 128
    },
    "gamePort": {
      "type": "integer",
      "maximum": 65535,
      "minimum": 1
    },
    "maxPlayers": {
      "type": "integer",
      "maximum": 200,
      "minimum": 1
    },
    "networking": {
      "enum": [
        "fishnet",
        "ngo",
        "mirror",
        "photon",
        "enet",
        "gfnet",
        "custom",
        "unknown"
      ],
      "type": "string"
    },
    "sourceKind": {
      "enum": [
        "project",
        "git",
        "upload",
        "docker"
      ],
      "type": "string"
    },
    "environment": {
      "enum": [
        "production",
        "staging",
        "development"
      ],
      "type": "string"
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    },
    "launchTemplate": {
      "type": "string",
      "maxLength": 2000
    },
    "privateNetwork": {
      "type": "boolean",
      "description": "Bind game ports to host loopback for a WSS proxy. Default true for gfnet."
    }
  }
}
gripforge_server_create annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_server_deploy — Deploy a game server
Advertised by the server during the last successful anonymous check.

Create a Docker instance for this server and start it. Local demo uses a real container (python heartbeat unless a custom image is set). Mutating.

gripforge_server_deploy input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "id"
  ],
  "properties": {
    "id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Game server id (srv_…)"
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    }
  }
}
gripforge_server_deploy annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_server_start — Start a game server
Advertised by the server during the last successful anonymous check.

Start the existing instance. Mutating.

gripforge_server_start input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "id"
  ],
  "properties": {
    "id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Game server id (srv_…)"
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    }
  }
}
gripforge_server_start annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_server_stop — Stop a game server
Advertised by the server during the last successful anonymous check.
Advertised destructive

Stop the running instance. Mutating.

gripforge_server_stop input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "id"
  ],
  "properties": {
    "id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Game server id (srv_…)"
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    }
  }
}
gripforge_server_stop annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": true
}
gripforge_server_restart — Restart a game server
Advertised by the server during the last successful anonymous check.

Restart the running instance. Mutating.

gripforge_server_restart input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "id"
  ],
  "properties": {
    "id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Game server id (srv_…)"
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    }
  }
}
gripforge_server_restart annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_server_scale — Scale max players
Advertised by the server during the last successful anonymous check.

Update desired max players. Does not resize cloud hardware (Docker provider has no node pool). Mutating.

gripforge_server_scale input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "id",
    "maxPlayers"
  ],
  "properties": {
    "id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Game server id (srv_…)"
    },
    "maxPlayers": {
      "type": "integer",
      "maximum": 200,
      "minimum": 1
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    }
  }
}
gripforge_server_scale annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_server_delete — Delete a game server
Advertised by the server during the last successful anonymous check.
Advertised destructive

HIGH IMPACT. Stops the instance and deletes the server. Requires confirm=true. Owner only.

gripforge_server_delete input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "id",
    "confirm"
  ],
  "properties": {
    "id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Game server id (srv_…)"
    },
    "confirm": {
      "type": "boolean",
      "const": true,
      "description": "Must be true. Production-destructive."
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    }
  }
}
gripforge_server_delete annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": true
}
gripforge_server_logs — Read server logs
Advertised by the server during the last successful anonymous check.
Advertised read-only

Stdout/stderr from the runtime provider (Docker logs). Not stored in SQL.

gripforge_server_logs input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "id"
  ],
  "properties": {
    "id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Game server id (srv_…)"
    },
    "tail": {
      "type": "integer",
      "maximum": 2000,
      "minimum": 20
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    }
  }
}
gripforge_server_logs annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_server_metrics — Read server metrics
Advertised by the server during the last successful anonymous check.
Advertised read-only

CPU, memory, network counters and player count from the metrics provider.

gripforge_server_metrics input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "id"
  ],
  "properties": {
    "id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Game server id (srv_…)"
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    }
  }
}
gripforge_server_metrics annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_server_events — Read server events
Advertised by the server during the last successful anonymous check.
Advertised read-only

Activity feed: server.created, server.ready, player.joined, match.started, …

gripforge_server_events input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "id"
  ],
  "properties": {
    "id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Game server id (srv_…)"
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    }
  }
}
gripforge_server_events annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_build_list — List dedicated builds
Advertised by the server during the last successful anonymous check.
Advertised read-only

List game_builds (not Godot kit zips at /api/v1/builds).

gripforge_build_list input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    }
  }
}
gripforge_build_list annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_build_get — Get a dedicated build
Advertised by the server during the last successful anonymous check.
Advertised read-only

Read one game build. Upload/deploy of Linux dedicated artifacts is not implemented yet.

gripforge_build_get input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "id"
  ],
  "properties": {
    "id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Game build id (bld_…)"
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    }
  }
}
gripforge_build_get annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_build_deploy — Deploy a build
Advertised by the server during the last successful anonymous check.

Not implemented. Returns 501 until artifact upload exists.

gripforge_build_deploy input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "id"
  ],
  "properties": {
    "id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Game build id (bld_…)"
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    }
  }
}
gripforge_build_deploy annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_build_rollback — Rollback a build
Advertised by the server during the last successful anonymous check.
Advertised destructive

Not implemented. Returns 501. Mutating / production-sensitive.

gripforge_build_rollback input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "id"
  ],
  "properties": {
    "id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Game build id (bld_…)"
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    }
  }
}
gripforge_build_rollback annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": true
}
gripforge_players_list — List connected players
Advertised by the server during the last successful anonymous check.
Advertised read-only

Sessions reported by the Unity SDK. Empty until the SDK calls player.joined.

gripforge_players_list input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "id"
  ],
  "properties": {
    "id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Game server id (srv_…)"
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    }
  }
}
gripforge_players_list annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_player_get — Get a player session
Advertised by the server during the last successful anonymous check.
Advertised read-only

Read one player session on a server.

gripforge_player_get input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "id",
    "player_id"
  ],
  "properties": {
    "id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Game server id (srv_…)"
    },
    "player_id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Player session id (ses_…)"
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    }
  }
}
gripforge_player_get annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_player_kick — Kick a player
Advertised by the server during the last successful anonymous check.
Advertised destructive

Requires the Unity SDK. Currently returns 501. Mutating.

gripforge_player_kick input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "id",
    "player_id"
  ],
  "properties": {
    "id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Game server id (srv_…)"
    },
    "player_id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Player session id (ses_…)"
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    }
  }
}
gripforge_player_kick annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": true
}
gripforge_player_ban — Ban a player
Advertised by the server during the last successful anonymous check.
Advertised destructive

HIGH IMPACT. Requires the Unity SDK. Currently returns 501. Owner only.

gripforge_player_ban input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "id",
    "player_id"
  ],
  "properties": {
    "id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Game server id (srv_…)"
    },
    "player_id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Player session id (ses_…)"
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    }
  }
}
gripforge_player_ban annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": true
}
gripforge_game_broadcast — Broadcast to a match
Advertised by the server during the last successful anonymous check.

Requires the Unity SDK. Currently returns 501. Never runs a shell on the host.

gripforge_game_broadcast input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "id"
  ],
  "properties": {
    "id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Game server id (srv_…)"
    },
    "message": {
      "type": "string",
      "maxLength": 500
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    }
  }
}
gripforge_game_broadcast annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_world_list — List worlds
Advertised by the server during the last successful anonymous check.
Advertised read-only

Worlds stored for the workspace or a server’s project. Empty until worlds are implemented.

gripforge_world_list input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Game server id (srv_…)"
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    }
  }
}
gripforge_world_list annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_world_deploy — Deploy a world
Advertised by the server during the last successful anonymous check.

Not implemented. Returns 501.

gripforge_world_deploy input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "id"
  ],
  "properties": {
    "id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Game server id (srv_…)"
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    }
  }
}
gripforge_world_deploy annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_world_backup — Backup a world
Advertised by the server during the last successful anonymous check.

Not implemented. Returns 501. Mutating.

gripforge_world_backup input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "id"
  ],
  "properties": {
    "id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Game server id (srv_…)"
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    }
  }
}
gripforge_world_backup annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_world_restore — Restore a backup
Advertised by the server during the last successful anonymous check.
Advertised destructive

HIGH IMPACT. Not implemented. Returns 501.

gripforge_world_restore input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "id"
  ],
  "properties": {
    "id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Game server id (srv_…)"
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    }
  }
}
gripforge_world_restore annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": true
}
gripforge_match_list — List matches
Advertised by the server during the last successful anonymous check.
Advertised read-only

Matches recorded for a server (SDK or API).

gripforge_match_list input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "id"
  ],
  "properties": {
    "id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Game server id (srv_…)"
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    }
  }
}
gripforge_match_list annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_match_get — Get a match
Advertised by the server during the last successful anonymous check.
Advertised read-only

Read one match record.

gripforge_match_get input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "id",
    "match_id"
  ],
  "properties": {
    "id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Game server id (srv_…)"
    },
    "match_id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Match id (mtc_…)"
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    }
  }
}
gripforge_match_get annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_match_create — Create a match record
Advertised by the server during the last successful anonymous check.

Records match.started. Does not spawn a new process. Mutating.

gripforge_match_create input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "id"
  ],
  "properties": {
    "id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Game server id (srv_…)"
    },
    "map": {
      "type": "string",
      "maxLength": 120
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    }
  }
}
gripforge_match_create annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_match_stop — Stop a match
Advertised by the server during the last successful anonymous check.
Advertised destructive

Marks the match ended. Mutating.

gripforge_match_stop input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "id",
    "match_id"
  ],
  "properties": {
    "id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Game server id (srv_…)"
    },
    "match_id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Match id (mtc_…)"
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    }
  }
}
gripforge_match_stop annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": true
}
gripforge_room_list — List online rooms
Advertised by the server during the last successful anonymous check.
Advertised read-only

List the online (multiplayer) rooms of the workspace with their live state. A closed page can leave a room open until its lifetime ends; each workspace holds at most 8 live rooms, so list and close the stale ones when "Room capacity reached" appears.

gripforge_room_list input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    }
  }
}
gripforge_room_list annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_room_close — Close an online room
Advertised by the server during the last successful anonymous check.
Advertised destructive

Close and delete one online room (frees the room quota). Invitations to it stop working. Mutating.

gripforge_room_close input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "room_id"
  ],
  "properties": {
    "room_id": {
      "type": "string",
      "pattern": "^[A-Za-z0-9_-]+$",
      "maxLength": 100,
      "minLength": 1,
      "description": "Room id from gripforge_room_list"
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    }
  }
}
gripforge_room_close annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": true
}
gripforge_game_world — Level plan and world review
Advertised by the server during the last successful anonymous check.

Read source-linked plans (get), author one (plan), construct actual kit content atomically (build, with plan_id, options and expected_revision; dry_run previews; activate explicitly sets the entry scene), save an input journey (journey), inspect without a run (inspect), or queue a real Bevy input/capture test (test). get section:builder with kit returns the provider options; section:journey returns its schema. Builders belong to kits, never genres. test returns a durable job; AI visual review uses a separately quoted Develop and test pass. Generated content remains unverified. Preserve requirements and existing authored content. 0 credits.

gripforge_game_world input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "project_id",
    "action"
  ],
  "properties": {
    "kit": {
      "type": "string",
      "description": "For get section:builder and build: the kit whose builder constructs the content."
    },
    "plan": {
      "type": "object",
      "description": "LevelPlan matching the versioned schema returned by get.",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "action": {
      "enum": [
        "get",
        "plan",
        "build",
        "journey",
        "inspect",
        "test"
      ],
      "type": "string",
      "description": "get: read the plans and sources; plan: save a LevelPlan; build: construct its kit content; journey: save an input journey; inspect: review without a run; test: queue a real input/capture test."
    },
    "offset": {
      "type": "integer",
      "maximum": 9007199254740991,
      "minimum": 0,
      "description": "Design source pagination for get."
    },
    "dry_run": {
      "type": "boolean",
      "description": "For build: preview what would be written, write nothing."
    },
    "journey": {
      "type": "object",
      "description": "For journey: the input journey matching the schema of get section:journey.",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "options": {
      "type": "object",
      "description": "For build: the options of the kit builder (from get section:builder).",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "plan_id": {
      "type": "string",
      "maxLength": 1000,
      "description": "The saved LevelPlan to build, inspect or test."
    },
    "section": {
      "enum": [
        "builder",
        "journey"
      ],
      "type": "string",
      "description": "For get: builder (the provider options of a kit) or journey (its schema)."
    },
    "activate": {
      "type": "boolean",
      "description": "For build: also make the built scene the entry scene."
    },
    "project_id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Game Kit project id (gkp_…). Not a dedicated-server project (gpj_…) nor a Library item."
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    },
    "idempotency_key": {
      "type": "string",
      "maxLength": 200,
      "description": "For test: the same key returns the same queued job instead of a new one."
    },
    "expected_revision": {
      "type": "integer",
      "maximum": 9007199254740991,
      "minimum": 0,
      "description": "Required for plan, build and journey; current project revision."
    }
  }
}
gripforge_game_world output schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "job": {
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "code": {
      "type": "string"
    },
    "data": {
      "type": "array",
      "items": {
        "type": "object",
        "propertyNames": {
          "type": "string"
        },
        "additionalProperties": {}
      }
    },
    "note": {
      "type": "string"
    },
    "plan": {
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "build": {
      "type": "string"
    },
    "error": {
      "type": "string"
    },
    "plans": {
      "type": "array",
      "items": {
        "type": "object",
        "propertyNames": {
          "type": "string"
        },
        "additionalProperties": {}
      }
    },
    "report": {
      "type": "object",
      "required": [
        "schema",
        "fingerprint",
        "mode",
        "checks",
        "plans",
        "unverified"
      ],
      "properties": {
        "mode": {
          "enum": [
            "structural",
            "geometry"
          ],
          "type": "string"
        },
        "plans": {
          "type": "array",
          "items": {
            "type": "object",
            "propertyNames": {
              "type": "string"
            },
            "additionalProperties": {}
          }
        },
        "checks": {
          "type": "array",
          "items": {
            "type": "object",
            "required": [
              "id",
              "kit",
              "location",
              "status",
              "level",
              "explanation",
              "remediation"
            ],
            "properties": {
              "id": {
                "type": "string"
              },
              "kit": {
                "type": "string"
              },
              "level": {
                "enum": [
                  "structural",
                  "geometry",
                  "gameplay",
                  "visual"
                ],
                "type": "string"
              },
              "status": {
                "enum": [
                  "passed",
                  "failed",
                  "unsupported"
                ],
                "type": "string"
              },
              "location": {
                "type": "string"
              },
              "measured": {
                "type": "object",
                "propertyNames": {
                  "type": "string"
                },
                "additionalProperties": {
                  "anyOf": [
                    {
                      "type": "number"
                    },
                    {
                      "type": "string"
                    },
                    {
                      "type": "boolean"
                    }
                  ]
                }
              },
              "explanation": {
                "type": "string"
              },
              "remediation": {
                "type": "string"
              }
            },
            "additionalProperties": false
          }
        },
        "schema": {
          "type": "string",
          "const": "gripforge.world-review/1"
        },
        "runtime": {
          "type": "array",
          "items": {
            "type": "object",
            "propertyNames": {
              "type": "string"
            },
            "additionalProperties": {}
          }
        },
        "production": {
          "type": "object",
          "propertyNames": {
            "type": "string"
          },
          "additionalProperties": {}
        },
        "unverified": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "fingerprint": {
          "type": "string"
        }
      },
      "additionalProperties": false
    },
    "schema": {
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "status": {
      "enum": [
        "planned",
        "preview",
        "implemented_unverified"
      ],
      "type": "string"
    },
    "details": {
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "journey": {
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "runtime": {
      "type": "array",
      "items": {
        "type": "object",
        "propertyNames": {
          "type": "string"
        },
        "additionalProperties": {}
      }
    },
    "sources": {
      "type": "array",
      "items": {
        "type": "object",
        "propertyNames": {
          "type": "string"
        },
        "additionalProperties": {}
      }
    },
    "builders": {
      "type": "array",
      "items": {
        "type": "object",
        "propertyNames": {
          "type": "string"
        },
        "additionalProperties": {}
      }
    },
    "journeys": {
      "type": "array",
      "items": {
        "type": "object",
        "propertyNames": {
          "type": "string"
        },
        "additionalProperties": {}
      }
    },
    "provider": {
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "revision": {
      "type": "integer",
      "maximum": 9007199254740991,
      "minimum": -9007199254740991
    },
    "workflow": {
      "type": "string"
    },
    "documents": {
      "type": "array",
      "items": {
        "type": "object",
        "propertyNames": {
          "type": "string"
        },
        "additionalProperties": {}
      }
    },
    "remaining": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "status_url": {
      "type": "string"
    },
    "structural": {
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "fingerprint": {
      "type": "string"
    },
    "next_offset": {
      "anyOf": [
        {
          "type": "number"
        },
        {
          "type": "null"
        }
      ]
    },
    "configurations": {
      "type": "array",
      "items": {
        "type": "object",
        "propertyNames": {
          "type": "string"
        },
        "additionalProperties": {}
      }
    },
    "journey_schema": {
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "designFingerprint": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ]
    },
    "plan_fingerprints": {
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {
        "type": "string"
      }
    }
  },
  "additionalProperties": false
}
gripforge_game_world annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_game_world_scope — Spatial production queue
Advertised by the server during the last successful anonymous check.

Read every spatial obligation in the saved game contract (get), or save region/location classifications, hierarchy, entries and intended connections (put). No genre counts. Old contracts need explicit classifications; declared spatial roles cannot be weakened. Regions require real child locations. Construction and verification remain separate. Scope writes use project revision checking. Continue with gripforge_game_world build/journey/test. 0 credits.

gripforge_game_world_scope input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "project_id",
    "action"
  ],
  "properties": {
    "scope": {
      "type": "object",
      "description": "For put: region/location classifications, hierarchy, entries and intended connections.",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "action": {
      "enum": [
        "get",
        "put"
      ],
      "type": "string",
      "description": "get: read every spatial obligation of the contract; put: save the scope."
    },
    "offset": {
      "type": "integer",
      "maximum": 9007199254740991,
      "minimum": 0,
      "description": "Pagination of the obligations for get."
    },
    "project_id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Game Kit project id (gkp_…). Not a dedicated-server project (gpj_…) nor a Library item."
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    },
    "expected_revision": {
      "type": "integer",
      "maximum": 9007199254740991,
      "minimum": 0,
      "description": "Required for put; current project revision."
    }
  }
}
gripforge_game_world_scope output schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "code": {
      "type": "string"
    },
    "next": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "note": {
      "type": "string"
    },
    "error": {
      "type": "string"
    },
    "scope": {
      "anyOf": [
        {
          "type": "object",
          "propertyNames": {
            "type": "string"
          },
          "additionalProperties": {}
        },
        {
          "type": "null"
        }
      ]
    },
    "total": {
      "type": "number"
    },
    "groups": {
      "type": "array",
      "items": {
        "type": "object",
        "propertyNames": {
          "type": "string"
        },
        "additionalProperties": {}
      }
    },
    "schema": {
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "status": {
      "type": "string",
      "const": "planned"
    },
    "details": {
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "entries": {
      "type": "array",
      "items": {
        "type": "object",
        "propertyNames": {
          "type": "string"
        },
        "additionalProperties": {}
      }
    },
    "revision": {
      "type": "integer",
      "maximum": 9007199254740991,
      "minimum": -9007199254740991
    },
    "next_offset": {
      "anyOf": [
        {
          "type": "number"
        },
        {
          "type": "null"
        }
      ]
    },
    "designFingerprint": {
      "type": "string"
    }
  },
  "additionalProperties": false
}
gripforge_game_world_scope annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_define_game — Game completeness: define game
Advertised by the server during the last successful anonymous check.

Journey — once the user's game is understood (any game: no character, enemy, level, ending or known genre is required). Record what the game contains; for a known genre, its definition of done and the common frame (title / pause / end screens, sound, HUD, touch controls, a way to win or lose when the game has an end) are proposals to offer, recorded when the user takes them. Content is data, not code: generic systems in code (kits, parameters, hooks); levels, characters, weapons, items, balance, texts, assets and inputs as data read at run time; clips, bones, grips and sizes from each asset's passport, never written in code. Persist a versioned Game Completion Contract with revision checking. Read get_completion_report for its schema and a proposed contract. Required, optional and excluded capabilities describe the actual intended experience. 0 credits.

gripforge_define_game input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "project_id",
    "contract",
    "expected_revision"
  ],
  "properties": {
    "contract": {
      "type": "object",
      "description": "GameCompletionContract matching the versioned schema returned by get_completion_report.",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "project_id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Game Kit project id (gkp_…). Not a dedicated-server project (gpj_…) nor a Library item."
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    },
    "expected_revision": {
      "type": "integer",
      "maximum": 9007199254740991,
      "description": "Current revision of the PROJECT (the `revision` field get_completion_report returns, also for a project with no contract yet; it is not a contract counter and 0 is never right). The save is refused with revision_conflict (actual revision in details) if the project changed since.",
      "exclusiveMinimum": 0
    }
  }
}
gripforge_define_game output schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "job": {
      "type": "object",
      "required": [
        "id",
        "status"
      ],
      "properties": {
        "id": {
          "type": "string"
        },
        "status": {
          "type": "string"
        }
      },
      "additionalProperties": {}
    },
    "code": {
      "type": "string"
    },
    "error": {
      "type": "string"
    },
    "report": {
      "type": "object",
      "required": [
        "schema",
        "projectId",
        "ready",
        "profile",
        "build",
        "blockers",
        "metrics",
        "graph",
        "results"
      ],
      "properties": {
        "build": {
          "type": "object",
          "propertyNames": {
            "type": "string"
          },
          "additionalProperties": {
            "type": "string"
          }
        },
        "graph": {
          "type": "object",
          "propertyNames": {
            "type": "string"
          },
          "additionalProperties": {}
        },
        "ready": {
          "type": "boolean"
        },
        "schema": {
          "type": "string",
          "const": "gripforge.completion-report/1"
        },
        "metrics": {
          "type": "object",
          "propertyNames": {
            "type": "string"
          },
          "additionalProperties": {
            "anyOf": [
              {
                "type": "number"
              },
              {
                "type": "null"
              }
            ]
          }
        },
        "profile": {
          "type": "string"
        },
        "results": {
          "type": "array",
          "items": {
            "type": "object",
            "propertyNames": {
              "type": "string"
            },
            "additionalProperties": {}
          }
        },
        "blockers": {
          "type": "array",
          "items": {
            "type": "object",
            "required": [
              "requirementId",
              "reason"
            ],
            "properties": {
              "reason": {
                "type": "string"
              },
              "requirementId": {
                "type": "string"
              }
            },
            "additionalProperties": false
          }
        },
        "projectId": {
          "type": "string"
        }
      },
      "additionalProperties": false
    },
    "schema": {
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "defined": {
      "type": "boolean"
    },
    "details": {
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "contract": {
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "proposal": {
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "revision": {
      "type": "integer",
      "maximum": 9007199254740991,
      "minimum": -9007199254740991
    },
    "migrations": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "report_url": {
      "type": "string"
    },
    "status_url": {
      "type": "string"
    }
  },
  "additionalProperties": false
}
gripforge_define_game annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_resolve_requirements — Game completeness: resolve requirements
Advertised by the server during the last successful anonymous check.
Advertised read-only

Resolve the saved contract, transitive capabilities and rules into an inspectable requirement graph. Does not run tests. 0 credits.

gripforge_resolve_requirements input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "project_id"
  ],
  "properties": {
    "project_id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Game Kit project id (gkp_…). Not a dedicated-server project (gpj_…) nor a Library item."
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    }
  }
}
gripforge_resolve_requirements output schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "job": {
      "type": "object",
      "required": [
        "id",
        "status"
      ],
      "properties": {
        "id": {
          "type": "string"
        },
        "status": {
          "type": "string"
        }
      },
      "additionalProperties": {}
    },
    "code": {
      "type": "string"
    },
    "error": {
      "type": "string"
    },
    "report": {
      "type": "object",
      "required": [
        "schema",
        "projectId",
        "ready",
        "profile",
        "build",
        "blockers",
        "metrics",
        "graph",
        "results"
      ],
      "properties": {
        "build": {
          "type": "object",
          "propertyNames": {
            "type": "string"
          },
          "additionalProperties": {
            "type": "string"
          }
        },
        "graph": {
          "type": "object",
          "propertyNames": {
            "type": "string"
          },
          "additionalProperties": {}
        },
        "ready": {
          "type": "boolean"
        },
        "schema": {
          "type": "string",
          "const": "gripforge.completion-report/1"
        },
        "metrics": {
          "type": "object",
          "propertyNames": {
            "type": "string"
          },
          "additionalProperties": {
            "anyOf": [
              {
                "type": "number"
              },
              {
                "type": "null"
              }
            ]
          }
        },
        "profile": {
          "type": "string"
        },
        "results": {
          "type": "array",
          "items": {
            "type": "object",
            "propertyNames": {
              "type": "string"
            },
            "additionalProperties": {}
          }
        },
        "blockers": {
          "type": "array",
          "items": {
            "type": "object",
            "required": [
              "requirementId",
              "reason"
            ],
            "properties": {
              "reason": {
                "type": "string"
              },
              "requirementId": {
                "type": "string"
              }
            },
            "additionalProperties": false
          }
        },
        "projectId": {
          "type": "string"
        }
      },
      "additionalProperties": false
    },
    "schema": {
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "defined": {
      "type": "boolean"
    },
    "details": {
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "contract": {
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "proposal": {
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "revision": {
      "type": "integer",
      "maximum": 9007199254740991,
      "minimum": -9007199254740991
    },
    "migrations": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "report_url": {
      "type": "string"
    },
    "status_url": {
      "type": "string"
    }
  },
  "additionalProperties": false
}
gripforge_resolve_requirements annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_audit_game — Game completeness: audit game
Advertised by the server during the last successful anonymous check.

Inspect project structure and flow, preserve fresh build evidence and report unsupported tests explicitly. 0 credits.

gripforge_audit_game input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "project_id"
  ],
  "properties": {
    "project_id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Game Kit project id (gkp_…). Not a dedicated-server project (gpj_…) nor a Library item."
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    }
  }
}
gripforge_audit_game output schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "job": {
      "type": "object",
      "required": [
        "id",
        "status"
      ],
      "properties": {
        "id": {
          "type": "string"
        },
        "status": {
          "type": "string"
        }
      },
      "additionalProperties": {}
    },
    "code": {
      "type": "string"
    },
    "error": {
      "type": "string"
    },
    "report": {
      "type": "object",
      "required": [
        "schema",
        "projectId",
        "ready",
        "profile",
        "build",
        "blockers",
        "metrics",
        "graph",
        "results"
      ],
      "properties": {
        "build": {
          "type": "object",
          "propertyNames": {
            "type": "string"
          },
          "additionalProperties": {
            "type": "string"
          }
        },
        "graph": {
          "type": "object",
          "propertyNames": {
            "type": "string"
          },
          "additionalProperties": {}
        },
        "ready": {
          "type": "boolean"
        },
        "schema": {
          "type": "string",
          "const": "gripforge.completion-report/1"
        },
        "metrics": {
          "type": "object",
          "propertyNames": {
            "type": "string"
          },
          "additionalProperties": {
            "anyOf": [
              {
                "type": "number"
              },
              {
                "type": "null"
              }
            ]
          }
        },
        "profile": {
          "type": "string"
        },
        "results": {
          "type": "array",
          "items": {
            "type": "object",
            "propertyNames": {
              "type": "string"
            },
            "additionalProperties": {}
          }
        },
        "blockers": {
          "type": "array",
          "items": {
            "type": "object",
            "required": [
              "requirementId",
              "reason"
            ],
            "properties": {
              "reason": {
                "type": "string"
              },
              "requirementId": {
                "type": "string"
              }
            },
            "additionalProperties": false
          }
        },
        "projectId": {
          "type": "string"
        }
      },
      "additionalProperties": false
    },
    "schema": {
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "defined": {
      "type": "boolean"
    },
    "details": {
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "contract": {
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "proposal": {
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "revision": {
      "type": "integer",
      "maximum": 9007199254740991,
      "minimum": -9007199254740991
    },
    "migrations": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "report_url": {
      "type": "string"
    },
    "status_url": {
      "type": "string"
    }
  },
  "additionalProperties": false
}
gripforge_audit_game annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_get_completion_report — Game completeness: get completion report
Advertised by the server during the last successful anonymous check.
Advertised read-only

Journey — while building: what the contract still misses, leaves unverified, fails or blocks. The genre defects come from gripforge_game_audit. Read the contract, requirements, implementation status, build-specific evidence, blockers and remediation. Without a contract returns the schema and a proposal. 0 credits.

gripforge_get_completion_report input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "project_id"
  ],
  "properties": {
    "project_id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Game Kit project id (gkp_…). Not a dedicated-server project (gpj_…) nor a Library item."
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    }
  }
}
gripforge_get_completion_report output schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "job": {
      "type": "object",
      "required": [
        "id",
        "status"
      ],
      "properties": {
        "id": {
          "type": "string"
        },
        "status": {
          "type": "string"
        }
      },
      "additionalProperties": {}
    },
    "code": {
      "type": "string"
    },
    "error": {
      "type": "string"
    },
    "report": {
      "type": "object",
      "required": [
        "schema",
        "projectId",
        "ready",
        "profile",
        "build",
        "blockers",
        "metrics",
        "graph",
        "results"
      ],
      "properties": {
        "build": {
          "type": "object",
          "propertyNames": {
            "type": "string"
          },
          "additionalProperties": {
            "type": "string"
          }
        },
        "graph": {
          "type": "object",
          "propertyNames": {
            "type": "string"
          },
          "additionalProperties": {}
        },
        "ready": {
          "type": "boolean"
        },
        "schema": {
          "type": "string",
          "const": "gripforge.completion-report/1"
        },
        "metrics": {
          "type": "object",
          "propertyNames": {
            "type": "string"
          },
          "additionalProperties": {
            "anyOf": [
              {
                "type": "number"
              },
              {
                "type": "null"
              }
            ]
          }
        },
        "profile": {
          "type": "string"
        },
        "results": {
          "type": "array",
          "items": {
            "type": "object",
            "propertyNames": {
              "type": "string"
            },
            "additionalProperties": {}
          }
        },
        "blockers": {
          "type": "array",
          "items": {
            "type": "object",
            "required": [
              "requirementId",
              "reason"
            ],
            "properties": {
              "reason": {
                "type": "string"
              },
              "requirementId": {
                "type": "string"
              }
            },
            "additionalProperties": false
          }
        },
        "projectId": {
          "type": "string"
        }
      },
      "additionalProperties": false
    },
    "schema": {
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "defined": {
      "type": "boolean"
    },
    "details": {
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "contract": {
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "proposal": {
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "revision": {
      "type": "integer",
      "maximum": 9007199254740991,
      "minimum": -9007199254740991
    },
    "migrations": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "report_url": {
      "type": "string"
    },
    "status_url": {
      "type": "string"
    }
  },
  "additionalProperties": false
}
gripforge_get_completion_report annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_test_game — Game completeness: test game
Advertised by the server during the last successful anonymous check.

Journey — after each change, with gripforge_game_test (the headless playtest). Passing tests are not a finished game: gripforge_game_audit, then gripforge_validate_release. Queue validation on the existing durable job worker. Plays the game with its own controls: the suites each kit declares (several clients joining, leaving and coming back, click orders on the ground, an enemy, a door, a chest, a downed ally, held buttons, a player that plays to an ending) and the headless playtest; endings (victory, defeat, boss defeated) come back as events. A real page that reached an ending, its hardware frame rate and the default screens it opened count for this revision. Returns job and status_url; poll that URL with the existing job tools. Simulation is not end-to-end gameplay proof. 0 credits.

gripforge_test_game input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "project_id"
  ],
  "properties": {
    "project_id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Game Kit project id (gkp_…). Not a dedicated-server project (gpj_…) nor a Library item."
    },
    "max_attempts": {
      "type": "integer",
      "maximum": 12,
      "minimum": 1,
      "description": "Upper bound of attempts of the queued job (1-12)."
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    },
    "idempotency_key": {
      "type": "string",
      "maxLength": 160,
      "minLength": 8,
      "description": "Repeat the same key to get the job already queued instead of a new one."
    }
  }
}
gripforge_test_game output schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "job": {
      "type": "object",
      "required": [
        "id",
        "status"
      ],
      "properties": {
        "id": {
          "type": "string"
        },
        "status": {
          "type": "string"
        }
      },
      "additionalProperties": {}
    },
    "code": {
      "type": "string"
    },
    "error": {
      "type": "string"
    },
    "report": {
      "type": "object",
      "required": [
        "schema",
        "projectId",
        "ready",
        "profile",
        "build",
        "blockers",
        "metrics",
        "graph",
        "results"
      ],
      "properties": {
        "build": {
          "type": "object",
          "propertyNames": {
            "type": "string"
          },
          "additionalProperties": {
            "type": "string"
          }
        },
        "graph": {
          "type": "object",
          "propertyNames": {
            "type": "string"
          },
          "additionalProperties": {}
        },
        "ready": {
          "type": "boolean"
        },
        "schema": {
          "type": "string",
          "const": "gripforge.completion-report/1"
        },
        "metrics": {
          "type": "object",
          "propertyNames": {
            "type": "string"
          },
          "additionalProperties": {
            "anyOf": [
              {
                "type": "number"
              },
              {
                "type": "null"
              }
            ]
          }
        },
        "profile": {
          "type": "string"
        },
        "results": {
          "type": "array",
          "items": {
            "type": "object",
            "propertyNames": {
              "type": "string"
            },
            "additionalProperties": {}
          }
        },
        "blockers": {
          "type": "array",
          "items": {
            "type": "object",
            "required": [
              "requirementId",
              "reason"
            ],
            "properties": {
              "reason": {
                "type": "string"
              },
              "requirementId": {
                "type": "string"
              }
            },
            "additionalProperties": false
          }
        },
        "projectId": {
          "type": "string"
        }
      },
      "additionalProperties": false
    },
    "schema": {
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "defined": {
      "type": "boolean"
    },
    "details": {
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "contract": {
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "proposal": {
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "revision": {
      "type": "integer",
      "maximum": 9007199254740991,
      "minimum": -9007199254740991
    },
    "migrations": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "report_url": {
      "type": "string"
    },
    "status_url": {
      "type": "string"
    }
  },
  "additionalProperties": false
}
gripforge_test_game annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_complete_game — Game completeness: complete game
Advertised by the server during the last successful anonymous check.

Queue bounded completion using existing kit installers and regression tests. Installs only the provider that fits the game and only kits of its genre, preset or request (never a kit that makes it another game). Preserves exclusions and project revision safety. No paid generation or destructive replacement. Poll status_url; succeeded means the job finished, inspect report.ready. 0 credits.

gripforge_complete_game input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "project_id"
  ],
  "properties": {
    "project_id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Game Kit project id (gkp_…). Not a dedicated-server project (gpj_…) nor a Library item."
    },
    "max_attempts": {
      "type": "integer",
      "maximum": 12,
      "minimum": 1,
      "description": "Upper bound of attempts of the queued job (1-12)."
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    },
    "idempotency_key": {
      "type": "string",
      "maxLength": 160,
      "minLength": 8,
      "description": "Repeat the same key to get the job already queued instead of a new one."
    }
  }
}
gripforge_complete_game output schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "job": {
      "type": "object",
      "required": [
        "id",
        "status"
      ],
      "properties": {
        "id": {
          "type": "string"
        },
        "status": {
          "type": "string"
        }
      },
      "additionalProperties": {}
    },
    "code": {
      "type": "string"
    },
    "error": {
      "type": "string"
    },
    "report": {
      "type": "object",
      "required": [
        "schema",
        "projectId",
        "ready",
        "profile",
        "build",
        "blockers",
        "metrics",
        "graph",
        "results"
      ],
      "properties": {
        "build": {
          "type": "object",
          "propertyNames": {
            "type": "string"
          },
          "additionalProperties": {
            "type": "string"
          }
        },
        "graph": {
          "type": "object",
          "propertyNames": {
            "type": "string"
          },
          "additionalProperties": {}
        },
        "ready": {
          "type": "boolean"
        },
        "schema": {
          "type": "string",
          "const": "gripforge.completion-report/1"
        },
        "metrics": {
          "type": "object",
          "propertyNames": {
            "type": "string"
          },
          "additionalProperties": {
            "anyOf": [
              {
                "type": "number"
              },
              {
                "type": "null"
              }
            ]
          }
        },
        "profile": {
          "type": "string"
        },
        "results": {
          "type": "array",
          "items": {
            "type": "object",
            "propertyNames": {
              "type": "string"
            },
            "additionalProperties": {}
          }
        },
        "blockers": {
          "type": "array",
          "items": {
            "type": "object",
            "required": [
              "requirementId",
              "reason"
            ],
            "properties": {
              "reason": {
                "type": "string"
              },
              "requirementId": {
                "type": "string"
              }
            },
            "additionalProperties": false
          }
        },
        "projectId": {
          "type": "string"
        }
      },
      "additionalProperties": false
    },
    "schema": {
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "defined": {
      "type": "boolean"
    },
    "details": {
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "contract": {
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "proposal": {
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "revision": {
      "type": "integer",
      "maximum": 9007199254740991,
      "minimum": -9007199254740991
    },
    "migrations": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "report_url": {
      "type": "string"
    },
    "status_url": {
      "type": "string"
    }
  },
  "additionalProperties": false
}
gripforge_complete_game annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_validate_release — Game completeness: validate release
Advertised by the server during the last successful anonymous check.

Journey — last, after gripforge_game_audit says complete. The game is finished only when report.ready=true on a contract that holds what the user chose for the game (genre proposals taken included); otherwise tell the user what is left and why. Evaluate explicit release blockers for the current build. Only report.ready=true proves all mandatory acceptance checks passed; coverage ratios never override blockers. 0 credits.

gripforge_validate_release input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "project_id"
  ],
  "properties": {
    "project_id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Game Kit project id (gkp_…). Not a dedicated-server project (gpj_…) nor a Library item."
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    }
  }
}
gripforge_validate_release output schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "job": {
      "type": "object",
      "required": [
        "id",
        "status"
      ],
      "properties": {
        "id": {
          "type": "string"
        },
        "status": {
          "type": "string"
        }
      },
      "additionalProperties": {}
    },
    "code": {
      "type": "string"
    },
    "error": {
      "type": "string"
    },
    "report": {
      "type": "object",
      "required": [
        "schema",
        "projectId",
        "ready",
        "profile",
        "build",
        "blockers",
        "metrics",
        "graph",
        "results"
      ],
      "properties": {
        "build": {
          "type": "object",
          "propertyNames": {
            "type": "string"
          },
          "additionalProperties": {
            "type": "string"
          }
        },
        "graph": {
          "type": "object",
          "propertyNames": {
            "type": "string"
          },
          "additionalProperties": {}
        },
        "ready": {
          "type": "boolean"
        },
        "schema": {
          "type": "string",
          "const": "gripforge.completion-report/1"
        },
        "metrics": {
          "type": "object",
          "propertyNames": {
            "type": "string"
          },
          "additionalProperties": {
            "anyOf": [
              {
                "type": "number"
              },
              {
                "type": "null"
              }
            ]
          }
        },
        "profile": {
          "type": "string"
        },
        "results": {
          "type": "array",
          "items": {
            "type": "object",
            "propertyNames": {
              "type": "string"
            },
            "additionalProperties": {}
          }
        },
        "blockers": {
          "type": "array",
          "items": {
            "type": "object",
            "required": [
              "requirementId",
              "reason"
            ],
            "properties": {
              "reason": {
                "type": "string"
              },
              "requirementId": {
                "type": "string"
              }
            },
            "additionalProperties": false
          }
        },
        "projectId": {
          "type": "string"
        }
      },
      "additionalProperties": false
    },
    "schema": {
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "defined": {
      "type": "boolean"
    },
    "details": {
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "contract": {
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "proposal": {
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "revision": {
      "type": "integer",
      "maximum": 9007199254740991,
      "minimum": -9007199254740991
    },
    "migrations": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "report_url": {
      "type": "string"
    },
    "status_url": {
      "type": "string"
    }
  },
  "additionalProperties": false
}
gripforge_validate_release annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_runtime_sessions — Rust runtime sessions
Advertised by the server during the last successful anonymous check.
Advertised read-only

List live Rust/Bevy previews for an authorized Game Kit project. Open the project Rust player in GripForge first. No server-side solo simulation. 0 credits.

gripforge_runtime_sessions input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "project_id"
  ],
  "properties": {
    "project_id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Game Kit project id (gkp_…). Not a dedicated-server project (gpj_…) nor a Library item."
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    }
  }
}
gripforge_runtime_sessions annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_runtime_command — Command Rust preview
Advertised by the server during the last successful anonymous check.

Queue a versioned GripForge runtime command for the exact browser session. Use inspect, apply_patch, set_relief (off/pom/spom on configured relief surfaces), step (paused only), run_test, play, pause, reset, load_game, unload_game or get_stats. Returns received; fetch the applied receipt with gripforge_runtime_receipt. Preview changes do not persist the project. Unknown kits/components and invalid fields are refused by the Rust core. 0 credits.

gripforge_runtime_command input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "project_id",
    "command"
  ],
  "properties": {
    "command": {
      "type": "object",
      "description": "The versioned runtime command: { protocol_version: 1, request_id, session_id (from gripforge_runtime_sessions), expected_revision, operation (inspect, apply_patch, set_relief, step, run_test, play, pause, reset, load_game, unload_game, get_stats), payload }.",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "project_id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Game Kit project id (gkp_…). Not a dedicated-server project (gpj_…) nor a Library item."
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    }
  }
}
gripforge_runtime_command annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_runtime_receipt — Read Rust command receipt
Advertised by the server during the last successful anonymous check.
Advertised read-only

Read received/applied/rejected status for a Rust preview request, including simulation boundary and revisions. 0 credits.

gripforge_runtime_receipt input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "project_id",
    "session_id",
    "request_id"
  ],
  "properties": {
    "project_id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Game Kit project id (gkp_…). Not a dedicated-server project (gpj_…) nor a Library item."
    },
    "request_id": {
      "type": "string",
      "maxLength": 96,
      "description": "The request_id of the command sent with gripforge_runtime_command."
    },
    "session_id": {
      "type": "string",
      "maxLength": 96,
      "description": "A live browser runtime session of the project, as listed by gripforge_runtime_sessions."
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    }
  }
}
gripforge_runtime_receipt annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_get_render_capabilities — Bevy neural preview: get_render_capabilities
Advertised by the server during the last successful anonymous check.
Advertised read-only

Local optional Bevy neural snapshot, not a saved scene edit. Requires an open authorized browser runtime session. Configure off/preview; realtime_experimental is refused. Trained weights and a local rights manifest must be selected in the browser; none are downloaded. render_preview starts an asynchronous request: read the command receipt, then query get_render_capabilities for actual completion, model, effective resolution, provenance, timings and limitations. Cancellation prevents stale publication. No images are uploaded. 0 credits.

gripforge_get_render_capabilities input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "project_id",
    "session_id",
    "request_id",
    "expected_revision"
  ],
  "properties": {
    "project_id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Game Kit project id (gkp_…). Not a dedicated-server project (gpj_…) nor a Library item."
    },
    "request_id": {
      "type": "string",
      "pattern": "^[-\\w.]{1,96}$",
      "description": "A new id of your choosing for this request (letters, digits, - _ .): its receipt is read with gripforge_runtime_receipt."
    },
    "session_id": {
      "type": "string",
      "maxLength": 96,
      "description": "A live browser runtime session of the project, as listed by gripforge_runtime_sessions."
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    },
    "expected_revision": {
      "type": "integer",
      "maximum": 9007199254740991,
      "minimum": 0,
      "description": "The revision of the session as gripforge_runtime_sessions reports it: a request on another revision is refused."
    }
  }
}
gripforge_get_render_capabilities annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_configure_render_preview — Bevy neural preview: configure_render_preview
Advertised by the server during the last successful anonymous check.

Local optional Bevy neural snapshot, not a saved scene edit. Requires an open authorized browser runtime session. Configure off/preview; realtime_experimental is refused. Trained weights and a local rights manifest must be selected in the browser; none are downloaded. render_preview starts an asynchronous request: read the command receipt, then query get_render_capabilities for actual completion, model, effective resolution, provenance, timings and limitations. Cancellation prevents stale publication. No images are uploaded. 0 credits.

gripforge_configure_render_preview input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "project_id",
    "session_id",
    "request_id",
    "expected_revision",
    "mode"
  ],
  "properties": {
    "mode": {
      "enum": [
        "off",
        "preview"
      ],
      "type": "string",
      "description": "off: no neural preview; preview: snapshots on request (realtime_experimental is refused)."
    },
    "project_id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Game Kit project id (gkp_…). Not a dedicated-server project (gpj_…) nor a Library item."
    },
    "request_id": {
      "type": "string",
      "pattern": "^[-\\w.]{1,96}$",
      "description": "A new id of your choosing for this request (letters, digits, - _ .): its receipt is read with gripforge_runtime_receipt."
    },
    "session_id": {
      "type": "string",
      "maxLength": 96,
      "description": "A live browser runtime session of the project, as listed by gripforge_runtime_sessions."
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    },
    "expected_revision": {
      "type": "integer",
      "maximum": 9007199254740991,
      "minimum": 0,
      "description": "The revision of the session as gripforge_runtime_sessions reports it: a request on another revision is refused."
    }
  }
}
gripforge_configure_render_preview annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_render_preview — Bevy neural preview: render_preview
Advertised by the server during the last successful anonymous check.

Local optional Bevy neural snapshot, not a saved scene edit. Requires an open authorized browser runtime session. Configure off/preview; realtime_experimental is refused. Trained weights and a local rights manifest must be selected in the browser; none are downloaded. render_preview starts an asynchronous request: read the command receipt, then query get_render_capabilities for actual completion, model, effective resolution, provenance, timings and limitations. Cancellation prevents stale publication. No images are uploaded. 0 credits.

gripforge_render_preview input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "project_id",
    "session_id",
    "request_id",
    "expected_revision"
  ],
  "properties": {
    "project_id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Game Kit project id (gkp_…). Not a dedicated-server project (gpj_…) nor a Library item."
    },
    "request_id": {
      "type": "string",
      "pattern": "^[-\\w.]{1,96}$",
      "description": "A new id of your choosing for this request (letters, digits, - _ .): its receipt is read with gripforge_runtime_receipt."
    },
    "session_id": {
      "type": "string",
      "maxLength": 96,
      "description": "A live browser runtime session of the project, as listed by gripforge_runtime_sessions."
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    },
    "expected_revision": {
      "type": "integer",
      "maximum": 9007199254740991,
      "minimum": 0,
      "description": "The revision of the session as gripforge_runtime_sessions reports it: a request on another revision is refused."
    }
  }
}
gripforge_render_preview annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_cancel_render_preview — Bevy neural preview: cancel_render_preview
Advertised by the server during the last successful anonymous check.

Local optional Bevy neural snapshot, not a saved scene edit. Requires an open authorized browser runtime session. Configure off/preview; realtime_experimental is refused. Trained weights and a local rights manifest must be selected in the browser; none are downloaded. render_preview starts an asynchronous request: read the command receipt, then query get_render_capabilities for actual completion, model, effective resolution, provenance, timings and limitations. Cancellation prevents stale publication. No images are uploaded. 0 credits.

gripforge_cancel_render_preview input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "project_id",
    "session_id",
    "request_id",
    "expected_revision"
  ],
  "properties": {
    "project_id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Game Kit project id (gkp_…). Not a dedicated-server project (gpj_…) nor a Library item."
    },
    "request_id": {
      "type": "string",
      "pattern": "^[-\\w.]{1,96}$",
      "description": "A new id of your choosing for this request (letters, digits, - _ .): its receipt is read with gripforge_runtime_receipt."
    },
    "session_id": {
      "type": "string",
      "maxLength": 96,
      "description": "A live browser runtime session of the project, as listed by gripforge_runtime_sessions."
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    },
    "expected_revision": {
      "type": "integer",
      "maximum": 9007199254740991,
      "minimum": 0,
      "description": "The revision of the session as gripforge_runtime_sessions reports it: a request on another revision is refused."
    }
  }
}
gripforge_cancel_render_preview annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_debug_sessions — Live game tabs for the debug inspector
Advertised by the server during the last successful anonymous check.
Advertised read-only

List the play tabs of a game that a member of the workspace has open right now (heartbeat within 30 s; closed tabs are gone): session id, last seen, viewer role, engine, backend (webgpu/webgl2) and render thread (worker/main). The first is the default target of gripforge_debug_snapshot / gripforge_debug_set. Empty: no tab is open, and the debug tools answer at once that no game tab is open. 0 credits.

gripforge_debug_sessions input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "project_id"
  ],
  "properties": {
    "project_id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Game Kit project id (gkp_…). Not a dedicated-server project (gpj_…) nor a Library item."
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    }
  }
}
gripforge_debug_sessions annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_debug_snapshot — Debug snapshot of a running game
Advertised by the server during the last successful anonymous check.
Advertised read-only

Read the debug inspector of a game open in a browser by a member of its workspace (the play page, Bevy player): frame rate and frame time (p50/p95/p99, worst, slow frames, stages of a frame), GPU and backend (webgpu, webgl2, vulkan, dx12, metal…, software rasteriser or not), draws, meshes, triangles, materials, lights, textures and their memory, entities, memory; the modes (wireframe, colliders, bounds), the selection, hidden and outlined nodes, the debug modes the kits registered and their data; with tree=true the scene tree (scenes, nodes, meshes with vertices / triangles / material, world boxes) within depth and max_nodes. JSON contract gripforge.debug/1, identical on every engine. The inspector is open to everyone by default; a game where the developer turned it off (kit debug.inspector config enabled: false, set with gripforge_gamekit_configure) answers "not open to this viewer". Use it to find why a game is slow or wrong before changing it. Same rights as the panel: members of the workspace. 0 credits.

gripforge_debug_snapshot input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "project_id"
  ],
  "properties": {
    "tree": {
      "type": "boolean",
      "description": "Also build the scene tree (default false)."
    },
    "depth": {
      "type": "integer",
      "maximum": 64,
      "minimum": 1,
      "description": "Levels of the tree (default 6)."
    },
    "max_nodes": {
      "type": "integer",
      "maximum": 20000,
      "minimum": 1,
      "description": "Nodes of the tree at most (default 2000)."
    },
    "project_id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Game Kit project id (gkp_…). Not a dedicated-server project (gpj_…) nor a Library item."
    },
    "session_id": {
      "type": "string",
      "maxLength": 96,
      "description": "A play session (play-…) of gripforge_runtime_sessions; default: the latest play page of the project."
    },
    "wait_seconds": {
      "type": "number",
      "maximum": 20,
      "minimum": 0,
      "description": "Seconds to wait for the page to answer (default 8); 0 answers at once with status received."
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    }
  }
}
gripforge_debug_snapshot annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_debug_set — Drive the debug inspector of a running game
Advertised by the server during the last successful anonymous check.

Send ops of gripforge.debug/1 to the debug inspector of a game open in a browser by a member of its workspace, then read the snapshot: { op: "mode", wireframe?, colliders?, bounds? } (wireframe, collision boxes, mesh bounds), { op: "tree", root?, depth?, maxNodes? }, { op: "select", ids }, { op: "hide", id, hidden }, { op: "outline", id, on }, { op: "reset" } (show everything, no outline), { op: "extension", id, on } (a debug mode of a kit, e.g. ai.navigation.paths), { op: "open" } / { op: "close" } (the panel on screen). Ids are those of the snapshot tree. Nothing is saved in the project. Same rights as the panel: members of the workspace. 0 credits.

gripforge_debug_set input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "project_id",
    "ops"
  ],
  "properties": {
    "ops": {
      "anyOf": [
        {
          "type": "object",
          "propertyNames": {
            "type": "string"
          },
          "additionalProperties": {}
        },
        {
          "type": "array",
          "items": {
            "type": "object",
            "propertyNames": {
              "type": "string"
            },
            "additionalProperties": {}
          },
          "maxItems": 64
        }
      ],
      "description": "One op or a list of ops."
    },
    "project_id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Game Kit project id (gkp_…). Not a dedicated-server project (gpj_…) nor a Library item."
    },
    "session_id": {
      "type": "string",
      "maxLength": 96,
      "description": "A play session (play-…) of gripforge_runtime_sessions; default: the latest play page of the project."
    },
    "wait_seconds": {
      "type": "number",
      "maximum": 20,
      "minimum": 0,
      "description": "Seconds to wait for the page to answer (default 8); 0 answers at once with status received."
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    }
  }
}
gripforge_debug_set annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_game_web_export — Prepare a standalone local web game
Advertised by the server during the last successful anonymous check.

Journey — last, and never for a local engine project (gripforge game-attach works in it). Run gripforge_game_audit then gripforge_validate_release first: export a game whose verdict is complete and whose release is ready, or tell the user what is left. Not for a local engine project: when the game's Godot project already exists on the user's machine, do not export it — attach GripForge to it with the CLI, gripforge game-attach <project_id> <project folder> (addon gripforge_kits + game under gripforge/, never its project.godot, scenes or scripts); Unity / Unreal: gripforge_gamekit_deliver in place. A native project's answer carries notices [{ code: export_not_needed, howToFix }]: follow it. If game-attach reports manual_setup_found, follow its howToFix before any --force. Prepare a download manifest for an existing Game Kit project in the current workspace. Reuses the same player and HUD as hosted play, compiles only installed enabled kit runtimes, and lists the game configuration, static resources and Library assets to download. Does not publish the project or change its visibility. The hosted MCP cannot write local files: use gripforge game-export <project_id> <folder> locally, then npm run dev. The CLI verifies downloads and preserves local edits on updates (--check previews conflicts; --force backs up and replaces edits only when authorized). The delivered versions remain fixed until an explicit export update. Legacy kits and unpublished source overlays cannot be exported. net.* kits still need their online services. 0 credits.

gripforge_game_web_export input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "project_id"
  ],
  "properties": {
    "project_id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Game Kit project id (gkp_…). Not a dedicated-server project (gpj_…) nor a Library item."
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    }
  }
}
gripforge_game_web_export annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_gamekit_search — Search the Game Kit catalogue
Advertised by the server during the last successful anonymous check.
Advertised read-only

Journey — first: analyse the project or the plan, then recommend the kits that fit, each with what it brings, and offer to plug them in ("these kits would help: shall I plug them in?"); never impose them. A preset of a known genre has a `done` list: proposals of what a finished game of that genre usually has, recorded in the contract (gripforge_define_game) when the user takes them; gripforge_game_audit checks what was chosen at the end Content is data, not code: generic systems in code (kits, parameters, hooks); levels, characters, weapons, items, balance, texts, assets and inputs as data read at run time; clips, bones, grips and sizes from each asset's passport, never written in code. Start here. Search the modular Game Kit catalogue (vehicle.driveable, mission.objectives, npc.wanted, …) by free text, capability, tag or engine target. Pass project_id to score kits against that project: each hit then carries state { installed, enabled, fills, reason } and kits that fill one of its missing capabilities rank first. Kits are bricks that go together: a kit handling the same thing as an installed one is a same-scene overlap (only one active in a scene), never a reason to skip it. Returns { kits, presets }; each kit carries its presentation: name, tagline (one-line hook), tags, targets and status per engine (web / godot / unity / unreal), and cover / coverUrl, the featured landscape image (WebP) to show the user when proposing kits. legacy.* kits play through their existing client. Kart Racing is native: compose world.racetrack + vehicle.driveable + race.kart; edit race_tracks through project data. world.lighting adds shared sun/fill, point lights and spots, presets, bounded light budgets and bloom; edit world_lights through project data. world.fluids adds interactive mud / blood surfaces, displaced 3D wheel ruts and footprints; edit fluid_surfaces through project data (web renderer). world.terrain adds a seeded large landscape (terrain_edits data), movement.traversal climbing / swimming / gliding with stamina, world.elements data-driven fire, water, ice, electricity and poison (element_rules, element_materials, element_climates data). Also returns packs: content packs (ready-made game content — documents and kit configs, e.g. a realistic atmosphere, a tree of life, a star system) that gripforge_gamekit_install { pack } installs into a project. Call this BEFORE gripforge_gamekit_install. 0 credits.

gripforge_gamekit_search input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "q": {
      "type": "string",
      "maxLength": 200,
      "description": "Free text matched on id, name, description and tags (e.g. \"drive a car\", \"wanted level\")."
    },
    "tag": {
      "type": "string",
      "maxLength": 60,
      "description": "Tag filter (e.g. vehicle, mission, npc, legacy)."
    },
    "limit": {
      "type": "integer",
      "maximum": 100,
      "minimum": 1,
      "description": "Max kits returned (default 20)."
    },
    "target": {
      "enum": [
        "bevy",
        "web",
        "godot",
        "unity",
        "unreal",
        "rust"
      ],
      "type": "string",
      "description": "Engine target the kit must support (bevy = the GripForge player, Rust/Bevy, also named web; rust: the kits ported to the Rust kit host, which the native player and the Bevy player run). For game creation, use the engine chosen by the user or identified in their project; ask Bevy (GripForge player) / Godot / Unity / Unreal Engine if unknown. The API web default is not user consent."
    },
    "capability": {
      "type": "string",
      "maxLength": 120,
      "description": "Capability the kit must provide (exact id or prefix, e.g. vehicle.drive)."
    },
    "project_id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Game Kit project id (gkp_…) to score results against. Default: the workspace’s most recently updated project."
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    }
  }
}
gripforge_gamekit_search annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_gamekit_get — Read one Game Kit
Advertised by the server during the last successful anonymous check.
Advertised read-only

Read one Game Kit: its manifest (provides / requires capabilities, asset slots, data collections, events), README docs, config JSON schema with defaults, version and changelog (information only: projects always run the latest version), and summary { tagline, tags, targets, status, cover, coverUrl } with the featured image URL. Pass with_usage=true to also list the workspace projects that have it installed. Call this BEFORE gripforge_gamekit_configure to know which config keys exist. 0 credits.

gripforge_gamekit_get input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "id"
  ],
  "properties": {
    "id": {
      "type": "string",
      "pattern": "^[a-z0-9][a-z0-9._-]*$",
      "maxLength": 120,
      "minLength": 2,
      "description": "Kit id from the catalogue, dotted (e.g. vehicle.driveable, mission.objectives)."
    },
    "section": {
      "enum": [
        "api"
      ],
      "type": "string",
      "description": "api: also return `api`, the full API reference of the kit (config with units and limits, hooks, events, views, services, verbs, slots, collections, mod points, presentation module, target parity, changelog, examples of a config and of a mod). For a compact Markdown form use gripforge_gamekit_api."
    },
    "version": {
      "type": "string",
      "maxLength": 40,
      "description": "Exact version to read (e.g. 1.0.0). Default: latest."
    },
    "with_usage": {
      "type": "boolean",
      "description": "true to include usedBy: the workspace projects where this kit is installed."
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    }
  }
}
gripforge_gamekit_get annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_gamekit_api — API reference of a Game Kit
Advertised by the server during the last successful anonymous check.
Advertised read-only

The API reference of one Game Kit, as compact Markdown: what it does and when to use it, every config key (type, default, unit, limits; mod = a mod may set it, live = read again while the game runs, scene = a scene may override it), hooks (payload, mutable fields, cancellable), events emitted and listened to (when, payload), web views and HUD vars, services and their methods, script verbs, asset slots, data collections, input actions, mod points, its Bevy presentation module (needs, ABI families, web UI), target parity, changelog, and an example config and an example mod (gripforge.mod/1). Read it BEFORE gripforge_gamekit_configure, before writing a mod (gripforge_game_mods) or hooks / scripts for the kit, and before writing its presentation module. sections narrows the answer (e.g. ["config","hooks"]); full=true adds nested keys, examples of every hook and verb, and the README. 0 credits.

gripforge_gamekit_api input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "id"
  ],
  "properties": {
    "id": {
      "type": "string",
      "pattern": "^[a-z0-9][a-z0-9._-]*$",
      "maxLength": 120,
      "minLength": 2,
      "description": "Kit id from the catalogue, dotted (e.g. vehicle.driveable, mission.objectives)."
    },
    "full": {
      "type": "boolean",
      "description": "true: the full form (nested config keys, every example, README). Default: compact."
    },
    "sections": {
      "type": "array",
      "items": {
        "enum": [
          "summary",
          "config",
          "hooks",
          "events",
          "views",
          "services",
          "verbs",
          "slots",
          "collections",
          "inputs",
          "modding",
          "module",
          "parity",
          "changelog",
          "examples",
          "readme"
        ],
        "type": "string"
      },
      "maxItems": 16,
      "description": "Only these sections (default: all)."
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    }
  }
}
gripforge_gamekit_api annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_docs — GripForge docs (offline)
Advertised by the server during the last successful anonymous check.
Advertised read-only

The GripForge docs, embedded in this MCP (readable offline, versioned with it), as Markdown. Without topic: the list of topics. With topic: its text, or one section (section = a heading, its number such as "4.2", or words of it); a long topic answers its table of contents first unless a section is given or full=true. Topics: web-export, godot, unity, unreal, desktop, rooms-server, central-server, c-api, lod, shadows, collision, render-lod, render-optimize, core-loop, local-project, game-plan, warnings, physics-async, structs, net, web-multiplayer, scenes, input, combat, character, enemies, npcs, quests, inventory, economy, vehicles, puzzles, sport, ui-webui, ui-screens, world-terrain, minion-waves, game-cinematic, debug-inspector, world-environment, hud, audio-core, i18n-text, save-persistence, settings-graphics, asset-preload, ai-navigation, fx-kits, glossary, kit-api, third-party, player, render-budget, scene-optim, porting, game-schema, module-calls, module-calls-native, godot-host, kit-modules, kit-structures, kit-third-party, abi, modding, game-engine-contract, game-engine, animal-behavior, animal-breeding, animal-taming, asset-cache, asset-meta, automation-logistics, bots-skirmish, build-modular, build-placement, camera-strategy, cards-deck, central-client, character-first-person, character-forms, character-platformer, character-roster, character-top-down, checkpoint-rest, collect-tokens, collection-packs, combat-abilities, combat-attacks, combat-defense, combat-duel, combat-grabs, combat-hit-reactions, combat-lockon, combat-melee, combat-moveset, combat-projectiles, combat-ranged, combat-stamina, combat-threat, combat-turns, combat-weakpoints, companion-control, coop-session, craft-recipes, custom-paint, defense-towers, defense-waves, desktop-launcher, dialogue-voice, display-fullscreen, drop-parachute, encounters-waves, enemy-boss, enemy-horde, enemy-stalker, engine-interop, faction-system, farming-crops, fishing-rod, fps-abilities, fps-armory, fps-deathmatch, fps-network, fps-tactical, fx-ability-vfx, game-endings, hazard-traps, horror-sanity, hud-minimap, hud-mmo, hud-moba, hud-nameplates, hud-open-world, hud-tactical, input-actions, input-pointer-lock, input-remap, input-virtualpad, interaction-feedback, interaction-system, interaction-telekinesis, inventory-equipment, launch-pad, life-ecosystem, life-genetics, light-flashlight, loot-ground, lore-journal, machines-production, match-knockout, mission-system, moba-hero, moba-lanes, mount-ride, movement-boost, movement-dash, movement-flight, movement-grapple, movement-grind, movement-modes, movement-traversal, net-async, net-authoritative, net-claim, net-lobby, net-physics, net-rollback, net-rooms, net-state, net-transport, net-zones, npc-dialogue, npc-pedestrian, party-rounds, photo-mode, present-native, progression-levels, puzzle-circuits, race-kart, render-raytrace, render-realism, research-samples, resource-extraction, resource-nodes, rts-ai, rts-production, run-map, save-online, shared-memory, social-party, spawn-system, sport-golf, stealth-detection, stealth-takedown, storage-containers, survival-needs, tactics-grid, time-rewind, trade-shop, traffic-system, travel-worlds, ui-cursor, ui-endscreen, ui-prompts, ui-theme, units-command, upgrades-boons, vehicle-boostpads, vehicle-damage, vehicle-doors, vehicle-enter-exit, vehicle-rivals, vehicle-spaceship, vehicle-upgrades, wanted-police, weapons-arsenal, weapons-loadout, weapons-mastery, world-access, world-arena, world-atmosphere, world-bindings, world-biomes, world-daynight, world-destructibles, world-district, world-elements, world-fluids, world-grass, world-gravity-zones, world-instances, world-interiors, world-magnetism, world-platforms, world-portals, world-racetrack, world-rooms, world-scene-ground, world-scenery, world-sky-bodies, world-stages, world-streaming, world-tracks, world-vision, world-water, world-weather, wrappers-demo, zone-shrink. Read "third-party" and "porting" + "abi" before writing a presentation module, "modding" before writing a mod, "glossary" for the words. A kit's own API reference is gripforge_gamekit_api. 0 credits.

gripforge_docs input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "full": {
      "type": "boolean",
      "description": "true: the whole topic even when long."
    },
    "topic": {
      "type": "string",
      "maxLength": 40,
      "description": "One of: web-export, godot, unity, unreal, desktop, rooms-server, central-server, c-api, lod, shadows, collision, render-lod, render-optimize, core-loop, local-project, game-plan, warnings, physics-async, structs, net, web-multiplayer, scenes, input, combat, character, enemies, npcs, quests, inventory, economy, vehicles, puzzles, sport, ui-webui, ui-screens, world-terrain, minion-waves, game-cinematic, debug-inspector, world-environment, hud, audio-core, i18n-text, save-persistence, settings-graphics, asset-preload, ai-navigation, fx-kits, glossary, kit-api, third-party, player, render-budget, scene-optim, porting, game-schema, module-calls, module-calls-native, godot-host, kit-modules, kit-structures, kit-third-party, abi, modding, game-engine-contract, game-engine, animal-behavior, animal-breeding, animal-taming, asset-cache, asset-meta, automation-logistics, bots-skirmish, build-modular, build-placement, camera-strategy, cards-deck, central-client, character-first-person, character-forms, character-platformer, character-roster, character-top-down, checkpoint-rest, collect-tokens, collection-packs, combat-abilities, combat-attacks, combat-defense, combat-duel, combat-grabs, combat-hit-reactions, combat-lockon, combat-melee, combat-moveset, combat-projectiles, combat-ranged, combat-stamina, combat-threat, combat-turns, combat-weakpoints, companion-control, coop-session, craft-recipes, custom-paint, defense-towers, defense-waves, desktop-launcher, dialogue-voice, display-fullscreen, drop-parachute, encounters-waves, enemy-boss, enemy-horde, enemy-stalker, engine-interop, faction-system, farming-crops, fishing-rod, fps-abilities, fps-armory, fps-deathmatch, fps-network, fps-tactical, fx-ability-vfx, game-endings, hazard-traps, horror-sanity, hud-minimap, hud-mmo, hud-moba, hud-nameplates, hud-open-world, hud-tactical, input-actions, input-pointer-lock, input-remap, input-virtualpad, interaction-feedback, interaction-system, interaction-telekinesis, inventory-equipment, launch-pad, life-ecosystem, life-genetics, light-flashlight, loot-ground, lore-journal, machines-production, match-knockout, mission-system, moba-hero, moba-lanes, mount-ride, movement-boost, movement-dash, movement-flight, movement-grapple, movement-grind, movement-modes, movement-traversal, net-async, net-authoritative, net-claim, net-lobby, net-physics, net-rollback, net-rooms, net-state, net-transport, net-zones, npc-dialogue, npc-pedestrian, party-rounds, photo-mode, present-native, progression-levels, puzzle-circuits, race-kart, render-raytrace, render-realism, research-samples, resource-extraction, resource-nodes, rts-ai, rts-production, run-map, save-online, shared-memory, social-party, spawn-system, sport-golf, stealth-detection, stealth-takedown, storage-containers, survival-needs, tactics-grid, time-rewind, trade-shop, traffic-system, travel-worlds, ui-cursor, ui-endscreen, ui-prompts, ui-theme, units-command, upgrades-boons, vehicle-boostpads, vehicle-damage, vehicle-doors, vehicle-enter-exit, vehicle-rivals, vehicle-spaceship, vehicle-upgrades, wanted-police, weapons-arsenal, weapons-loadout, weapons-mastery, world-access, world-arena, world-atmosphere, world-bindings, world-biomes, world-daynight, world-destructibles, world-district, world-elements, world-fluids, world-grass, world-gravity-zones, world-instances, world-interiors, world-magnetism, world-platforms, world-portals, world-racetrack, world-rooms, world-scene-ground, world-scenery, world-sky-bodies, world-stages, world-streaming, world-tracks, world-vision, world-water, world-weather, wrappers-demo, zone-shrink."
    },
    "section": {
      "type": "string",
      "maxLength": 120,
      "description": "A heading of the topic, its number (\"3.1\", \"§4\") or words of it."
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    }
  }
}
gripforge_docs annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_gamekit_installed — Installed kits of a project (use these first)
Advertised by the server during the last successful anonymous check.
Advertised read-only

Journey — first on an existing project; gripforge_game_audit then says what stands between it and a finished game. Start here for an existing project. Lists the kits installed in a Game Kit project (gkp_…), first and marked priority: id, name, enabled, addedBy (user / agent / auto / preset / default — the interface kits every new game gets), provides, requires and config, plus the rule that goes with them. Versions are for your information (projects always follow the latest): each kit also has version (in the project), latest, delivered { godot | unity | unreal } (the version the last engine delivery carries — a delivered game can run an older one) and pendingMigrations (manual migrations left to you). Installed kits are choices already made for this game: build on them for what they cover and configure them as needed; search the catalogue only for what they do not cover. 0 credits.

gripforge_gamekit_installed input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "project_id"
  ],
  "properties": {
    "project_id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Game Kit project id (gkp_…). Not a dedicated-server project (gpj_…) nor a Library item."
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    }
  }
}
gripforge_gamekit_installed annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_gamekit_install — Install a Game Kit into a project
Advertised by the server during the last successful anonymous check.

Journey — while composing. A kit installed and left empty is not done (audio.core without a sound, ui.endscreen without an end condition): gripforge_game_audit names them. Content is data, not code: generic systems in code (kits, parameters, hooks); levels, characters, weapons, items, balance, texts, assets and inputs as data read at run time; clips, bones, grips and sizes from each asset's passport, never written in code. Add a gameplay kit (a brick) to a Game Kit project (gkp_…); installing marks that the game uses it. Decide it yourself, no confirmation needed. Always the latest version; dependencies are added automatically and listed in added [{ kit, version, requiredBy, capability }] (e.g. game.engine for a kit that requires it). A kit that looks with the mouse (first person, third person, shooters, vehicles, mounts) also brings its companion input.pointer_lock (mouse capture) the first time it is added — listed in added with reason "companion of …"; keep it unless the user wants the cursor visible (remove it alone with gripforge_gamekit_remove), and never code requestPointerLock by hand. Kits are bricks that go together: two kits handling the same thing (e.g. two lightings) are a same-scene overlap, never a game-level conflict — only one is active in a scene. Returns { plan, applied, added, project }; dry_run=true previews without writing. Check gripforge_gamekit_installed first, then gripforge_gamekit_search; tune with gripforge_gamekit_configure. To adapt a kit to the game, go through its extension points first — its configuration, its overridable collections, rules and scripts on its events, hooks documents on the hooks it declares (engine.hooks) — and recode or copy a kit only as a last resort, saying why: a copy is no longer updated. Legacy genre kits (legacy.*) use gripforge_kit. 0 credits.

gripforge_gamekit_install input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "project_id"
  ],
  "properties": {
    "id": {
      "type": "string",
      "pattern": "^[a-z0-9][a-z0-9._-]*$",
      "maxLength": 120,
      "minLength": 2,
      "description": "Kit id to install (e.g. vehicle.driveable). Required unless pack is given."
    },
    "pack": {
      "type": "string",
      "maxLength": 80,
      "description": "Instead of id: a content pack listed by gripforge_gamekit_search (packs[].id, e.g. tree-of-life) — its kits are installed, its configs merged and its documents upserted by id (the project's own documents are kept). Returns { pack, applied, plan: { installed, configured, data }, added, project }."
    },
    "config": {
      "type": "object",
      "description": "Kit config values, validated against the kit configSchema returned by gripforge_gamekit_get. Merged over the current config.",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "reason": {
      "type": "string",
      "maxLength": 300,
      "description": "One sentence: why you do this, recorded in the project history (required in spirit when you go against the installed-kits rule)."
    },
    "dry_run": {
      "type": "boolean",
      "description": "true to return the install plan without writing the project."
    },
    "existing": {
      "enum": [
        "replace",
        "keep"
      ],
      "type": "string",
      "description": "With pack: a pack document whose id the project already has — replace (default) or keep the project's."
    },
    "project_id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Game Kit project id (gkp_…). Not a dedicated-server project (gpj_…) nor a Library item."
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    },
    "allow_planned": {
      "type": "boolean",
      "description": "true to accept kits still marked planned (0.x, no runtime yet). Default false."
    }
  }
}
gripforge_gamekit_install annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_gamekit_remove — Uninstall a Game Kit from a project
Advertised by the server during the last successful anonymous check.
Advertised destructive

Uninstall a kit from a Game Kit project (gkp_…). Remove a kit the user installed (addedBy user in gripforge_gamekit_installed) only when the user asks. game.engine (the engine of the game) and the default kits (ui.menu, input.remap, settings.graphics, ui.prompts, ui.endscreen, save.persistence, audio.core, i18n.text, ui.theme, input.virtualpad, display.fullscreen, asset.preload, asset.cache, ai.navigation on web, addedBy default) are removed only when the user explicitly asks — never to "clean up". A kit other kits depend on, and game.engine always, is not removed by a first call: it answers 409 (kit_in_use, or confirm_required) with details { dependents, confirm } — nothing applied; show the user the dependents, then call again with with_dependents=true and confirm=<token> to remove the kit and its dependents together (the token is bound to the project revision). dry_run=true returns the plan, the dependents and the token without writing. force=true (legacy) removes it and disables its dependents instead; prune=true also drops the dependencies nothing else needs (never game.engine nor a default kit). When the GAME serves what the kit provided (its own terrain for world.ground, its own camera…: a Godot, Unity, Unreal or Bevy project attached with game-attach), pass host_provides=["world.ground"] (or [] for every capability the dependents need from it, listed in details.hostable of the 409): the kit goes ALONE, its dependents stay, and the project declares those capabilities served by the game (hostProvides) — offer this to the user before removing dependents. Returns { applied, removed[], dependents, project }. 0 credits.

gripforge_gamekit_remove input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "project_id",
    "id"
  ],
  "properties": {
    "id": {
      "type": "string",
      "pattern": "^[a-z0-9][a-z0-9._-]*$",
      "maxLength": 120,
      "minLength": 2,
      "description": "Kit id from the catalogue, dotted (e.g. vehicle.driveable, mission.objectives)."
    },
    "force": {
      "type": "boolean",
      "description": "Legacy: remove even when other kits depend on it; they are disabled, not removed."
    },
    "prune": {
      "type": "boolean",
      "description": "true to also remove dependencies that no remaining kit requires (never game.engine nor a default kit)."
    },
    "reason": {
      "type": "string",
      "maxLength": 300,
      "description": "One sentence: why you do this, recorded in the project history (required in spirit when you go against the installed-kits rule)."
    },
    "confirm": {
      "type": "string",
      "maxLength": 80,
      "description": "The confirm token of the previous answer, after the user saw the dependents."
    },
    "dry_run": {
      "type": "boolean",
      "description": "true to return the removal plan (with the dependents and the confirm token) without writing."
    },
    "project_id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Game Kit project id (gkp_…). Not a dedicated-server project (gpj_…) nor a Library item."
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    },
    "host_provides": {
      "type": "array",
      "items": {
        "type": "string",
        "maxLength": 120
      },
      "maxItems": 32,
      "description": "The capabilities the game serves itself in place of this kit (e.g. [\"world.ground\"]; [] = all those its dependents need from it): the kit is removed alone and they are declared in the project (hostProvides). See gripforge_game_host_provides."
    },
    "with_dependents": {
      "type": "boolean",
      "description": "true to remove the kit AND the kits that depend on it (needs confirm)."
    }
  }
}
gripforge_gamekit_remove annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": true
}
gripforge_game_host_provides — Capabilities the game serves itself
Advertised by the server during the last successful anonymous check.

Declare that the GAME serves a capability itself instead of a kit (GameProjectDoc.hostProvides), as the engine host serves physics.character: the user's own Godot / Unity / Unreal / Bevy terrain answers world.ground, its own camera camera.*… With the declaration the kits that require it keep working without a provider kit (none is added, none is removed with its dependents) and remove_kit removes that provider kit ALONE in the same revision. The game must then serve it at run time (GDScript host.provide_service("world.ground", obj), Unity Provide, Unreal ProvideService, C gfk_provide, Rust Host::provide — gripforge_docs topic engine-interop); a kit that asks it before it is served logs a warning naming it. Without add/remove it lists { hostProvides, hostable: { <kit>: capabilities the game could serve in its place } }. remove withdraws a declaration: the default provider kit comes back. dry_run=true previews. Then re-run game-attach in the engine project. 0 credits.

gripforge_game_host_provides input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "project_id"
  ],
  "properties": {
    "add": {
      "type": "array",
      "items": {
        "type": "string",
        "maxLength": 120
      },
      "maxItems": 32,
      "description": "Capabilities the game serves from now on, e.g. [\"world.ground\"] (any version) or [\"world.ground@1.0.0\"]."
    },
    "prune": {
      "type": "boolean",
      "description": "true to also drop the auto-installed provider kits nothing needs any more."
    },
    "reason": {
      "type": "string",
      "maxLength": 300,
      "description": "One sentence recorded in the project history."
    },
    "remove": {
      "type": "array",
      "items": {
        "type": "string",
        "maxLength": 120
      },
      "maxItems": 32,
      "description": "Capabilities a kit serves again (its default provider is installed back)."
    },
    "dry_run": {
      "type": "boolean",
      "description": "true to return the plan without writing."
    },
    "project_id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Game Kit project id (gkp_…). Not a dedicated-server project (gpj_…) nor a Library item."
    },
    "remove_kit": {
      "type": "string",
      "pattern": "^[a-z0-9][a-z0-9._-]*$",
      "maxLength": 120,
      "minLength": 2,
      "description": "A provider kit to remove alone in the same revision (e.g. world.scene_ground); without add, the capabilities it provides to its dependents are declared."
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    }
  }
}
gripforge_game_host_provides annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_gamekit_configure — Configure an installed Game Kit
Advertised by the server during the last successful anonymous check.

Journey — while composing, and to fix what gripforge_game_audit reports (its defects carry the exact config to write). Content is data, not code: generic systems in code (kits, parameters, hooks); levels, characters, weapons, items, balance, texts, assets and inputs as data read at run time; clips, bones, grips and sizes from each asset's passport, never written in code. Tune an installed kit: merge config values validated against the kit configSchema (read it with gripforge_gamekit_get), or patch the config as a document (patch: set a nested key, add / change / remove one element of a list without rewriting it), or toggle enabled to switch the kit off without uninstalling it. Configure installed kits freely rather than recoding what they do (game.engine: startScene, startEntry, flow.title, story flags). The interface look of a game is ui.theme: set preset (scifi-lowpoly, military, fantasy-medieval, cyberpunk-neon, cartoon-bright, horror-dark, minimal-clean, retro-pixel) for a complete look, and only the colours, typography, shapes or glyphs that must differ (they win over the preset); gripforge_game_theme_from_concept fills it from the art direction. No key on screen in game outside a tutorial: never write a legend of the controls into a HUD text (hud.action hint, captions, labels) and leave ui.prompts bar off (its default); a tutorial step pushes its prompt with ui.prompts show(), and ui.prompts context: true / interaction.feedback worldPrompt: true are set only when the gameplay needs contextual prompts (the key is then the live binding, never written) — the controls live in Options › Controls (input.remap). Switching game.engine off follows the confirmation of a removal: the first call answers 409 confirm_required with details.confirm; send it back with enabled=false after the user agreed — never on your own. Returns { kit, project } with the new project revision. Call this AFTER gripforge_gamekit_install. 0 credits.

gripforge_gamekit_configure input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "project_id",
    "id"
  ],
  "properties": {
    "id": {
      "type": "string",
      "pattern": "^[a-z0-9][a-z0-9._-]*$",
      "maxLength": 120,
      "minLength": 2,
      "description": "Kit id from the catalogue, dotted (e.g. vehicle.driveable, mission.objectives)."
    },
    "patch": {
      "type": "object",
      "description": "The config as a document, instead of rewriting a whole list: { set: { \"<dotted path>\": value }, append: { \"<path of a list>\": [items] }, update: { \"<path>\": [{ match: { key: value }, set: { … } }] }, remove: { \"<path>\": [values or { key: value }] } } — add, change or remove one element of a config list (an item with the id of an element replaces it); remove on an object (a table: audio.core sounds, music.playlists) takes out the keys named, { remove: { sounds: [\"music.combat\"] } }; a list the project does not write starts from the kit default. Validated against the configSchema like config.",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "config": {
      "type": "object",
      "description": "Kit config values, validated against the kit configSchema returned by gripforge_gamekit_get. Merged over the current config.",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "reason": {
      "type": "string",
      "maxLength": 300,
      "description": "One sentence: why you do this, recorded in the project history (required in spirit when you go against the installed-kits rule)."
    },
    "confirm": {
      "type": "string",
      "maxLength": 80,
      "description": "game.engine enabled=false: the confirm token of the previous answer."
    },
    "enabled": {
      "type": "boolean",
      "description": "false to disable the kit at runtime while keeping it installed; true to re-enable."
    },
    "project_id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Game Kit project id (gkp_…). Not a dedicated-server project (gpj_…) nor a Library item."
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    }
  }
}
gripforge_gamekit_configure annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_gamekit_dependencies — Dependency graph of a project or kit
Advertised by the server during the last successful anonymous check.
Advertised read-only

Dependency graph of a Game Kit project: nodes (installed kits with version, provides, requires), edges labelled by capability, same-scene overlaps (conflicts: several enabled providers of one exclusive capability) and unresolved requirements. Pass project_id for the installed graph; pass a kit id instead to read the declared requires / provides tree of a catalogue kit before installing it. Call this BEFORE gripforge_gamekit_remove with force. 0 credits.

gripforge_gamekit_dependencies input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "id": {
      "type": "string",
      "pattern": "^[a-z0-9][a-z0-9._-]*$",
      "maxLength": 120,
      "minLength": 2,
      "description": "Catalogue kit id to inspect instead of a project (returns its manifest tree)."
    },
    "project_id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Game Kit project id (gkp_…). Default: the workspace’s most recently updated project when id is not given."
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    }
  }
}
gripforge_gamekit_dependencies annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_gamekit_update — Bring Game Kits to their latest version
Advertised by the server during the last successful anonymous check.

Projects always follow the latest version of their kits: the studio updates them automatically when a project is opened. Use this to do it now. Dry-run by default: returns the plan (from / to version, migrations). Pass apply=true to apply it. A migration with auto=false is never applied by itself: it is your task — apply its note (config, data) then call again. Omit id to check every installed kit. 0 credits.

gripforge_gamekit_update input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "project_id"
  ],
  "properties": {
    "id": {
      "type": "string",
      "pattern": "^[a-z0-9][a-z0-9._-]*$",
      "maxLength": 120,
      "minLength": 2,
      "description": "Installed kit to update. Omit to check every installed kit."
    },
    "apply": {
      "type": "boolean",
      "description": "true to apply the update to the latest version (automatic migrations run). Default false = plan only."
    },
    "project_id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Game Kit project id (gkp_…). Not a dedicated-server project (gpj_…) nor a Library item."
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    }
  }
}
gripforge_gamekit_update annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_gamekit_deliver — Deliver Game Kits into an engine project
Advertised by the server during the last successful anonymous check.

Journey — kits into a local engine project, in place (with the CLI: gripforge game-attach <gkp_id> <folder>, Bevy, Godot, Unity or Unreal; never an export); a final delivery is last. Run gripforge_game_audit then gripforge_validate_release first: deliver a game whose verdict is complete and whose release is ready, or tell the user what is left. Content is data, not code: generic systems in code (kits, parameters, hooks); levels, characters, weapons, items, balance, texts, assets and inputs as data read at run time; clips, bones, grips and sizes from each asset's passport, never written in code. Turn catalogue kits, or the enabled kits of a Game Kit project, into engine files: Godot gets GDScript, scenes and config under gripforge/kits/<kit>/, Unity gets an embedded UPM package plus C# files and Unreal a Blueprint-first plugin for every kit with an engine delivery (gameplay and net.* kits; recipes otherwise), web needs nothing. Kits always deliver at their latest version; a kit the project copied locally is delivered from its copy. Call with dry_run=true FIRST: it returns the plan (files to add / keep / modify / delete, conflicts, dependencies, post-install steps) and never charges. Pass project_state (the current gripforge/gamekits.lock.json, path → sha256 of the files under gripforge/, engineVersion) so updates keep your edits and detect conflicts. Then call without dry_run to get the bundle. The hosted endpoint cannot write into your project: write bundle.files following plan.actions in order (backup, write, writeBin from bundle.binaries, delete with .uid / .import siblings, writeLock with bundle.lock), or use the npm client with project_dir (gripforge_gamekit_deliver_local), or the editor bridge. A blocked plan answers 409 with the plan: a file edited in the engine project is reported (modified_file), never overwritten silently; force backs it up then overwrites it. Credits: the first delivery of a kit major version to an engine costs 1 credit per workspace; re-deliveries, updates within a major, dry runs and the web target are free.

gripforge_gamekit_deliver input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "target"
  ],
  "properties": {
    "kits": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "id"
        ],
        "properties": {
          "id": {
            "type": "string",
            "pattern": "^[a-z0-9][a-z0-9._-]*$",
            "maxLength": 120,
            "minLength": 2,
            "description": "Kit id from the catalogue, dotted (e.g. vehicle.driveable, mission.objectives)."
          },
          "config": {
            "type": "object",
            "description": "Kit config, validated against its configSchema.",
            "propertyNames": {
              "type": "string"
            },
            "additionalProperties": {}
          },
          "bindings": {
            "type": "object",
            "description": "Asset slot → Library item id (lib_…).",
            "propertyNames": {
              "type": "string"
            },
            "additionalProperties": {
              "type": "string"
            }
          }
        }
      },
      "maxItems": 16,
      "description": "Kits to deliver (at most 16). Omit to deliver the enabled kits of project_id."
    },
    "mode": {
      "enum": [
        "install",
        "update",
        "uninstall"
      ],
      "type": "string",
      "description": "install (default), update to the latest catalogue version, or uninstall (needs project_state.lock)."
    },
    "force": {
      "type": "boolean",
      "description": "true → back up then overwrite edited managed files and existing seed files."
    },
    "target": {
      "enum": [
        "godot",
        "unity",
        "unreal",
        "web",
        "rust"
      ],
      "type": "string",
      "description": "Engine to deliver to: godot (addon + kit files), unity (UPM package + C# files), unreal (plugins), web (native, nothing to write), rust (the Rust / Bevy runtime: nothing to write either — the answer is the native compatibility report of the kits or of project_id: which kits have a Rust module, which do not, and what blocks the project from running on the Bevy player; a web delivery of that player always holds both backends, WebGPU and WebGL2, with the automatic selection and fallback — one backend alone is an error). Kits without an engine delivery get recipes."
    },
    "dry_run": {
      "type": "boolean",
      "description": "true → plan only: no bundle, never charged. Do this first."
    },
    "project_id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Game Kit project (gkp_…) whose enabled kits, config and slot bindings are delivered when kits is omitted."
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    },
    "project_state": {
      "type": "object",
      "properties": {
        "lock": {
          "anyOf": [
            {
              "type": "object",
              "propertyNames": {
                "type": "string"
              },
              "additionalProperties": {}
            },
            {
              "type": "null"
            }
          ],
          "description": "Current gripforge/gamekits.lock.json content, null when absent."
        },
        "files": {
          "type": "object",
          "description": "path → sha256 hex of every file under gripforge/ and assets/gripforge/ (at most 5000).",
          "propertyNames": {
            "type": "string"
          },
          "additionalProperties": {
            "type": "string"
          }
        },
        "engineVersion": {
          "type": "string",
          "maxLength": 80,
          "description": "Engine version, e.g. 4.3.stable."
        }
      },
      "description": "What the engine project contains now. Without it the plan assumes an empty project (add-only)."
    }
  }
}
gripforge_gamekit_deliver annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_game_capabilities — Capabilities report of a project
Advertised by the server during the last successful anonymous check.
Advertised read-only

Journey — while composing; gripforge_game_audit includes this report, with the creatures, the controls, the playtest and the definition of done of the genre. Report the capabilities a Game Kit project provides, what is still missing for a goal (a preset id from gripforge_gamekit_search or a comma-separated list of capabilities) and which catalogue kits would fill each gap. The installed kits (gripforge_gamekit_installed) come first; call this BEFORE gripforge_gamekit_install to pick the next kit. 0 credits.

gripforge_game_capabilities input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "project_id"
  ],
  "properties": {
    "goal": {
      "type": "string",
      "maxLength": 400,
      "description": "Preset id (e.g. from gripforge_gamekit_search presets) or comma-separated capabilities to reach. Default: the project’s own preset."
    },
    "project_id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Game Kit project id (gkp_…). Not a dedicated-server project (gpj_…) nor a Library item."
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    }
  }
}
gripforge_game_capabilities annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_game_art_direction — Read or update the shared art direction of a game
Advertised by the server during the last successful anonymous check.

Store artistic intent on the existing Game Kit project (game.engine), separately from gameplay: look, world/theme, palette, proportions/materials/lighting notes and device budget. Read first, then set with expected_revision. Unspecified fields are preserved; null clears a field or the profile. Existing assets and rendering are not modified. Use this direction with map wizard.look, VFX look, asset prompts, lighting and UI tools, then inspect gripforge_game_asset_plan and actual-engine captures. 0 credits.

gripforge_game_art_direction input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "project_id",
    "action"
  ],
  "properties": {
    "action": {
      "enum": [
        "get",
        "set"
      ],
      "type": "string",
      "description": "get reads the profile/revision; set applies a partial profile update."
    },
    "project_id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Game Kit project id (gkp_…). Not a dedicated-server project (gpj_…) nor a Library item."
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    },
    "art_direction": {
      "anyOf": [
        {
          "type": "object",
          "properties": {
            "look": {
              "anyOf": [
                {
                  "enum": [
                    "stylized",
                    "painted",
                    "toon",
                    "anime",
                    "realistic",
                    "lowpoly",
                    "pixel"
                  ],
                  "type": "string"
                },
                {
                  "type": "null"
                }
              ],
              "description": "Rendering look, separate from the game style: stylized (neutral) | painted | toon | anime | realistic | lowpoly | pixel. Old values (handpainted, cartoon, low_poly…) are read as aliases. Omit for the style default."
            },
            "notes": {
              "anyOf": [
                {
                  "type": "string",
                  "maxLength": 1600
                },
                {
                  "type": "null"
                }
              ]
            },
            "theme": {
              "anyOf": [
                {
                  "type": "string",
                  "maxLength": 120
                },
                {
                  "type": "null"
                }
              ]
            },
            "device": {
              "anyOf": [
                {
                  "enum": [
                    "mobile",
                    "desktop"
                  ],
                  "type": "string"
                },
                {
                  "type": "null"
                }
              ]
            },
            "palette": {
              "anyOf": [
                {
                  "type": "array",
                  "items": {
                    "type": "string",
                    "pattern": "^#[a-f\\d]{6}$"
                  },
                  "maxItems": 12
                },
                {
                  "type": "null"
                }
              ]
            }
          },
          "additionalProperties": false
        },
        {
          "type": "null"
        }
      ],
      "description": "set: shared project art direction patch. Null clears the profile or an individual field."
    },
    "expected_revision": {
      "type": "integer",
      "maximum": 9007199254740991,
      "description": "set: revision returned by get; stale changes are refused.",
      "exclusiveMinimum": 0
    }
  }
}
gripforge_game_art_direction annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_game_publish — Publish a game (preview or release) or take it offline
Advertised by the server during the last successful anonymous check.

Publish the Game Kit project so its play link opens without an account, and start its online server if the game is online (same API as the Publish button and `gripforge game-publish`). mode=preview shares a TEST build: no release checks (completion, animation proof), the project is marked preview; use it to let testers join an online game before it is release-ready. mode=release (default) runs the release checks and refuses with the blockers if the build is not ready. unpublish=true takes the game and its online server offline (mode is ignored). Needs an editor role on the owning workspace. Returns published, publicationMode and playUrl. 0 credits.

gripforge_game_publish input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "project_id"
  ],
  "properties": {
    "mode": {
      "enum": [
        "preview",
        "release"
      ],
      "type": "string",
      "description": "preview: shared test build without release checks; release (default): full release checks."
    },
    "unpublish": {
      "type": "boolean",
      "description": "true: take the game offline instead of publishing."
    },
    "project_id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Game Kit project id (gkp_…). Not a dedicated-server project (gpj_…) nor a Library item."
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    }
  }
}
gripforge_game_publish annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_game_app_icon — Generate or reuse the app icon of a game
Advertised by the server during the last successful anonymous check.

One original square icon from the saved game art direction, delivered as PNG, macOS ICNS and Windows ICO in the Library. get returns the latest complete pack. quote prices generation; run queues it after the quoted cost is accepted. Existing icons are reused for free unless regenerate=true. Poll the returned job with gripforge_generation_read. Use files for direct and Steam builds; Steam store artwork is separate.

gripforge_game_app_icon input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "project_id",
    "action"
  ],
  "properties": {
    "action": {
      "enum": [
        "get",
        "quote",
        "run"
      ],
      "type": "string",
      "description": "get reads the saved pack; quote prices it; run queues the accepted quote."
    },
    "project_id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Game Kit project id (gkp_…). Not a dedicated-server project (gpj_…) nor a Library item."
    },
    "regenerate": {
      "type": "boolean",
      "description": "Generate a new icon instead of reusing the saved pack."
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    },
    "idempotency_key": {
      "type": "string",
      "pattern": "^[a-zA-Z0-9_.:-]{8,160}$",
      "description": "Stable request key for retries; use a new key for a distinct request."
    },
    "expected_revision": {
      "type": "integer",
      "maximum": 9007199254740991,
      "description": "Project revision returned by quote, required for generation.",
      "exclusiveMinimum": 0
    }
  }
}
gripforge_game_app_icon annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_game_theme_from_concept — Fill the game interface theme from a generated UI concept
Advertised by the server during the last successful anonymous check.

Generic concept → theme pipeline for a Game Kit project: the saved art direction (gripforge_game_art_direction: look, theme, palette, notes, device) becomes ONE interface concept image (title, main menu, HUD with health, a weapon card, key prompts), a vision pass reads its design tokens (colour roles, radius, border width, button shape, padding, letter case, weight, the closest open-licence font, glyph style, closest preset) and they are written as the ui.theme config (contrast repaired). The concept is kept in the Library (kind concept, category ui). action=quote prices it: 1 credit per run (quote it and ask the user before run). Without regenerate the latest concept of the project is reused with the tokens already read from it (0 credits), so a run after a dry run applies exactly what the dry run showed; reread=true reads the concept again (1 credit). dry_run=true writes nothing. run returns a generation job: poll it with gripforge_generation_read; its result carries config, tokens, fixes, previous_config and revision_before for a rollback (gripforge_gamekit_configure ui.theme with previous_config).

gripforge_game_theme_from_concept input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "project_id",
    "action"
  ],
  "properties": {
    "action": {
      "enum": [
        "quote",
        "run"
      ],
      "type": "string",
      "description": "quote prices it and returns next; run queues it (needs expected_revision from quote)."
    },
    "reread": {
      "type": "boolean",
      "description": "true runs the vision pass again on the reused concept (1 credit) instead of its saved tokens."
    },
    "dry_run": {
      "type": "boolean",
      "description": "true: generate and read the tokens without writing the project."
    },
    "project_id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Game Kit project id (gkp_…). Not a dedicated-server project (gpj_…) nor a Library item."
    },
    "regenerate": {
      "type": "boolean",
      "description": "true draws a new concept image; default reuses the latest concept of the project."
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    },
    "expected_revision": {
      "type": "integer",
      "maximum": 9007199254740991,
      "description": "run: the revision returned by quote.",
      "exclusiveMinimum": 0
    }
  }
}
gripforge_game_theme_from_concept annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_game_asset_plan — Audit project asset roles or search compatible candidates
Advertised by the server during the last successful anonymous check.
Advertised read-only

Read asset requirements from enabled Game Kits and game.engine archetypes. Without slot: report missing files/bindings, template defaults, metadata style/theme conflicts, unknown classifications and technical ranking concerns. With slot: search accessible Library/Community candidates for that role and the saved art direction; known visual conflicts are excluded. No purchase, generation or binding. Metadata checks do not replace visual/animation/gameplay review in the actual engine. 0 credits.

gripforge_game_asset_plan input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "project_id"
  ],
  "properties": {
    "q": {
      "type": "string",
      "maxLength": 400,
      "description": "Optional candidate search terms for this slot."
    },
    "slot": {
      "type": "string",
      "maxLength": 160,
      "description": "Omit for the audit; pass a role id from the audit to search candidates."
    },
    "limit": {
      "type": "integer",
      "maximum": 48,
      "minimum": 1,
      "description": "Maximum candidates, default 12."
    },
    "source": {
      "enum": [
        "all",
        "workspace",
        "community"
      ],
      "type": "string",
      "description": "Search scope; default all accessible assets."
    },
    "project_id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Game Kit project id (gkp_…). Not a dedicated-server project (gpj_…) nor a Library item."
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    }
  }
}
gripforge_game_asset_plan annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_game_project — List, create, read, bind, feed, set the controls of or delete Game Kit projects
Advertised by the server during the last successful anonymous check.

Journey — create (or reuse the user's project), then bind a model to each creature slot the game has (get carries the creatures report) and set the controls: action=controls applies the control scheme of the gameplay, a proposal to adapt. Before telling the user the game is done: gripforge_game_audit Content is data, not code: generic systems in code (kits, parameters, hooks); levels, characters, weapons, items, balance, texts, assets and inputs as data read at run time; clips, bones, grips and sizes from each asset's passport, never written in code. Manage Game Kit projects (gkp_…): the container holding installed kits, their lockfile, asset bindings and data collections. action=list lists the workspace projects; create needs name and takes a preset (see gripforge_gamekit_search; adventure is the reference game of game.engine) or an explicit kits map — every new project gets game.engine first (the engine of the game: scenes, archetypes, scripts, life cycle; its answer carries the engine start pack { structure, scene, blocks, order, next, rules } and added, the kits installed for dependencies), then the default kits ui.menu (title / pause / options / load and save screen), input.remap (key remapping), settings.graphics (graphics options), ui.prompts (on-screen key prompts that follow remapping and the gamepad), ui.endscreen (end screen and credits), save.persistence (save slots, quick save, autosave), audio.core (game audio: mixer, music, effects, event → sound table), i18n.text (game texts in the player’s language: translation tables in the translations collection, ICU plurals) ui.theme (the design of every interface as kit config: colours, font, shapes, key glyphs; unset = built-in look) and input.virtualpad (the on-screen gamepad of touch screens, mode auto: shown on a touch screen without a gamepad, Touch controls tab) and display.fullscreen (the game in fullscreen: F11, the Options entry, start in fullscreen with atStart, the player’s choice saved), asset.preload (the files of the game loaded in phases — first playable frame, background, next scene ahead — each file once, checked; progress as state and events shown by ui.menu, ui.endscreen and hud.action) and asset.cache (the files kept on the device between visits: IndexedDB, then Cache Storage with a service worker, then the HTTP cache; quota and eviction) and, on web, ai.navigation (the paths of the game over its real collision geometry: route and steer for NPCs, enemies and click-to-move), addedBy default: keep and configure them (never recode a pathfinding: ask ai.navigation and adapt its config, the hook navigation.plan and the event navigation.blocked; never recode an asset loader, a download queue or a cache: adapt their rules, asset_preload documents, scenes ahead and cache quota instead), leave one out ({ "ui.menu": false }) or remove it only if the user asks. They hold for EVERY game, a compiled module with its own page or a custom page included: that page mounts the menu, Options › Controls and Video, fullscreen and the prompts from the bindings through the kits’ web views (gripforge-ui.mjs, GET /api/v1/hud) or their adapter, never its own copy; get returns the full ProjectDetail (installed kits, bindings, capabilities, missing, playUrl); bind maps asset slots to Library items (lib_…, null to clear); data reads a collection or upserts / removes documents validated against the kits’ schemas (replace=true swaps the whole collection); collection asset_passports = the game’s own passport of a Library model, over the global GripForge one (what it leaves out is inherited): { id: <slot>, item: lib_…, passport: { kits: { lod: { ratios, minTriangles, fit, maxError… } } } } changes the mesh levels of that model for this game only (its own game copy; ratios: [] = no level; characters keep their bone weights); controls reads or sets the controls: without scheme it returns the control schemes of the catalogue (fps, third_person, moba_click, top_down, platformer, fighting, vehicle, rts, point_click: movement by keys or by click, what the mouse is for, expected actions and keys, touch layout), the project scheme, the one its kits suggest, every action with its effective key and the keys two actions share in one mode (warnings with a proposed reassignment, never a refusal — also in get → report.controls); with scheme and dry_run=true it returns the diff of keys the scheme would write; with scheme alone it applies it (input.actions overrides marked source: scheme, the touch layout of input.virtualpad, the actions of the ui.prompts help bar — the bar itself stays off: no key on screen outside a tutorial). Choose the scheme from the kind of game, never from a kit default: Kits offer capabilities that can be switched off and tuned; the game makes one high-level gameplay choice and enables only the coherent set that choice needs: what is not chosen is off and invisible, and no kit default is imposed on the game. The generic modules propose choices, the request picks one: name the kind of game, take its control scheme from the table below (usually the only one allowed), and embed only what that scheme uses on each device — its input sources, its on-screen controls on a touch screen, its settings (remapping, sensitivity, inversion, capture, dead zone only where the scheme uses them). Every option is a choice of the request too: the network input frame is embedded only for a multiplayer game, each other option only when asked. Write the choice into the project: gripforge_game_project create with controls=<scheme>, or action=controls scheme=<scheme> on an existing game (dry_run first, reset=true to drop old key overrides). A dungeon crawler is played with the mouse, not on W A S D. In play, input.scheme (a default kit) implements that choice: it follows the device in hand (keyboard and mouse, gamepad, touch) with the variant of the scheme for it, takes the vehicle scheme while the player drives, gives the input to the interface while a menu, a dialogue or a text field is open, and the Options show per device only the controls the scheme uses; tune it within the choice (input.scheme allowed: the closed list the player may switch between, usually one; variants; composites for held / double / charged / chorded / combo actions), never by enabling every option. Gameplay choices (kind → control scheme, per device): - MOBA → `moba_click` (mouse+keys: click to move, right click = context, settings: remap; gamepad: stick, aim assist, settings: remap, deadzone, aim_assist; touch: tap to move, on screen: tap_world, settings: touch_layout). A hero is ordered with the mouse (right click to move / attack, abilities toward the cursor); a gamepad moves it with the stick. Interaction feedback: interaction.feedback style bold, on: highlight, cursor, confirm, fail, sound, orderMarker; interaction.system pointerTarget: true. - Real-time strategy → `rts` (mouse+keys: click to move, right click = context, settings: remap; gamepad: click to move, settings: remap, deadzone; touch: tap to move, on screen: stick + buttons + tap_world, settings: touch_layout). Units are selected and ordered with the cursor; nothing is moved with W A S D. Interaction feedback: interaction.feedback style default, on: highlight, cursor, confirm, fail, sound, moveMarker, orderMarker; interaction.system pointerTarget: true. - Dungeon crawler / action RPG seen from above → `arpg_click` (mouse+keys: click to move, right click = context, settings: remap; gamepad: stick, aim assist, settings: remap, deadzone, aim_assist; touch: tap to move, on screen: buttons + tap_world, settings: touch_layout). Played with the mouse: click to walk, click an enemy to attack, right click for the special; the left stick on a gamepad, a tap on a touch screen. W A S D is not the default for this genre. Interaction feedback: interaction.feedback style default, on: highlight, nearbyHint, worldPrompt, cursor, holdGauge, confirm, fail, sound, orderMarker; interaction.system pointerTarget: true. - Top-down shooter / twin-stick roguelike → `top_down` (mouse+keys: WASD, right click = aim, settings: remap; gamepad: stick, aim assist, settings: remap, deadzone, aim_assist; touch: virtual stick, on screen: stick + buttons, settings: touch_layout). Constant dodging needs direct movement (W A S D / left stick) with the cursor or right stick to aim. The game may also allow: arpg_click. Interaction feedback: interaction.feedback style default, on: highlight, worldPrompt, holdGauge, confirm, fail, sound. - Point-and-click adventure → `point_click` (mouse+keys: click to move, right click = context, settings: remap; gamepad: stick, aim assist, settings: remap, deadzone, aim_assist; touch: tap to move, on screen: buttons + tap_world, settings: touch_layout). A free cursor: click where to go and what to use. Interaction feedback: interaction.feedback style default, on: highlight, nearbyHint, worldPrompt, cursor, confirm, fail, sound, moveMarker; interaction.system pointerTarget: true. - First-person shooter / survival → `fps` (mouse+keys: WASD, captured mouse, right click = aim, settings: remap, mouse_sensitivity, invert_y, pointer_capture; gamepad: stick, right stick looks, aim assist, settings: remap, deadzone, stick_sensitivity, invert_y, aim_assist; touch: virtual stick, right stick looks, on screen: stick + buttons, settings: touch_layout, stick_sensitivity, invert_y). W A S D and the captured mouse to look (right stick on a gamepad). Interaction feedback: interaction.feedback style subtle, on: highlight, worldPrompt, holdGauge, confirm, fail, sound. - Third-person action / open world → `third_person` (mouse+keys: WASD, captured mouse, right click = aim, settings: remap, mouse_sensitivity, invert_y, pointer_capture; gamepad: stick, right stick looks, aim assist, settings: remap, deadzone, stick_sensitivity, invert_y, aim_assist; touch: virtual stick, right stick looks, on screen: stick + buttons, settings: touch_layout, stick_sensitivity, invert_y). W A S D relative to the camera and the captured mouse (right stick) to turn it. Interaction feedback: interaction.feedback style default, on: highlight, nearbyHint, worldPrompt, holdGauge, confirm, fail, sound. - Platformer → `platformer` (mouse+keys: WASD, settings: remap; gamepad: stick, settings: remap, deadzone; touch: virtual stick, on screen: stick + buttons, settings: touch_layout). Direct movement and jump, no pointer. Interaction feedback: interaction.feedback style subtle, on: worldPrompt, confirm, fail, sound. - Fighting → `fighting` (mouse+keys: WASD, settings: remap; gamepad: stick, settings: remap, deadzone; touch: virtual stick, on screen: buttons, settings: touch_layout). One key per blow, no pointer. No interaction.feedback. - Racing / vehicles → `vehicle` (mouse+keys: vehicle, settings: remap; gamepad: vehicle, settings: remap, deadzone; touch: vehicle, on screen: stick + buttons, settings: touch_layout). Throttle, brake and steering; no pointer. Interaction feedback: interaction.feedback style subtle, on: worldPrompt, confirm, fail. - Turn-based combat / tactics → `point_click` (mouse+keys: click to move, right click = context, settings: remap; gamepad: stick, aim assist, settings: remap, deadzone, aim_assist; touch: tap to move, on screen: buttons + tap_world, settings: touch_layout). Each turn is played with the cursor or a tap (combat.turns, tactics.grid): pick a unit or an action, then its cell or its target; no direct movement. Interaction feedback: interaction.feedback style default, on: highlight, cursor, confirm, fail, sound; interaction.system pointerTarget: true. - Card game / deckbuilder / pack opening → `point_click` (mouse+keys: click to move, right click = context, settings: remap; gamepad: stick, aim assist, settings: remap, deadzone, aim_assist; touch: tap to move, on screen: buttons + tap_world, settings: touch_layout). Cards and packs are played with the cursor or a tap (cards.deck on combat.turns; collection.packs for a pack-opening or gacha game with an album): pick a card or a pack, then its target or the next object to turn over; no direct movement. Interaction feedback: interaction.feedback style default, on: highlight, cursor, confirm, fail, sound; interaction.system pointerTarget: true. - Puzzle → `third_person` (mouse+keys: WASD, captured mouse, right click = aim, settings: remap, mouse_sensitivity, invert_y, pointer_capture; gamepad: stick, right stick looks, aim assist, settings: remap, deadzone, stick_sensitivity, invert_y, aim_assist; touch: virtual stick, right stick looks, on screen: stick + buttons, settings: touch_layout, stick_sensitivity, invert_y). The puzzle kits (puzzle.circuits, puzzle.beams) sit in the world: the player reaches them with the game's character, seen from behind by default, in first person or with the cursor when the game is built that way. The game may also allow: fps, point_click. Interaction feedback: interaction.feedback style default, on: highlight, nearbyHint, worldPrompt, holdGauge, confirm, fail, sound. - Sports / ball game → `third_person` (mouse+keys: WASD, captured mouse, right click = aim, settings: remap, mouse_sensitivity, invert_y, pointer_capture; gamepad: stick, right stick looks, aim assist, settings: remap, deadzone, stick_sensitivity, invert_y, aim_assist; touch: virtual stick, right stick looks, on screen: stick + buttons, settings: touch_layout, stick_sensitivity, invert_y). sport.ball on foot: the athlete moves with W A S D or the left stick and kicks where it faces; in its car mode, the vehicle controls. The game may also allow: vehicle. Interaction feedback: interaction.feedback style subtle, on: worldPrompt, confirm, fail, sound. - Golf / mini-golf → `point_click` (mouse+keys: click to move, right click = context, settings: remap; gamepad: stick, aim assist, settings: remap, deadzone, aim_assist; touch: tap to move, on screen: buttons + tap_world, settings: touch_layout). sport.golf: the shot is aimed with the free cursor (the ball goes where the pointer is) and played with a click or a tap that stops the power gauge; nobody walks, so no W A S D and no captured pointer; the left stick turns the aim on a gamepad. No interaction.feedback. - Flight / space combat → `vehicle` (mouse+keys: vehicle, settings: remap; gamepad: vehicle, settings: remap, deadzone; touch: vehicle, on screen: stick + buttons, settings: touch_layout). Throttle, yaw and pitch on the keys or the sticks, no pointer: vehicle.spaceship pilots a starfighter (the space_combat preset) and the same vehicle controls drive a plane. Interaction feedback: interaction.feedback style subtle, on: worldPrompt, confirm, fail. Per device: the cursor per kind of target only with a mouse; on a gamepad the prompt shows the button of the active gamepad, on a touch screen the text alone (ui.prompts / input.actions promptFor); the designated target comes from input.scheme target() (cursor, aim axis, stick). Interactions must be visible. Install interaction.feedback for any game with interactive objects (not for a pure fighting game) and set its elements from the gameplay table row; never draw an interaction prompt in a kit or a script: kits that offer an interaction pass their kind to interaction.use.register(entity, label, action, kind) (or interactable.kind on an archetype), and slow uses get a hold (interactable.hold / interaction.system.holdSeconds) instead of a custom timer. Styles and kinds are data (feedback_styles, interaction_kinds): restyle with them, do not recode. Leave the player settings (interaction.feedback.settings) to the menu. A scheme is a starting proposal: a preset applies its own at creation (create takes controls to pick another one — pass the scheme of the kind of game the user asked for — or none), and any key stays changeable with gripforge_gamekit_configure input.actions { overrides: [{ action, keys, buttons?, disabled? }] } — the action of any kit; those entries always win over the scheme. logic chooses where the kits’ logic runs: wasm = logic of the kits in Rust compiled to wasm (Bevy player), the only logic; default wasm (create takes logic too; action=logic without logic reads it, with logic sets it). A game installing a kit without a Rust module cannot start: logic reports runs: none and fallback: the kits. delete needs confirm=true. Call this first to create or pick the project, then gripforge_gamekit_installed (existing project) or gripforge_gamekit_install. 0 credits.

gripforge_game_project input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "action"
  ],
  "properties": {
    "kits": {
      "type": "object",
      "description": "create: explicit kit toggles { \"vehicle.driveable\": true, … } on top of the preset. Unchecking a required kit fails with toggle_requires. The default kits (ui.menu, input.remap, settings.graphics, ui.prompts, ui.endscreen, save.persistence, audio.core, i18n.text, ui.theme, input.virtualpad, display.fullscreen, asset.preload, asset.cache, ai.navigation on web) are included unless set to false here — only when the user asked for it.",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {
        "type": "boolean"
      }
    },
    "name": {
      "type": "string",
      "maxLength": 120,
      "minLength": 1,
      "description": "create: project name."
    },
    "force": {
      "type": "boolean",
      "description": "controls: also replace a touch layout or a help bar the game edited (kept by default)."
    },
    "logic": {
      "enum": [
        "wasm"
      ],
      "type": "string",
      "description": "create, logic: wasm = logic of the kits in Rust compiled to wasm (Bevy player), the only logic; default wasm. logic without it reads the current choice."
    },
    "reset": {
      "type": "boolean",
      "description": "controls: also drop the key overrides the game wrote itself (kept by default), so the game ends exactly on the scheme — what a game made before the schemes needs to move to one. Preview with dry_run."
    },
    "action": {
      "enum": [
        "list",
        "create",
        "get",
        "bind",
        "data",
        "controls",
        "logic",
        "delete"
      ],
      "type": "string",
      "description": "list | create | get | bind | data | controls | logic | delete."
    },
    "preset": {
      "type": "string",
      "maxLength": 80,
      "description": "create: preset id whose default kits are installed (gripforge_gamekit_search returns presets)."
    },
    "remove": {
      "type": "array",
      "items": {
        "type": "string",
        "maxLength": 120
      },
      "maxItems": 500,
      "description": "data: document ids to remove."
    },
    "scheme": {
      "type": "string",
      "maxLength": 40,
      "description": "controls: the control scheme to show (dry_run) or apply — fps, third_person, moba_click, arpg_click, top_down, platformer, fighting, vehicle, rts, point_click: the one of the kind of game (gameplay choices above; a dungeon crawler → arpg_click, a MOBA → moba_click, an RTS → rts). Omit to read the schemes and the project controls."
    },
    "target": {
      "enum": [
        "bevy",
        "web",
        "godot",
        "unity",
        "unreal"
      ],
      "type": "string",
      "description": "create: pass the confirmed engine explicitly (bevy = the GripForge player, Rust/Bevy; web is its former name). Ask the user to choose Bevy (GripForge player) / Godot / Unity / Unreal Engine before creating if unknown, unless their folder already holds an engine project (then that engine; gripforge game-attach <gkp_id> <folder> brings the game into it). API default web is for compatibility, not an engine choice."
    },
    "confirm": {
      "type": "boolean",
      "description": "delete: must be true. The project, its revisions and data are removed."
    },
    "dry_run": {
      "type": "boolean",
      "description": "controls: true returns the diff of keys without writing."
    },
    "replace": {
      "type": "boolean",
      "description": "data: true to replace the whole collection with documents."
    },
    "bindings": {
      "type": "object",
      "description": "bind: { slot: lib_… | null } — Library item per asset slot declared by the installed kits, null clears. A model bound to a creature slot gets its animations by itself as far as that is free (the answer carries the chain in creatures); see gripforge_gamekit_creatures.",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {
        "anyOf": [
          {
            "type": "string"
          },
          {
            "type": "null"
          }
        ]
      }
    },
    "controls": {
      "type": "string",
      "maxLength": 40,
      "description": "create: the control scheme of the kind of game the user asked for (gameplay choices above: one scheme, usually the only one allowed), applied at creation instead of the preset’s own or of the one the kits suggest; none keeps the kits’ own keys."
    },
    "documents": {
      "type": "array",
      "items": {
        "type": "object",
        "propertyNames": {
          "type": "string"
        },
        "additionalProperties": {}
      },
      "maxItems": 500,
      "description": "data: documents to upsert (each with its id), validated against the kit schema."
    },
    "collection": {
      "type": "string",
      "maxLength": 80,
      "description": "data: collection name declared by an installed kit (e.g. missions, npcs, zones)."
    },
    "project_id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Game Kit project id (gkp_…). Required for get, bind, data, controls, logic and delete."
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    }
  }
}
gripforge_game_project annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_gamekit_creatures — Creatures of a project: a model and its animations for every unit
Advertised by the server during the last successful anonymous check.

Journey — when the game has creatures, right after creating or binding: no unit stays a capsule, every model gets its movement and action clips (read from its passport, never named in code). gripforge_game_audit folds this report with the rest and applies the free steps with fix=true The living units of a Game Kit project (gkp_…) — player, heroes, enemies, bosses, minions, monsters, NPCs: the creature slots its kits declare. Two rules: NO creature ships as a capsule, and a model ships WITH its animations (movement AND action). action=report (default): every creature slot with its status (bound | fallback = a capsule in game), the model bound, the clips the slot plays (locomotion, action), the ones the model lacks, and its chain (steps: clone | rig | animate | more_clips, each done / running / proposed with its tool, free or its credits). action=propose: ranked Library models for each unbound slot — the workspace first, then the Community — with the reasons of the rank (source, slot and role words, game theme, size, rigged, animated, triangle budget). YOU judge: read the reasons, pick the model that fits the game (any monster beats a capsule), bind it with gripforge_game_project { action: "bind" }; nothing is final, rebind any time. A slot with no proposal at all carries defect creature_no_model: generate a model (paid — quote and ask first), never leave the capsule. action=animate: run the free steps of the chain now for the bound models (a free Community model is copied into the workspace and bound in place of the original; the standard clip pack is retargeted, 0 credits; wait=true waits for the result, else it runs in the background — read report again). action=fill: bind the best free proposal to every unbound creature slot, then animate (what the hosted creation does). Nothing here spends credits: the automatic rig, a priced Community asset and generated motions always come back as proposed steps for you to quote and ask about. Binding a model through gripforge_game_project already starts its chain. 0 credits.

gripforge_gamekit_creatures input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "project_id"
  ],
  "properties": {
    "slot": {
      "type": "string",
      "maxLength": 80,
      "description": "report / propose: only this creature slot (e.g. enemy_grunt, moba_hero_3)."
    },
    "wait": {
      "type": "boolean",
      "description": "animate / fill: wait for the retargets instead of running them in the background."
    },
    "brief": {
      "type": "string",
      "maxLength": 2000,
      "description": "fill: what the game is about, to rank the models (theme, mood)."
    },
    "limit": {
      "type": "integer",
      "maximum": 12,
      "minimum": 1,
      "description": "propose: models per slot (default 5)."
    },
    "slots": {
      "type": "array",
      "items": {
        "type": "string",
        "maxLength": 120
      },
      "maxItems": 64,
      "description": "animate: only these slots (slot or slot:variant). Default: every bound creature slot."
    },
    "action": {
      "enum": [
        "report",
        "propose",
        "animate",
        "fill"
      ],
      "type": "string",
      "description": "report (default) | propose | animate | fill."
    },
    "project_id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Game Kit project id (gkp_…). Not a dedicated-server project (gpj_…) nor a Library item."
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    }
  }
}
gripforge_gamekit_creatures annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_gamekit_anim_layers — Animation layers: what an action keeps or blends of the body, and of the movement
Advertised by the server during the last successful anonymous check.

The animation layers of the characters of a Game Kit project (gkp_…), part of the generic animation layer of the kits (module-kits packages/gamekits/src/runtime/anim-layers.ts, mixed in Rust by the players: Bevy on the web and natively, libgfkits for Godot / Unity / Unreal). An action (attack, heavy_attack, punch, kick, ability, shoot, reload, throw, block, emote, interact, hit, body) plays on the parts of the body its layer takes over the locomotion, which keeps the rest: attacking while running keeps the legs running and the player moving. Defaults: a one-hand attack while moving = upper body (legs and hips to the locomotion, waist blended), standing still = whole body; movement free. NEVER recode a blend of animations, a bone mask or a movement lock in game code: set the layer here. action=table (default): the masks (full, upper, torso, lower, legs, arms, arm_right, arm_left, head, upper_right, upper_left; regions hips, spine, chest, head, arm_l, arm_r, leg_l, leg_r), the action families with their states and their default layer. action=get: the layers the project sets — actionLayers of its character kits (character.third_person, character.first_person, character.top_down: by family or by state such as attack3) and weaponLayers of weapons.loadout (by weapon id). action=set { kit, key, layer }: one entry, layer = { mask, still, weight, mode: replace | additive, fadeIn, fadeOut, movement: free | slow | lock | root, moveScale } (mask / still: a mask name or { regions: { <region>: 0..1 }, bones: { <bone>: 0..1 } }); the kit validates it, mods may override it (the keys are moddable), the hook character.action decides the movement once per action and player.action reports it. action=clear { kit, key }: back to the defaults. Existing games get the defaults without any change; nothing is recompiled. 0 credits.

gripforge_gamekit_anim_layers input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "key": {
      "type": "string",
      "maxLength": 64,
      "description": "set / clear: an action family (attack, shoot…), a state (attack3) or, for weapons.loadout, a weapon id."
    },
    "kit": {
      "enum": [
        "character.third_person",
        "character.first_person",
        "character.top_down",
        "weapons.loadout"
      ],
      "type": "string",
      "description": "set / clear: the kit whose table is changed (weapons.loadout: by weapon id)."
    },
    "layer": {
      "type": "object",
      "description": "set: { mask, still, weight, mode, fadeIn, fadeOut, movement, moveScale }.",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "action": {
      "enum": [
        "table",
        "get",
        "set",
        "clear"
      ],
      "type": "string",
      "description": "table (default) | get | set | clear."
    },
    "reason": {
      "type": "string",
      "maxLength": 300,
      "description": "One sentence: why, recorded in the project history."
    },
    "project_id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Game Kit project id (gkp_…): required for get, set and clear; table needs none."
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    }
  }
}
gripforge_gamekit_anim_layers annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_game_engine — The engine of a game: structure, bricks, report, next steps
Advertised by the server during the last successful anonymous check.
Advertised read-only

Journey — the build order of the content; its last step is gripforge_game_audit, not "it loads". Content is data, not code: generic systems in code (kits, parameters, hooks); levels, characters, weapons, items, balance, texts, assets and inputs as data read at run time; clips, bones, grips and sizes from each asset's passport, never written in code. Read game.engine of a Game Kit project (gkp_…) — a direction, never a gate. action=start (default): the start pack { version, active, structure { engine, kits, content counts, code }, scene, blocks digest, order (scene → playable → assets → archetypes → story → scripts → ui → validate → deliver → code), next [{ step, tool, args, why }], code (where game code goes per engine), rules } and the full content report. action=blocks: the brick catalogue computed from the manifests — entity kinds, archetype components (kit, schema, example), script verbs (conditions / actions with arguments and shorthand), script sugars (interact, enter, leave, scene, talked, quest, state, gives), quest step types, NPC behaviours, worlds, layers, events, variables; scope=catalog adds the bricks of kits not installed (install <kit>). action=points (game.engine 1.3): what can be plugged into the kits without recoding them — without kit, the compact view of every installed kit (hooks with their mutable fields and whether they cancel, events emitted and listened to, registries, collections and config keys with what is moddable or live, settings, verbs, components, services, completeness counters); with kit, the full extension points of that kit with schemas. Look here before writing anything new: the kit or tool that already does it is the proven way, above all for what makes a game complete (input, camera, combat, saving, HUD, menus, sound). The kits are built to be adapted, nothing in them is fixed: adapt one as deep as the game needs through its extension points — its config (gripforge_gamekit_configure), its documents and registries (gripforge_game_content, gripforge_game_project data), taps on its hooks (documents of the hooks collection), scripts whose rules react to its events and change data — in the project, or packaged as a mod (gripforge_game_mods); write something new only when no kit does it, and then as a kit following the extension contract; a local copy of a kit last, saying why. action=report: { ok, errors, warnings, stats } — an error means that piece is left out of the game (the rest plays), a warning that it loads with something missing; each issue may carry a fix { tool, args }. action=next: the next steps only. A game with everything in code is valid: content first, kits second, code for the rest. 0 credits.

gripforge_game_engine input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "project_id"
  ],
  "properties": {
    "kit": {
      "type": "string",
      "maxLength": 64,
      "description": "points: one kit id (installed or not): its full extension points with schemas."
    },
    "scene": {
      "type": "string",
      "maxLength": 64,
      "description": "start: also return this scene document."
    },
    "scope": {
      "enum": [
        "installed",
        "catalog"
      ],
      "type": "string",
      "description": "blocks: installed (default) or catalog."
    },
    "action": {
      "enum": [
        "start",
        "structure",
        "blocks",
        "points",
        "report",
        "next"
      ],
      "type": "string",
      "description": "start (default) | structure | blocks | points | report | next."
    },
    "project_id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Game Kit project id (gkp_…). Not a dedicated-server project (gpj_…) nor a Library item."
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    }
  }
}
gripforge_game_engine annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_game_mods — Mods of a game: list, validate, install, enable, order
Advertised by the server during the last successful anonymous check.

Journey — while building or after: a packaged way to apply the same extension mechanisms (config, documents, hooks, reactions) as one separable unit — a variant to switch on, content added over the game, a game opened to its players' mods (an option of the developer). gripforge_game_audit then plays the modded game. The mods of a Game Kit project (gkp_…), docs/mods-engine.md: a mod (gripforge.mod/1) is data applied over the project before the kits mount — config keys and collection documents the kits declare moddable (configPatch by dotted path, data.<collection> { remove, patch, add, order }, hooks documents that tap decisions, scripts whose rules react to events) — whole or not at all, never code. The kits are built to be adapted without recoding them — interceptable (hooks), registrable (registries), modifiable (config, documents, patches) and reactive (rules on events that change data): that is the normal, recommended way to build a game, written in the project (see gripforge_game_engine points) or packaged as a mod. A mod packages those changes as one separable unit: a variant to switch on or off (a hard mode, a season event) without copying the project, content added over the game, and — an option of the developer — a game opened to its players' mods. action=list (default): the game policy (config.mods of game.engine: enabled, disabled, order, deny), every mod with its status (applied | disabled | refused) and issues ({ level, code, path, message }), the documents each added, the fingerprint the network handshake compares. action=validate { mod }: a dry run — the project with this mod added (or replacing the one with its id), applied as the host would: its status and issues, nothing written. action=install { mod }: writes it to the mods collection (validated against the mod schema). action=remove { id }. action=enable / disable { id }: the policy list mods.disabled. action=order { ids }: these mods first, in this order (a mod always comes after those it depends on). 0 credits.

gripforge_game_mods input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "project_id"
  ],
  "properties": {
    "id": {
      "type": "string",
      "maxLength": 64,
      "description": "remove, enable, disable: the mod id."
    },
    "ids": {
      "type": "array",
      "items": {
        "type": "string",
        "maxLength": 64
      },
      "maxItems": 64,
      "description": "order: the mods first, in this order."
    },
    "mod": {
      "type": "object",
      "description": "validate, install: the gripforge.mod/1 document ({ id, version, requires?, depends?, conflicts?, config?, configPatch?, data? }).",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "action": {
      "enum": [
        "list",
        "validate",
        "install",
        "remove",
        "enable",
        "disable",
        "order"
      ],
      "type": "string",
      "description": "list (default) | validate | install | remove | enable | disable | order."
    },
    "project_id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Game Kit project id (gkp_…). Not a dedicated-server project (gpj_…) nor a Library item."
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    }
  }
}
gripforge_game_mods annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_game_scenes — Scenes and levels of a game: list, create, order, link, assets, load plan
Advertised by the server during the last successful anonymous check.

The scenes and levels of a Game Kit project (gkp_…), game.engine 1.7 — use this tool, never code a scene manager. A scene has a kind: interface (no world: title, main menu, credits — kits build nothing, the renderers draw no world), 2d, 3d (default), loading (shown while the next scene loads), cinematic; a role: menu (entered first, Play leads on), level (levels follow the order), credits, other; next (the scene that follows: Play from the menu, the end of a level, the script verb next_scene); loading (how it shows when its files are not ready — on demand: preloaded or cached files go straight in, a screen comes up only after sceneFlow.showAfterMs; overlay = ui.menu's loading screen with the real asset.preload progress, none, background = the scene left stays until this one is ready, or a scene id: a loading scene or an interface scene of the game); loadingScreen { image, tips, background, title } (several screens per game: one per scene, or flow.loadingScreen); background { image, video, color, scene } of an interface scene; unload (release | keep); transition (replace: the scene left is unloaded | add: it stays loaded under this one) and below (what the scenes under an added scene do: run, pause = drawn but frozen, hide = not drawn). Scenes stack and keep their states at run time — the game changes scene by program (engine.scenes.enter(scene, entry, { unload: false, previous: { visible, paused } }), push / pop / unload / activate / set(scene, { visible, paused }); script verbs load_scene { unload: false }, push_scene, pop_scene, set_scene): a scene kept loaded is frozen in memory and resumed at once; nothing a loaded scene uses is freed. The flow (game.engine config sceneFlow): transition replace | add, menu scene | overlay (scene: the title of ui.menu is a scene of its own, entered first with no world behind it — synthesised as menu when the project writes none; every new game and every opened game has it), menuScene, loading overlay | scene | none | background, loadingScene, showAfterMs, minLoadingMs, loadTimeout (s), onFail retry | enter | wait, retries, loadingScreen, unload. Each scene loads its files before it is entered (asset.preload, progress on the loading screen) and leaving it frees its instances and the memory of the files only it used (never the disk cache); hooks engine.scene.change (redirect or refuse a change) and engine.scene.release, events engine.scene.loading / loaded / unloaded / refused for mods. The asset list of a scene (scene_assets: files with role, phase, size, shared) is generated from its content (instances → archetype models, the global slots a played scene needs, world, HUD, music, menu art) — retouch it by hand or with assets_put; asset.preload uses it as one more source, never a restriction. action=list (default; scene: one scene with its files and plan): the flow (menu, start, levels, loading), each scene (kind, role, next, instances, world kit, files, written or generated list), the scene issues of the report, the check of the asset lists and the load plan (per scene in play order: what entering it loads, what leaving it frees, what is shared, and the loading screen of that transition). action=create { id, kind?, role?, title?, next?, loading?, background?, world?, at? (index) } | update { id, set: {…} } (null clears a key) | remove { id } | order { ids } (these first, in this order) | link { id, next } (next null: unlink) | flow { set: { menu, menuScene, transition, loading, loadingScene, showAfterMs, minLoadingMs, loadTimeout, onFail, retries, loadingScreen, unload } } | menu { id?, title?, background? } (writes the menu scene as a document, first, role menu) | assets { scene? } (generate or refresh the lists; files written by hand are kept) | assets_put { scene, files } | assets_check (missing file, file used by nothing, duplicate, list out of date). dry_run answers the new state without writing. Every write answers the new state. Scene content (instances, entries, zones, scripts) stays with gripforge_game_content. 0 credits.

gripforge_game_scenes input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "project_id"
  ],
  "properties": {
    "at": {
      "type": "integer",
      "maximum": 9007199254740991,
      "minimum": 0,
      "description": "create: its index in the order of the scenes."
    },
    "id": {
      "type": "string",
      "maxLength": 64,
      "description": "create, update, remove, link, menu: the scene id."
    },
    "ids": {
      "type": "array",
      "items": {
        "type": "string",
        "maxLength": 64
      },
      "maxItems": 200,
      "description": "order: the scenes first, in this order."
    },
    "set": {
      "type": "object",
      "description": "update: the scene keys to change; flow: the sceneFlow keys.",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "kind": {
      "enum": [
        "interface",
        "2d",
        "3d",
        "loading",
        "cinematic"
      ],
      "type": "string",
      "description": "create: the kind of the scene (default 3d)."
    },
    "next": {
      "anyOf": [
        {
          "type": "string",
          "maxLength": 64
        },
        {
          "type": "null"
        }
      ],
      "description": "create, link: the scene that follows (link: null unlinks)."
    },
    "role": {
      "enum": [
        "menu",
        "level",
        "credits",
        "other"
      ],
      "type": "string",
      "description": "create: its part in the game."
    },
    "files": {
      "type": "array",
      "items": {
        "type": "object",
        "propertyNames": {
          "type": "string"
        },
        "additionalProperties": {}
      },
      "maxItems": 4000,
      "description": "assets_put: the files of the scene ({ id, slot? | path?, role, phase?, bytes?, shared? }; source manual by default)."
    },
    "scene": {
      "type": "string",
      "maxLength": 64,
      "description": "list: one scene (its files and plan); assets, assets_put: the scene."
    },
    "title": {
      "type": "string",
      "maxLength": 160,
      "description": "create, menu: the title (an i18n.text key preferably)."
    },
    "world": {
      "type": "object",
      "description": "create: { kit, config?, doc? } the world kit of a 3d / 2d scene.",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "action": {
      "enum": [
        "list",
        "create",
        "update",
        "remove",
        "order",
        "link",
        "flow",
        "menu",
        "assets",
        "assets_put",
        "assets_check"
      ],
      "type": "string",
      "description": "list (default) | create | update | remove | order | link | flow | menu | assets | assets_put | assets_check."
    },
    "dry_run": {
      "type": "boolean",
      "description": "Every write: answer the new state without writing."
    },
    "loading": {
      "type": "string",
      "maxLength": 64,
      "description": "create: a loading scene id, overlay or none."
    },
    "background": {
      "type": "object",
      "description": "create, menu: { image?, video?, color?, scene? } of an interface scene.",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "project_id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Game Kit project id (gkp_…). Not a dedicated-server project (gpj_…) nor a Library item."
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    }
  }
}
gripforge_game_scenes annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_game_content — Drop content into a game: scenes, archetypes, scripts, quests…
Advertised by the server during the last successful anonymous check.

Journey — the content of the game, as data (documents, config), never as code. Once written, gripforge_game_audit lists what a game of its genre usually has, as proposals (a quest, a way to win or lose, dialogues…) Content is data, not code: generic systems in code (kits, parameters, hooks); levels, characters, weapons, items, balance, texts, assets and inputs as data read at run time; clips, bones, grips and sizes from each asset's passport, never written in code. Read and write the content of a Game Kit project (gkp_…) — what game.engine builds the game from, no engine code needed. kind: archetype (an entity template: kind prop|npc|…, asset { item: lib_… } bound to content:<id> | { slot }, components claimed by kits — see gripforge_game_engine blocks — and gives { quest, offer, progress?, thanks? } for "this NPC gives this quest"), scene (world { kit, config?, doc? }, entries, instances [{ id, archetype, at, yaw?, place?, set? }], zones, layers, ui), script (gripforge.script/1: { id, on: <instance> | archetype:<id> | scene:<id>, rules: [{ when, if?, then, else?, once? }] } with sugars { "interact": "self" }, { "enter": zone }, { "state": { open: false } }, { "quest": id, "is": "completed" }, { "talked": npc }, engine verbs set_state, play_clip, set_solid, show, hide, enable_script, disable_script, load_scene, end_game, call, set_talk and kit verbs as shorthand { "give_item": "key" }), mission (alias quest), dialogue, npc, item, translations, code_module (what game code registers: verbs, components, services, entity kinds), zone, trigger. action=list (kind optional: counts), get (kind, id), put (kind, doc or docs: upsert, validated against the declaring kit schema), remove (kind, id), validate (dry run of a put: the report it would give), place (scene, archetype or asset lib_…, at, yaw?, id?, place ground|none: the placement on the ground is baked once on the server, the same on every engine), bake (re-bake the placements of a scene after its world changed). Writes return the content report after the change; the report never refuses a write — only a document invalid for its schema is. 0 credits.

gripforge_game_content input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "project_id",
    "action"
  ],
  "properties": {
    "at": {
      "type": "array",
      "items": {
        "type": "number"
      },
      "maxItems": 3,
      "minItems": 3,
      "description": "place: position [x, y, z] in metres (+Y up)."
    },
    "id": {
      "type": "string",
      "maxLength": 120,
      "description": "get / remove: the document id; place: the instance id (default <archetype>_<n>)."
    },
    "doc": {
      "type": "object",
      "description": "put / validate: the document (with its id).",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "set": {
      "type": "object",
      "description": "place: component overrides of this instance.",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "yaw": {
      "type": "number",
      "description": "place: rotation around +Y in radians."
    },
    "docs": {
      "type": "array",
      "items": {
        "type": "object",
        "propertyNames": {
          "type": "string"
        },
        "additionalProperties": {}
      },
      "maxItems": 200,
      "description": "put / validate: several documents of the same kind."
    },
    "kind": {
      "enum": [
        "archetype",
        "scene",
        "script",
        "mission",
        "quest",
        "dialogue",
        "npc",
        "item",
        "translations",
        "code_module",
        "zone",
        "trigger"
      ],
      "type": "string",
      "description": "The content kind (list without kind: counts per kind)."
    },
    "asset": {
      "type": "string",
      "maxLength": 64,
      "description": "place: a Library asset (lib_…) instead of an archetype: its archetype is the one using it, or a new prop."
    },
    "place": {
      "enum": [
        "ground",
        "none"
      ],
      "type": "string",
      "description": "place: ground (default) snaps to the scene ground; none keeps y."
    },
    "scene": {
      "type": "string",
      "maxLength": 64,
      "description": "place / bake: the scene id (place default: the first scene)."
    },
    "action": {
      "enum": [
        "list",
        "get",
        "put",
        "remove",
        "validate",
        "place",
        "bake"
      ],
      "type": "string",
      "description": "list | get | put | remove | validate | place | bake."
    },
    "dry_run": {
      "type": "boolean",
      "description": "put / remove: validate and report without writing."
    },
    "archetype": {
      "type": "string",
      "maxLength": 64,
      "description": "place: the archetype of the instance."
    },
    "project_id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Game Kit project id (gkp_…). Not a dedicated-server project (gpj_…) nor a Library item."
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    }
  }
}
gripforge_game_content annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_game_play_url — Play URL of a Game Kit project
Advertised by the server during the last successful anonymous check.
Advertised read-only

Journey — to look at the running game. Share it as finished only when gripforge_game_audit says complete and gripforge_validate_release says ready; otherwise say what is left. Get the browser play URL of a Game Kit project so a human (or a screenshot step) can run its current revision in the web runtime. Reads the project bundle and returns { url, absolute }; absolute is built on the GripForge origin of this key. Call it AFTER gripforge_gamekit_install or gripforge_game_project bind to check the result live. 0 credits.

gripforge_game_play_url input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "project_id"
  ],
  "properties": {
    "project_id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Game Kit project id (gkp_…). Not a dedicated-server project (gpj_…) nor a Library item."
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    }
  }
}
gripforge_game_play_url annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_game_test — Playtest a Game Kit project
Advertised by the server during the last successful anonymous check.
Advertised read-only

Journey — after each change: it also checks what the game chose (its scheme's gestures, fullscreen, right button, pointer capture, texts against the bindings). A playtest that passes is not a finished game: gripforge_game_audit (playtest="run" runs this test) gives the verdict and everything the tester cannot see. Play the project headless and report what works and what is broken. Run it after building or changing a game, before telling the user it is done. An automatic player spawns, walks, follows the mission waypoints, uses what offers a prompt, picks things up and attacks enemies. Probes check each capability the game provides (character control, combat, XP and levels, inventory, interactions, missions, needs, gathering, crafting, building, machines, world counters). Detectors flag a stuck player, unreachable goals, kit exceptions, NaN positions, a player under the ground, enemies that never reach the player, and step time. Then it checks the game on what it CHOSE, on a fresh run (lines game.*): the gestures its control scheme promises (a click game: click to walk, held to follow the cursor, click an enemy to strike, held to keep striking), fullscreen when the game offers it, the right button when the game gives it a role (no browser menu), the pointer captured exactly when the scheme looks with the mouse, and its texts (title, help, tutorial, dialogue) against the real bindings — never a fixed W A S D in a click game; nothing is imposed on a game that did not choose it. The frame rate is · not verified here: only a real page measures it (the play page reports it to the audit). Returns { summary, text, report, next }: text has one line per result, ✓ pass, ⚠ warning, ✕ failure, · not checked, each with its time, position, entity or kit; "provoked" means the tester set the condition up through the kit service. Fix the ✕ lines first, then run it again. report.notCovered lists the capabilities no probe looks at. report.replay replays the same inputs; pass it back as replay to check a fix against the same run. Deterministic: same project, seed and budget, same report. Runs in the compute service, about 5–20 s. 0 credits.

gripforge_game_test input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "project_id"
  ],
  "properties": {
    "lang": {
      "enum": [
        "en",
        "fr"
      ],
      "type": "string",
      "description": "Language of text (default en)."
    },
    "seed": {
      "type": "integer",
      "maximum": 9007199254740991,
      "minimum": -9007199254740991,
      "description": "Seed of the run (default 1). The same seed gives the same report."
    },
    "replay": {
      "type": "object",
      "description": "report.replay of an earlier run: plays the same inputs again (seed and budget come from it).",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "project_id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Game Kit project id (gkp_…). Not a dedicated-server project (gpj_…) nor a Library item."
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    },
    "budget_seconds": {
      "type": "integer",
      "maximum": 300,
      "minimum": 5,
      "description": "Game time to play, in seconds (default 120)."
    }
  }
}
gripforge_game_test annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_game_audit — Audit a game: what is left before it is finished
Advertised by the server during the last successful anonymous check.

One report of everything that stands between a Game Kit project (gkp_…) and a FINISHED game of its genre — run it before telling the user a game is done, and again after each round of fixes. It aggregates, by severity (blocker / major / minor): creatures (slots drawn as a capsule, models without a skeleton, missing movement or action clips, the animation chain in progress), controls (no control scheme, the suggested one, keys shared by two actions in one mode, playable actions without a key), content (missing capabilities, required slots, the game.engine report, the core loop rule: an explicit game tick by genre — content.core_loop:tick, fixed for free by fix=true; the source checks are gripforge_core_loop_check), the last headless playtest (failures, warnings, the keys / models / animations probes, the checks of what the game chose — promised gestures, fullscreen, right button, pointer capture, texts —, capabilities no probe covers), the frame rate measured in a real page (sections.framerate: measured, or unverified — never call the game smooth while it is unverified; under 30 fps it is a major defect), keys shown in game (completeness common.no_key_hints, major: a ui.prompts help bar, build.placement keyHints or ui.menu keyHints turned on, a HUD text that lists keys or mouse buttons — no key on screen outside a tutorial), the default screens (sections.screens: on the KitHost page the host mounts them; a compiled module or a custom page must mount the menu, Options › Controls and Video, fullscreen when offered and the prompts from the bindings through the kits’ web views or adapter — a missing kit or a failing screen is a major defect, and a screen no real page has opened is screens.unverified, a major defect: say "not verified", never done) and completeness: what a finished game of the genre has beyond the literal request (MOBA: distinct heroes with Q/W/E/R, minions, towers, jungle monsters, shop, respawn; FPS: weapon, ammo, reload, crosshair, enemies; platformer: checkpoints, collectibles, end of level; racing: laps, ranking, AI opponents… and for every game a way to win AND to lose, title / pause / end screens, sound, a HUD, touch controls), checked against facts of the project, never a declaration. Each defect carries fix { tool, args, note, auto?, credits? }: call it as given. Returns { verdict: complete | playable_with_defects | incomplete, headline, genre, counts, defects, next (ordered calls), sections, text, play_url }. fix=true first applies what is free and safe (the best free Library model on each capsule — rebind at will —, the free standard clips, the suggested control scheme) and reports it in fixes. playtest="run" plays the game headless first (5–20 s); the default reads the last playtest and says when it is stale. Never refuses a write and never spends: paid fixes (a priced model, a rig, a generation) come back with their price to ask the user about. Aim for verdict complete; if you stop before, tell the user exactly what is left. 0 credits.

gripforge_game_audit input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "project_id"
  ],
  "properties": {
    "fix": {
      "type": "boolean",
      "description": "true: apply the free and safe fixes first (free models on capsules, standard clips, suggested control scheme), then read. Nothing paid is ever done."
    },
    "brief": {
      "type": "string",
      "maxLength": 2000,
      "description": "Free words about the game (theme, setting): they weigh in the model proposals."
    },
    "playtest": {
      "enum": [
        "last",
        "run"
      ],
      "type": "string",
      "description": "last (default): read the stored playtest of the project. run: play it headless now, then read."
    },
    "project_id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Game Kit project id (gkp_…). Not a dedicated-server project (gpj_…) nor a Library item."
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    }
  }
}
gripforge_game_audit annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_moba_roster — Set the champions of a MOBA project
Advertised by the server during the last successful anonymous check.

Journey — a MOBA needs distinct heroes; then gripforge_game_audit for the minions, towers, jungle monsters and the rest of a finished MOBA. Turn champions into the playable roster of a moba project (preset "moba"). Pass the Library ids of 1 to 10 champions that carry an ability pack (the items made by gripforge_abilities_generate: rigged model + basic_attack and ability_q…r clips). Writes the moba_heroes and abilities collections (ids <hero>__ability_q), binds each champion to moba_hero_<n> and the player's champion (player, else the first) to player_character. Bots play the other champions. Returns the heroes with their attack and Q/W/E/R. Then gripforge_game_play_url to play. 0 credits.

gripforge_moba_roster input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "project_id",
    "heroes"
  ],
  "properties": {
    "heroes": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "maxItems": 10,
      "minItems": 1,
      "description": "Library ids (lib_…) of champions with an ability pack, in roster order."
    },
    "player": {
      "type": "string",
      "description": "The champion the player controls (one of heroes); default the first."
    },
    "project_id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Game Kit project id (gkp_…). Not a dedicated-server project (gpj_…) nor a Library item."
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    }
  }
}
gripforge_moba_roster annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_ability_vfx — Give every ability of a game its cast effect
Advertised by the server during the last successful anonymous check.

Journey — after the roster; gripforge_game_audit lists it among what a finished MOBA has. Write and bind a cast effect for each ability of a Game Kit project that has none: an area gets a ground shockwave, a line a bolt and its trail, an arc a sweeping crescent, a self cast a rising aura; colour from the ability's words (fire, frost, wind, holy…), size from its range, ultimates larger. The project needs the fx.ability_vfx kit (the moba preset installs it) and an abilities collection (gripforge_moba_roster writes it). Effects are procedural sources saved as VFX items and bound to ability_vfx:<ability id>, immediately. replace: true rewrites the existing ones; abilities limits to some ids. A hand-made or generated VFX bound to the same slot takes over. 0 credits.

gripforge_ability_vfx input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "project_id"
  ],
  "properties": {
    "replace": {
      "type": "boolean",
      "description": "Rewrite abilities that already have an effect (default: keep them)."
    },
    "abilities": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "maxItems": 80,
      "description": "Only these ability ids (default: all)."
    },
    "project_id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Game Kit project id (gkp_…). Not a dedicated-server project (gpj_…) nor a Library item."
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    }
  }
}
gripforge_ability_vfx annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_moba_map — Generate, dress, check and set the map of a MOBA project
Advertised by the server during the last successful anonymous check.

The map of a moba project as a gameplay plan: bounds, team bases and spawns, 1 to 5 lanes (the minions' paths), structure slots (towers, inhibitors, nexus), jungle zones and camp slots, objective zones, the divider (river: walkable; chasm, lava, void: crossed only at bridges), crossings, bush zones, walls, camera limits and symmetry. action "generate" builds a fair map (mirrored through the centre) from lanes, divider, size, team_size, camps_per_jungle, objectives, bushes, walls and returns it with a playability report; apply: true puts it in the project (moba_maps, the match's map and team size, the camera turn). action "validate" checks a map you pass, or the project's: every lane open end to end, spawns, structures and camps reachable, nothing out of bounds, the declared symmetry respected. action "set" stores an edited map document (refused while it has errors, unless force). action "get" returns the current map and its report. New maps default to style {theme: "sanctum", detail: "high", seed: 11, relief: "landscape"}. action "dress" previews a reusable procedural finish for the current map: jungle plateaus, river banks and paved fords, terraced bases, walkable staircases, carved structures, clustered forests, stone guardians and lilies; apply: true saves only the map document, keeping its lane layout and camera configuration; relief updates the shared terrain mesh, ground queries and stair collisions; landscape is the default, terraced keeps base terraces only, flat keeps a level arena. Themes: sanctum, wildwood, ashen; detail: low, medium, high; seed makes the finish repeatable. Bound Library models and textures take precedence. The scenery kit dresses walls and bushes with the bound models. 0 credits.

gripforge_moba_map input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "project_id"
  ],
  "properties": {
    "id": {
      "type": "string",
      "maxLength": 41,
      "description": "generate: id of the new map (lowercase, digits, _)."
    },
    "map": {
      "type": "object",
      "description": "validate / set: a full map document.",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "name": {
      "type": "string",
      "maxLength": 80,
      "description": "generate: display name of the map."
    },
    "size": {
      "type": "number",
      "maximum": 400,
      "minimum": 100,
      "description": "generate: side of the square map in metres."
    },
    "apply": {
      "type": "boolean",
      "description": "generate / dress: store the result in the project (default: preview only)."
    },
    "force": {
      "type": "boolean",
      "description": "set: store a map that has errors."
    },
    "lanes": {
      "type": "integer",
      "maximum": 5,
      "minimum": 1,
      "description": "generate: number of lanes (default 3)."
    },
    "style": {
      "type": "object",
      "properties": {
        "seed": {
          "type": "integer",
          "maximum": 2147483646,
          "minimum": 0,
          "description": "Repeatable finish, default 11."
        },
        "theme": {
          "enum": [
            "sanctum",
            "wildwood",
            "ashen"
          ],
          "type": "string",
          "description": "sanctum: pale carved stone, gold, contrasting groves and lilies; wildwood: mossy forest; ashen: weathered volcanic stone. Default: sanctum."
        },
        "detail": {
          "enum": [
            "low",
            "medium",
            "high"
          ],
          "type": "string",
          "description": "Procedural decoration budget, default high. Navigation is identical at all levels."
        },
        "relief": {
          "enum": [
            "landscape",
            "terraced",
            "flat"
          ],
          "type": "string",
          "description": "Default landscape: jungle plateaus, river banks and terraced gardens; shared terrain mesh, physics and unit heights. terraced keeps only the gardens; flat keeps a level map."
        }
      },
      "description": "generate / dress: art direction stored with the map. Paved lanes, inset seals, bevelled stone borders, banks, plants, lilies and entrance lights. Bound Library models and textures take precedence.",
      "additionalProperties": false
    },
    "walls": {
      "type": "boolean",
      "description": "generate: rock walls behind the camps (default true)."
    },
    "action": {
      "enum": [
        "get",
        "generate",
        "dress",
        "validate",
        "set"
      ],
      "type": "string",
      "description": "Default: get. dress previews a finish for the existing map, without rebuilding its layout; apply: true saves it."
    },
    "bushes": {
      "type": "boolean",
      "description": "generate: stealth bushes along the lanes (default true)."
    },
    "divider": {
      "enum": [
        "river",
        "chasm",
        "lava",
        "void",
        "none"
      ],
      "type": "string",
      "description": "generate: what separates the halves (default river)."
    },
    "team_size": {
      "type": "integer",
      "maximum": 5,
      "minimum": 1,
      "description": "generate: heroes per team (default 3 for one lane, 5 otherwise)."
    },
    "objectives": {
      "type": "integer",
      "maximum": 4,
      "minimum": 0,
      "description": "generate: epic objectives on the divider."
    },
    "project_id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Game Kit project id (gkp_…). Not a dedicated-server project (gpj_…) nor a Library item."
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    },
    "camps_per_jungle": {
      "type": "integer",
      "maximum": 3,
      "minimum": 0,
      "description": "generate: small camps in each jungle (default 2)."
    }
  }
}
gripforge_moba_map annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_terrain_map_use — Play a terrain studio map in a game
Advertised by the server during the last successful anonymous check.

Make a map of the terrain studio the world of a game that has the world.terrain kit. Pass map (a terrain studio map id, lvl_…) or scene (a scene id, with terrain when the scene has several terrain nodes). The map is baked once into a file (heights, ground roles, lakes and rivers, vegetation, roads, spawn and objective points) stored in the Library and bound to the terrain_map slot; the project data keeps its reference in terrain_maps. The same file is delivered to Godot, Unity and Unreal with the kit. Buildings and other non-vegetation props, and terrain holes, are not carried yet (counted in map.notCarried). Without a bound map world.terrain keeps generating its world from the seed. 0 credits.

gripforge_terrain_map_use input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "project_id"
  ],
  "properties": {
    "map": {
      "type": "string",
      "description": "Terrain studio map id (lvl_…)."
    },
    "scene": {
      "type": "string",
      "description": "Scene id whose terrain node becomes the world (instead of map)."
    },
    "terrain": {
      "type": "string",
      "description": "Terrain node id in the scene (default: its first terrain)."
    },
    "project_id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 4,
      "description": "Game Kit project id (gkp_…). Not a dedicated-server project (gpj_…) nor a Library item."
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Workspace authorized by the current key. Never infer another user’s workspace."
    }
  }
}
gripforge_terrain_map_use annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_joystick_kit — Ready-to-use joystick · Unreal / Godot / Unity
Advertised by the server during the last successful anonymous check.
Advertised read-only

Generate input.joystick source files and installation instructions: touch + mouse, independent dual sticks, radial deadzone, continuous holding and release/focus reset. Unreal runtime Pawn component, Godot CanvasLayer scene, Unity UI component. Feeds the existing movement controller rather than replacing physics, collision or networking. Returns files with relative path/content; the agent writes them into the target project and compiles/tests there. Does not install automatically, modify project settings or claim runtime validation. 0 credits.

gripforge_joystick_kit input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "target"
  ],
  "properties": {
    "accent": {
      "type": "string",
      "default": "#ff681f",
      "pattern": "^#[\\da-f]{6}$",
      "description": "Thumb color, six-digit hexadecimal RGB."
    },
    "layout": {
      "enum": [
        "move",
        "dual"
      ],
      "type": "string",
      "default": "dual",
      "description": "One movement stick, or independent movement + camera sticks."
    },
    "radius": {
      "type": "number",
      "default": 72,
      "maximum": 160,
      "minimum": 32,
      "description": "Stick radius in CSS/UI logical pixels, before engine DPI scaling."
    },
    "target": {
      "enum": [
        "godot",
        "unity",
        "unreal",
        "all",
        "bevy",
        "web"
      ],
      "type": "string",
      "description": "Engine delivery. all returns each of the three source kits; bevy (the GripForge player, also web) has its sticks in input.virtualpad: the answer says how to set it."
    },
    "deadzone": {
      "type": "number",
      "default": 0.15,
      "maximum": 0.5,
      "minimum": 0,
      "description": "Radial deadzone, continuously rescaled to a unit disc."
    }
  }
}
gripforge_joystick_kit annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_abilities — Abilities / skills · three engines
Advertised by the server during the last successful anonymous check.
Advertised read-only

combat.abilities: inspect schema, get an editable Chrono Crab example, validate a pack or export executable Godot, Unity and Unreal source adapters. Shared costs, cooldowns, conditions, targeting, windup/active/recovery and presentation cues. Native adapters require the game combat backend and asset bindings. Returns relative path/content files; no rig/animation/VFX generation or automatic installation. Persist through gripforge_gamekit_configure config.pack or project data. 0 credits.

gripforge_abilities input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "action"
  ],
  "properties": {
    "pack": {
      "type": "object",
      "description": "Versioned ability pack. Read schema/example first; author a reusable pack then validate it.",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "action": {
      "enum": [
        "schema",
        "example",
        "validate",
        "export"
      ],
      "type": "string"
    },
    "target": {
      "enum": [
        "godot",
        "unity",
        "unreal",
        "all"
      ],
      "type": "string"
    },
    "model_asset": {
      "type": "string",
      "pattern": "^lib_[A-Za-z0-9_-]{8,64}$",
      "description": "Library model id bound to the example. Does not rig or animate it."
    }
  }
}
gripforge_abilities annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_ui_screen — Game screen templates
Advertised by the server during the last successful anonymous check.
Advertised read-only

Reusable death/victory screen concepts backed by the existing ui.endscreen Game Kit. List four visual templates, validate or export screen.json + a standalone web/Bevy presenter + runnable preview. No credits, no AI image generation. Connect authoritative game events and acknowledge multiplayer retries; a downed player is not a party defeat. Get health PNGs from gripforge_hud.

gripforge_ui_screen input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "action"
  ],
  "properties": {
    "action": {
      "enum": [
        "templates",
        "export",
        "validate"
      ],
      "type": "string"
    },
    "screen": {
      "type": "object",
      "required": [
        "schema",
        "kit",
        "template",
        "language",
        "title",
        "message"
      ],
      "properties": {
        "kit": {
          "type": "string",
          "const": "ui.endscreen"
        },
        "title": {
          "type": "string",
          "maxLength": 120
        },
        "schema": {
          "type": "string",
          "const": "gripforge.ui-screen/1"
        },
        "message": {
          "type": "string",
          "maxLength": 400
        },
        "language": {
          "enum": [
            "fr",
            "en"
          ],
          "type": "string"
        },
        "template": {
          "enum": [
            "gothic",
            "cinematic",
            "tactical",
            "arcade"
          ],
          "type": "string"
        }
      },
      "additionalProperties": false
    },
    "language": {
      "enum": [
        "fr",
        "en"
      ],
      "type": "string"
    },
    "template": {
      "enum": [
        "gothic",
        "cinematic",
        "tactical",
        "arcade"
      ],
      "type": "string"
    }
  }
}
gripforge_ui_screen annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_creature_rig_schema — Creature rig · schema
Advertised by the server during the last successful anonymous check.
Advertised read-only

Read the reusable creature anatomy/rig workflow, coordinate contract, limits and export formats. Detect anatomy before authoring; source GLB, asset instances and draft rig stay separate. Blender is the worker, GripForge is the review renderer.

gripforge_creature_rig_schema input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {}
}
gripforge_creature_rig_schema annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_creature_analyze — Creature rig · detect anatomy
Advertised by the server during the last successful anonymous check.

Queue multiview mesh inspection and vision anatomy detection for an OWNED GLB. Detect actual body, legs, arms, claws, wings or tail without imposing a humanoid/eight-leg template. Returns a persistent job_id. Poll gripforge_generation_read with include_preview=true for the annotated views, editable profile and uncertainty flags. No rig mutation. 0 GripForge credits; configured server vision/Blender required.

gripforge_creature_analyze input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "source_id"
  ],
  "properties": {
    "kind": {
      "enum": [
        "enemy",
        "character",
        "creatures"
      ],
      "type": "string"
    },
    "name": {
      "type": "string",
      "maxLength": 100,
      "minLength": 1
    },
    "source_id": {
      "type": "string",
      "pattern": "^lib_[A-Za-z0-9_-]{8,64}$"
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100
    },
    "idempotency_key": {
      "type": "string",
      "pattern": "^[a-zA-Z0-9_.:-]{8,160}$"
    }
  }
}
gripforge_creature_analyze annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_creature_rig — Creature rig · manufacture
Advertised by the server during the last successful anonymous check.

Create a NEW private draft character/enemy from a completed creature analysis and optional corrected anatomy. Blender builds the skeleton, surface-smoothed skin weights and procedural starting/diagnostic clips. Grounded leg chains get in-place walk/run with IK. Returns job_id; poll gripforge_generation_read for the Character Studio link, skinned GLB, editable .blend, anatomy and deformation report. Never automatically replaces or validates the source. Every anatomy proposal requires explicit review; use generation_cancel/retry to control durable work. Finger/facial authoring and finished combat choreography are outside v1. 0 GripForge credits.

gripforge_creature_rig input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "analysis_job"
  ],
  "properties": {
    "name": {
      "type": "string",
      "maxLength": 100,
      "minLength": 1
    },
    "profile": {
      "type": "object",
      "description": "Optional corrected anatomy in the exact coordinate system returned by analyze. Read the schema and inspect the multiview preview first.",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "allow_rerig": {
      "type": "boolean",
      "description": "Explicitly create a NEW rigged copy if the source already contains bones. The source is never overwritten."
    },
    "analysis_job": {
      "type": "string",
      "pattern": "^gen_[A-Za-z0-9_-]{8,64}$"
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100
    },
    "idempotency_key": {
      "type": "string",
      "pattern": "^[a-zA-Z0-9_.:-]{8,160}$"
    },
    "reviewed_anatomy": {
      "type": "boolean",
      "description": "Required: true only after inspecting/correcting the anatomy and its skeleton overlay."
    }
  }
}
gripforge_creature_rig annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_generate_creature — Creatures · plan, generate and rig
Advertised by the server during the last successful anonymous check.
Open-world

Generic animal/alien creature factory, one to eight original creatures per batch. stage=plan quotes concept + Meshy 3D + anatomy vision without paid calls. stage=build requires explicit budget and stable idempotency_key, then generates private meshes and inspectable skeleton overlays. Poll gripforge_generation_read; inspect each preview/profile before stage=rig with generation_job, creature_id, reviewed_anatomy=true and optional corrected profile. Reuses the anatomy-aware Blender rig, never humanoid autorig. Exports GLB, Blender source and diagnostics. Procedural starting clips are drafts; missing fly/swim/action clips are reported. No automatic game-ready approval. Existing owned immutable source/concept revisions can be reused. Use generation_cancel/retry for durable work.

gripforge_generate_creature input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "stage": {
      "enum": [
        "plan",
        "build",
        "rig"
      ],
      "type": "string",
      "default": "plan"
    },
    "budget": {
      "type": "object",
      "properties": {
        "usd": {
          "type": "number",
          "maximum": 10000,
          "minimum": 0
        },
        "credits": {
          "type": "integer",
          "maximum": 100000,
          "minimum": 0
        }
      },
      "additionalProperties": false
    },
    "profile": {
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "recipes": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "id",
          "name",
          "prompt",
          "family"
        ],
        "properties": {
          "id": {
            "type": "string",
            "pattern": "^[a-z][a-z0-9_-]{0,39}$"
          },
          "name": {
            "type": "string",
            "maxLength": 100,
            "minLength": 1
          },
          "role": {
            "enum": [
              "fauna",
              "enemy",
              "companion",
              "mount",
              "boss"
            ],
            "type": "string",
            "default": "fauna"
          },
          "style": {
            "type": "string",
            "default": "stylized science-fiction adventure",
            "maxLength": 300,
            "minLength": 1
          },
          "family": {
            "enum": [
              "arthropod",
              "quadruped",
              "biped",
              "winged",
              "serpentine",
              "other"
            ],
            "type": "string"
          },
          "prompt": {
            "type": "string",
            "maxLength": 4000,
            "minLength": 10
          },
          "size_m": {
            "type": "number",
            "default": 1,
            "maximum": 100,
            "minimum": 0.05
          },
          "source": {
            "type": "object",
            "required": [
              "assetId",
              "revisionId"
            ],
            "properties": {
              "assetId": {
                "type": "string",
                "pattern": "^lib_[A-Za-z0-9_-]{8,64}$"
              },
              "fileRole": {
                "type": "string",
                "maxLength": 100
              },
              "revisionId": {
                "type": "string",
                "maxLength": 100,
                "minLength": 1
              }
            },
            "additionalProperties": false
          },
          "concept": {
            "type": "object",
            "required": [
              "assetId",
              "revisionId"
            ],
            "properties": {
              "assetId": {
                "type": "string",
                "pattern": "^lib_[A-Za-z0-9_-]{8,64}$"
              },
              "fileRole": {
                "type": "string",
                "maxLength": 100
              },
              "revisionId": {
                "type": "string",
                "maxLength": 100,
                "minLength": 1
              }
            },
            "additionalProperties": false
          },
          "polycount": {
            "type": "integer",
            "default": 8000,
            "maximum": 20000,
            "minimum": 500
          },
          "locomotion": {
            "enum": [
              "ground",
              "air",
              "water"
            ],
            "type": "string",
            "default": "ground"
          },
          "required_clips": {
            "type": "array",
            "items": {
              "type": "string",
              "pattern": "^[a-z][a-z0-9_]{0,39}$"
            },
            "default": [
              "idle",
              "walk",
              "run"
            ],
            "maxItems": 24,
            "minItems": 1
          }
        },
        "additionalProperties": false
      },
      "maxItems": 8,
      "minItems": 1,
      "description": "One to eight distinct creatures; each variant needs its own id and prompt. Required for plan/build."
    },
    "allow_rerig": {
      "type": "boolean"
    },
    "creature_id": {
      "type": "string",
      "pattern": "^[a-z][a-z0-9_-]{0,39}$"
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100
    },
    "generation_job": {
      "type": "string",
      "pattern": "^gen_[A-Za-z0-9_-]{8,64}$"
    },
    "idempotency_key": {
      "type": "string",
      "pattern": "^[a-zA-Z0-9_.:-]{8,160}$"
    },
    "concept_provider": {
      "enum": [
        "openai",
        "xai"
      ],
      "type": "string",
      "default": "openai"
    },
    "reviewed_anatomy": {
      "type": "boolean"
    }
  }
}
gripforge_generate_creature annotations
{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_compute_status — Compute · router status
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

GripForge Compute readiness (free, read-only): whether generation is open, which actions the router can run now (image, text, couleur, matiere) and a machine summary (ready / busy / starting). The router rents and stops its own machines; nothing is started by this call.

gripforge_compute_status input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {}
}
gripforge_compute_status annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_compute_generate — Compute · generate 3D assets (deprecated alias)
Advertised by the server during the last successful anonymous check.
Open-world

DEPRECATED alias of gripforge_generate_prop with provider=compute (same request through the single generation door POST /api/v1/generate-asset, same answer); prefer that tool. ON DEMAND ONLY: use when the user asks for GripForge Compute; the default 3D generator stays gripforge_generate_prop without provider. Make textured 3D prop/furniture assets with GripForge Compute from images or text descriptions: one asset (name + prompt or image) or several at once (items, up to 5; each item is one asset, from its prompt or its image). Two steps: stage=quote (free) returns each quote.token and the total price; show it to the user, then stage=generate with the tokens (quote_token, or quote_tokens in item order) and confirm=true launches one durable job per asset, each debited once after success with its own idempotency key. Text assets stop after four reference images (billed on their own): show them to the user, then gripforge_compute_validate with the chosen image (the 3D is quoted then, and billed when finished), or regenerate; auto_pick=true (only if the user asked) takes the first image and bills images + 3D once. Weapons are refused before any charge; characters, mobs, creatures and vehicles need their type. Returns one job per asset with studio_url; poll gripforge_generation_read (or this alias family: gripforge_compute_job) for the GLBs and their edit_url.

gripforge_compute_generate input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "stage"
  ],
  "properties": {
    "name": {
      "type": "string",
      "maxLength": 100,
      "minLength": 1,
      "description": "Single asset name"
    },
    "type": {
      "enum": [
        "objet",
        "meuble",
        "batiment",
        "vegetation",
        "vehicule",
        "personnage",
        "mob",
        "creature"
      ],
      "type": "string",
      "description": "Asset type (gripforge_compute_status lists those the router makes now). personnage / mob / creature: the mesh only; rig and animate it afterwards in the Character studio. Weapons are refused"
    },
    "items": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "name"
        ],
        "properties": {
          "name": {
            "type": "string",
            "maxLength": 100,
            "minLength": 1
          },
          "prompt": {
            "type": "string",
            "maxLength": 500,
            "minLength": 3
          },
          "image_base64": {
            "type": "string",
            "maxLength": 12000000
          }
        }
      },
      "maxItems": 5,
      "minItems": 1,
      "description": "Several assets at once: [{name, prompt} or {name, image_base64}]"
    },
    "stage": {
      "enum": [
        "quote",
        "generate"
      ],
      "type": "string",
      "description": "quote first (free), then generate"
    },
    "prompt": {
      "type": "string",
      "maxLength": 500,
      "minLength": 3,
      "description": "source=text: one object, e.g. \"a studded wooden pirate chest\""
    },
    "source": {
      "enum": [
        "image",
        "text"
      ],
      "type": "string",
      "description": "Single asset: default image. Items: inferred from each item (prompt → text, image → image)"
    },
    "confirm": {
      "type": "boolean",
      "description": "stage=generate: true once the user accepted the quoted price"
    },
    "options": {
      "type": "array",
      "items": {
        "enum": [
          "photo",
          "matieres",
          "relief",
          "visage",
          "visage_cheveux",
          "peau_humaine",
          "raffinage"
        ],
        "type": "string"
      },
      "maxItems": 7,
      "description": "photo, matieres, relief; optional raffinage (slower), peau_humaine, visage, visage_cheveux. Face/hair require description and type personnage or mob. Prerequisites are included in the quote."
    },
    "quality": {
      "enum": [
        "standard",
        "detail"
      ],
      "type": "string",
      "description": "Texture quality. Default standard"
    },
    "auto_pick": {
      "type": "boolean",
      "description": "Text assets: true = take the first image without asking (only when the user explicitly wants it). Default: stop and wait for gripforge_compute_validate"
    },
    "triangles": {
      "type": "integer",
      "maximum": 200000,
      "minimum": 500,
      "description": "Image assets only: exact triangle count of the « near » GLB (the « scene » one gets half). Default: from object_type. For a finished asset (also from text), use gripforge_compute_variant kind=budget"
    },
    "description": {
      "type": "string",
      "maxLength": 500,
      "description": "Character appearance in English (age, facial features, hair), required for visage / visage_cheveux"
    },
    "object_type": {
      "type": "string",
      "pattern": "^[a-z_]{2,40}$",
      "description": "Size (budget) of the type, e.g. petit_objet, mobilier_simple; default: the type's default"
    },
    "quote_token": {
      "type": "string",
      "maxLength": 64,
      "minLength": 64,
      "description": "stage=generate, single asset: quote.token from the quote with the SAME inputs"
    },
    "image_base64": {
      "type": "string",
      "maxLength": 12000000,
      "description": "source=image: PNG/JPEG/WebP, raw base64 or data URI, up to 8 MB"
    },
    "quote_tokens": {
      "type": "array",
      "items": {
        "type": "string",
        "maxLength": 64,
        "minLength": 64
      },
      "maxItems": 5,
      "description": "stage=generate with items: the quote tokens in item order"
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Explicit workspace id. The key must have access to it."
    },
    "idempotency_key": {
      "type": "string",
      "pattern": "^[a-zA-Z0-9_.:-]{8,160}$",
      "description": "Single asset: stable key for retries of the same launch; generated if absent (items: one per item, derived from it)"
    }
  }
}
gripforge_compute_generate annotations
{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_compute_job — Compute · follow jobs (deprecated alias)
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

DEPRECATED alias of gripforge_generation_read (same GET /api/v1/generation-jobs/:id; that tool returns the same studio_url, attente, validation and result.assets edit_url / file_url). Read GripForge Compute jobs (generations or variants): job_id, or job_ids for several at once. Status (queued, running, succeeded, failed), current stage and stage counts. While the router waits, `attente` = {raison: demarrage_machine | aucune_machine | file | machine_occupee, position, depuis, estimation_s} (a machine start takes about 10 min the first time). On success, result.assets lists the GLBs (scene, detail) with asset_id, triangles, edit_url (open it to edit in the studio) and file_url. Free.

gripforge_compute_job input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "job_id": {
      "type": "string",
      "maxLength": 200,
      "minLength": 1
    },
    "job_ids": {
      "type": "array",
      "items": {
        "type": "string",
        "maxLength": 200,
        "minLength": 1
      },
      "maxItems": 20,
      "minItems": 1
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Explicit workspace id. The key must have access to it."
    }
  }
}
gripforge_compute_job annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_compute_assets — Compute · list assets (deprecated alias)
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

DEPRECATED alias of gripforge_library_list with engine=compute (each item carries the same `compute` block) and of gripforge_library_get (its `compute` block: family and edit link). List recent GripForge Compute assets of the workspace (manufactures and variants), newest first, each with asset_id, kind, type, category, tags (engine, recipe, budget, near/scene, materials, style, licence…), needs_rig, level (scene/detail), edit_url and file_url. With asset_id: that asset's family (original + colour/material versions) and its edit link. Free.

gripforge_compute_assets input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "limit": {
      "type": "integer",
      "maximum": 100,
      "minimum": 1
    },
    "asset_id": {
      "type": "string",
      "maxLength": 160
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Explicit workspace id. The key must have access to it."
    }
  }
}
gripforge_compute_assets annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_compute_variant — Compute · colour, material or polygon variant
Advertised by the server during the last successful anonymous check.
Open-world

New version of a Compute asset, on demand: kind=couleur (value #RRGGBB, recolours the main material), kind=matiere (value: a few words, e.g. "green velvet"; the texture is redone) kind=retexture (value: a style for the whole asset, same mesh and UVs, e.g. "painted blue wood, worn") or kind=budget (change the polygon count: value bas | moyen | haut relative to the current one, or an exact « near » triangle count 500–200000; the « scene » GLB gets half; refused as coming soon until the router supports it). stage=quote (free) returns quote.token; after the user accepts, stage=generate with quote_token and confirm=true launches one billed job. Poll gripforge_compute_job; new assets come back with edit_url. Painted-area edits need the studio brush: give the user the edit_url.

gripforge_compute_variant input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "asset_id",
    "kind",
    "value",
    "stage"
  ],
  "properties": {
    "kind": {
      "enum": [
        "couleur",
        "matiere",
        "budget",
        "retexture"
      ],
      "type": "string"
    },
    "stage": {
      "enum": [
        "quote",
        "generate"
      ],
      "type": "string"
    },
    "value": {
      "type": "string",
      "maxLength": 300,
      "minLength": 1,
      "description": "couleur: #RRGGBB; matiere: short description; budget: bas | moyen | haut or a triangle count; retexture: style for the whole asset"
    },
    "confirm": {
      "type": "boolean"
    },
    "asset_id": {
      "type": "string",
      "maxLength": 160,
      "minLength": 1,
      "description": "Compute asset (scene or detail) from gripforge_compute_assets or a job result"
    },
    "quote_token": {
      "type": "string",
      "maxLength": 64,
      "minLength": 64
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Explicit workspace id. The key must have access to it."
    },
    "idempotency_key": {
      "type": "string",
      "pattern": "^[a-zA-Z0-9_.:-]{8,160}$"
    }
  }
}
gripforge_compute_variant annotations
{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_compute_validate — Compute · validate or regenerate text images
Advertised by the server during the last successful anonymous check.
Open-world

A text generation of GripForge Compute stops after its four reference images (gripforge_generation_read shows validation.etat en_attente and images[{stage, url}]). Show them to the user, then: image=1..4 to turn that image into 3D (stage=quote returns the 3D price; stage=generate with quote_token and confirm=true launches the 3D job, billed when finished), or regenerate=true (optionally with a new prompt) for four new images, billed again on their own, or abandon=true (only the images were billed).

gripforge_compute_validate input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "job_id"
  ],
  "properties": {
    "image": {
      "type": "integer",
      "maximum": 4,
      "minimum": 1
    },
    "stage": {
      "enum": [
        "quote",
        "generate"
      ],
      "type": "string",
      "description": "image / regenerate: quote first, then generate"
    },
    "job_id": {
      "type": "string",
      "maxLength": 200,
      "minLength": 1,
      "description": "The text generation job waiting for validation"
    },
    "prompt": {
      "type": "string",
      "maxLength": 500,
      "minLength": 3,
      "description": "regenerate: new text (default: the same)"
    },
    "abandon": {
      "type": "boolean"
    },
    "confirm": {
      "type": "boolean"
    },
    "regenerate": {
      "type": "boolean"
    },
    "quote_token": {
      "type": "string",
      "maxLength": 64,
      "minLength": 64
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Explicit workspace id. The key must have access to it."
    },
    "idempotency_key": {
      "type": "string",
      "pattern": "^[a-zA-Z0-9_.:-]{8,160}$"
    }
  }
}
gripforge_compute_validate annotations
{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_compute_download — Compute · download a GLB (deprecated alias)
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

DEPRECATED alias of gripforge_library_get (same signed library file). Signed-in download link of one Compute GLB (file_url, needs the API key header) and its edit page. Free.

gripforge_compute_download input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "asset_id"
  ],
  "properties": {
    "asset_id": {
      "type": "string",
      "maxLength": 160,
      "minLength": 1
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Explicit workspace id. The key must have access to it."
    }
  }
}
gripforge_compute_download annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_facial_rig — Facial rig · inspect and prepare dialogue
Advertised by the server during the last successful anonymous check.

Inspect or create mouth controls on an OWNED GLB while preserving its body skeleton and animations. action=schema returns the contract. inspect returns a persistent job with mesh node indices, local bounds, existing facial controls and compatible dialogue.voice mappings. build automatically reuses recognized Oculus/ARKit/Rhubarb controls, or creates eight draft mouth morphs from explicit mouth landmarks (profile). A sealed mouth requires explicit prepare_mouth=true to cut a guided opening on the output copy and add an interior; it interpolates UVs and skin weights, changes face topology and requires visual review. It never guesses landmarks from the body bounds. Poll gripforge_generation_read for the new private GLB, report, voice_rig JSON and Character Studio link. No automatic source replacement or project binding. No TTS/GPU rental; CPU geometry processing, not full facial expression authoring.

gripforge_facial_rig input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "name": {
      "type": "string",
      "maxLength": 100,
      "minLength": 1
    },
    "node": {
      "type": "integer",
      "maximum": 4095,
      "minimum": 0,
      "description": "Mesh node index from inspect. Selects one existing rig when independent faces use different conventions."
    },
    "action": {
      "enum": [
        "schema",
        "inspect",
        "build"
      ],
      "type": "string",
      "default": "inspect"
    },
    "profile": {
      "type": "object",
      "required": [
        "node",
        "left",
        "right",
        "upper",
        "lower",
        "chin"
      ],
      "properties": {
        "chin": {
          "type": "array",
          "prefixItems": [
            {
              "type": "number",
              "maximum": 100000,
              "minimum": -100000
            },
            {
              "type": "number",
              "maximum": 100000,
              "minimum": -100000
            },
            {
              "type": "number",
              "maximum": 100000,
              "minimum": -100000
            }
          ]
        },
        "left": {
          "type": "array",
          "prefixItems": [
            {
              "type": "number",
              "maximum": 100000,
              "minimum": -100000
            },
            {
              "type": "number",
              "maximum": 100000,
              "minimum": -100000
            },
            {
              "type": "number",
              "maximum": 100000,
              "minimum": -100000
            }
          ]
        },
        "node": {
          "type": "integer",
          "maximum": 4095,
          "minimum": 0
        },
        "depth": {
          "type": "number",
          "maximum": 10000,
          "exclusiveMinimum": 0
        },
        "lower": {
          "type": "array",
          "prefixItems": [
            {
              "type": "number",
              "maximum": 100000,
              "minimum": -100000
            },
            {
              "type": "number",
              "maximum": 100000,
              "minimum": -100000
            },
            {
              "type": "number",
              "maximum": 100000,
              "minimum": -100000
            }
          ]
        },
        "right": {
          "type": "array",
          "prefixItems": [
            {
              "type": "number",
              "maximum": 100000,
              "minimum": -100000
            },
            {
              "type": "number",
              "maximum": 100000,
              "minimum": -100000
            },
            {
              "type": "number",
              "maximum": 100000,
              "minimum": -100000
            }
          ]
        },
        "upper": {
          "type": "array",
          "prefixItems": [
            {
              "type": "number",
              "maximum": 100000,
              "minimum": -100000
            },
            {
              "type": "number",
              "maximum": 100000,
              "minimum": -100000
            },
            {
              "type": "number",
              "maximum": 100000,
              "minimum": -100000
            }
          ]
        }
      },
      "description": "For a model without mouth controls: front-view left/right mouth corners, distinct upper/lower INNER lip points and chin, all in the selected node LOCAL rest space before skinning/transforms. A sealed surface also requires prepare_mouth. Inspect first; do not guess from whole-body bounds. depth optionally limits the region behind the lips.",
      "additionalProperties": false
    },
    "source_id": {
      "type": "string",
      "pattern": "^lib_[A-Za-z0-9_-]{8,64}$"
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100
    },
    "prepare_mouth": {
      "type": "boolean",
      "description": "Opt in to cutting a guided opening and adding an inner mouth on the output copy when the mouth is sealed. Requires profile and one primitive without existing morphs. Changes facial topology and needs close visual review."
    },
    "idempotency_key": {
      "type": "string",
      "pattern": "^[a-zA-Z0-9_.:-]{8,160}$"
    }
  }
}
gripforge_facial_rig annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_voice_profile — Voice profiles · listen and cast characters
Advertised by the server during the last successful anonymous check.

Reusable voice identities in Community > Audio > Voices and the workspace. list/get return provider, model, voice, tested languages, acting instructions and timed sample ranges in file_url. schema describes the contract. characters reads speakers and revision from an OWNED Game Kit project. To assign, first clone a community voice into the workspace, then supply voice_id, project_id, speaker, language and expected_revision from characters. Optional instructions describe the character acting style. Saves a per-speaker/language snapshot in dialogue.voice voice_cast, preserving other voices and dialogue content. Assignment performs no TTS: bake recordings with tools/dialogue-voice/build.mjs and a matching worker. Per-line emotions use dialogue_voice_directions. Free reads; no GPU rental or automatic generation.

gripforge_voice_profile input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "q": {
      "type": "string",
      "maxLength": 100
    },
    "scope": {
      "enum": [
        "all",
        "mine",
        "community"
      ],
      "type": "string"
    },
    "action": {
      "enum": [
        "schema",
        "list",
        "get",
        "characters",
        "assign"
      ],
      "type": "string",
      "default": "list"
    },
    "speaker": {
      "type": "string",
      "maxLength": 100,
      "minLength": 1
    },
    "language": {
      "type": "string",
      "maxLength": 20,
      "description": "list defaults to English (en); use all for every language. assign requires an explicit tested language."
    },
    "voice_id": {
      "type": "string",
      "pattern": "^lib_[A-Za-z0-9_-]{8,64}$"
    },
    "project_id": {
      "type": "string",
      "pattern": "^gkp_[A-Za-z0-9_-]+$"
    },
    "instructions": {
      "type": "string",
      "maxLength": 500
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100
    },
    "expected_revision": {
      "type": "integer",
      "maximum": 9007199254740991,
      "minimum": 1
    }
  }
}
gripforge_voice_profile annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_game_audio — Game audio · effects, weapons, music and ambience
Advertised by the server during the last successful anonymous check.

Read and configure the existing audio.core of an owned Game Kit project. get returns revision, role catalogue, sources, procedural/silent roles, weapon shot overrides, bus defaults, music states/playlists, event cues and broken references. It is a configuration audit; playback stays unverified until heard in the player. configure merges only supplied roles/weapons/volumes/fade and requires expected_revision from get. dry_run previews the same validated result without saving. Preserves other sounds, custom cues, spatial areas and Rust acoustic geometry. Search Library audio first; never use a sound effect as music. No generation, GPU rental, asset purchase or credit charge. Voice identities use gripforge_voice_profile and dialogue.voice; bake audio.speech through Drama 3, English by default.

gripforge_game_audio input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "project_id"
  ],
  "properties": {
    "fade": {
      "type": "number",
      "maximum": 10,
      "minimum": 0,
      "description": "Music crossfade in seconds."
    },
    "roles": {
      "type": "object",
      "description": "Role → variants. get lists the roles. Sources: lib:lib_…, slot:<id>, base:<recipe>. null resets SFX, silences that music state or removes global ambience.",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {
        "anyOf": [
          {
            "type": "array",
            "items": {
              "type": "string",
              "maxLength": 120
            },
            "maxItems": 16,
            "minItems": 1
          },
          {
            "type": "null"
          }
        ]
      }
    },
    "action": {
      "enum": [
        "get",
        "configure"
      ],
      "type": "string",
      "default": "get"
    },
    "dry_run": {
      "type": "boolean"
    },
    "volumes": {
      "type": "object",
      "description": "Default bus percentages: master, music, sfx, voice, ambience, ui. Player preferences still win.",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {
        "type": "integer",
        "maximum": 100,
        "minimum": 0
      }
    },
    "weapons": {
      "type": "object",
      "description": "Gun model ID → shot variants, e.g. {rifle:[\"lib:lib_…\"]}. null restores the generic shot. Web/Rust conditional cues: one shot, no duplicate; other weapons retain their defaults. Legacy engine scripts are unverified.",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {
        "anyOf": [
          {
            "type": "array",
            "items": {
              "type": "string",
              "maxLength": 120
            },
            "maxItems": 16,
            "minItems": 1
          },
          {
            "type": "null"
          }
        ]
      }
    },
    "project_id": {
      "type": "string",
      "pattern": "^gkp_[A-Za-z0-9_-]{1,76}$"
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100
    },
    "expected_revision": {
      "type": "integer",
      "maximum": 9007199254740991,
      "minimum": 1
    }
  }
}
gripforge_game_audio annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_audio_generate — Generate game sounds · Stable Audio 3 Medium
Advertised by the server during the last successful anonymous check.
Open-world

Generate SFX and ambience with self-hosted Stable Audio 3 Medium, the default sound model. No downgrade to Small. Call action=quote first (no generation/charge), then action=generate with the returned quote_hash and identical inputs. Cost is disclosed in the quote; generation may spend the selected AI allowance or GripForge credits. Returns a durable job_id immediately; poll gripforge_generation_read. Successful takes survive retries as Library audio with prompt, seed, revision and WAV measurements. Optional role assignment uses expected_revision; a conflicting edit keeps takes in Library without overwriting the project. Listen to results: quality and seamless loops are unreviewed. Max SFX 30s, ambience 60s, 1–4 variants, seed increments per take. Music uses its own pipeline; voices use Drama 3 via audio.speech.

gripforge_audio_generate input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "prompt"
  ],
  "properties": {
    "loop": {
      "type": "boolean",
      "default": false
    },
    "name": {
      "type": "string",
      "maxLength": 160,
      "minLength": 1
    },
    "role": {
      "type": "string",
      "maxLength": 60,
      "description": "Optional project role from gripforge_game_audio get. Requires expected_revision. Music/voice roles are not supported."
    },
    "seed": {
      "type": "integer",
      "default": 0,
      "maximum": 2147483643,
      "minimum": 0
    },
    "action": {
      "enum": [
        "quote",
        "generate"
      ],
      "type": "string",
      "default": "quote"
    },
    "prompt": {
      "type": "string",
      "maxLength": 2000,
      "minLength": 3,
      "description": "Describe one isolated sound in English: source, action, material, character and decay."
    },
    "weapon": {
      "type": "string",
      "pattern": "^[a-z0-9][a-z0-9_.-]{0,47}$",
      "description": "Optional gun model ID, requires role=shot."
    },
    "subtype": {
      "enum": [
        "sfx",
        "ambience"
      ],
      "type": "string",
      "default": "sfx"
    },
    "duration": {
      "type": "number",
      "default": 3,
      "maximum": 60,
      "minimum": 0.5
    },
    "variants": {
      "type": "integer",
      "default": 1,
      "maximum": 4,
      "minimum": 1
    },
    "project_id": {
      "type": "string",
      "pattern": "^gkp_[A-Za-z0-9_-]{1,76}$"
    },
    "quote_hash": {
      "type": "string",
      "pattern": "^[a-f0-9]{64}$"
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100
    },
    "idempotency_key": {
      "type": "string",
      "pattern": "^[a-zA-Z0-9_.:-]{8,160}$"
    },
    "expected_revision": {
      "type": "integer",
      "maximum": 9007199254740991,
      "minimum": 1
    }
  }
}
gripforge_audio_generate annotations
{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_game_releases — Game releases · desktop updates and Steam
Advertised by the server during the last successful anonymous check.

Read immutable game release history and stable/beta channel revisions; obtain a snapshot fingerprint for an exact saved project revision; register a prepared signed release; or promote its build ID with expected_revision from history. Direct Windows/macOS updates use the signed launcher feed. Steam builds use SteamPipe and are promoted in Steamworks separately. Registering never promotes. Use gripforge game-release prepare/finalize/publish locally for packaging, signatures and binary uploads; game-release steam-upload uses an already authorized local SteamCMD account. Never send a signing private key or Steam password to this tool. A missing artifact returns warnings and preserves the current channel.

gripforge_game_releases input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "project_id",
    "action"
  ],
  "properties": {
    "action": {
      "enum": [
        "history",
        "snapshot",
        "register",
        "promote"
      ],
      "type": "string"
    },
    "channel": {
      "enum": [
        "stable",
        "beta"
      ],
      "type": "string"
    },
    "build_id": {
      "type": "string",
      "pattern": "^[A-Za-z0-9][A-Za-z0-9_-]{1,100}$"
    },
    "manifest": {
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "revision": {
      "type": "integer",
      "maximum": 9007199254740991,
      "minimum": 1
    },
    "project_id": {
      "type": "string",
      "pattern": "^gkp_[A-Za-z0-9_-]{2,100}$"
    },
    "public_key": {
      "type": "string",
      "maxLength": 256
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100
    },
    "expected_revision": {
      "type": "integer",
      "maximum": 9007199254740991,
      "minimum": 0
    }
  }
}
gripforge_game_releases annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_weapon_profile — gripforge_weapon_profile
Advertised by the server during the last successful anonymous check.
Advertised read-only

Measure an owned armed GLB instance and return its editable weapon/motion profile: explicit family, holding hand, dimensions, grip anchors, handle and cutting-edge axes. Use gripforge_attach first. Default axes are +Y handle and +Z edge; inspect/correct them. Does not mutate the Library source or certify the initial seating.

gripforge_weapon_profile input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "source_id"
  ],
  "properties": {
    "hand": {
      "enum": [
        "left",
        "right"
      ],
      "type": "string"
    },
    "hands": {
      "anyOf": [
        {
          "type": "number",
          "const": 1
        },
        {
          "type": "number",
          "const": 2
        }
      ]
    },
    "family": {
      "enum": [
        "axe",
        "sword",
        "hammer",
        "staff"
      ],
      "type": "string",
      "description": "Required on the first call. Never infer axe vs sword from geometry alone."
    },
    "edgeAxis": {
      "type": "array",
      "prefixItems": [
        {
          "type": "number"
        },
        {
          "type": "number"
        },
        {
          "type": "number"
        }
      ]
    },
    "source_id": {
      "type": "string",
      "pattern": "^lib_[A-Za-z0-9_-]{8,64}$"
    },
    "handleAxis": {
      "type": "array",
      "prefixItems": [
        {
          "type": "number"
        },
        {
          "type": "number"
        },
        {
          "type": "number"
        }
      ]
    },
    "weaponNode": {
      "type": "string",
      "maxLength": 150
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100
    },
    "primaryAnchor": {
      "type": "array",
      "prefixItems": [
        {
          "type": "number"
        },
        {
          "type": "number"
        },
        {
          "type": "number"
        }
      ]
    },
    "secondaryAnchor": {
      "type": "array",
      "description": "Required for two hands; weapon-node local coordinates.",
      "prefixItems": [
        {
          "type": "number"
        },
        {
          "type": "number"
        },
        {
          "type": "number"
        }
      ]
    }
  }
}
gripforge_weapon_profile annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_weapon_motion — gripforge_weapon_motion
Advertised by the server during the last successful anonymous check.

Queue a persistent weapon-aware motion draft from an owned armed GLB. Axe/hammer get distinct procedural cleave, backhand and overhead attacks; sword uses the explicit UAL sword pack. Staff attacks fail with compatible_motion_missing; no silent sword fallback. Holds Grip finger poses, supports a second-hand anchor with IK. Poll gripforge_generation_read, cancel/retry with generation tools. Returns a NEW work asset and Character Studio URL; never replaces the game/source or visually validates a result. 0 generation credits.

gripforge_weapon_motion input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "source_id"
  ],
  "properties": {
    "hand": {
      "enum": [
        "left",
        "right"
      ],
      "type": "string"
    },
    "name": {
      "type": "string",
      "maxLength": 150
    },
    "hands": {
      "anyOf": [
        {
          "type": "number",
          "const": 1
        },
        {
          "type": "number",
          "const": 2
        }
      ]
    },
    "slots": {
      "type": "array",
      "items": {
        "enum": [
          "idle",
          "walk",
          "run",
          "attack1",
          "attack2",
          "attack3",
          "hit",
          "death",
          "dodge",
          "block",
          "jump_start",
          "jump_loop",
          "jump_land"
        ],
        "type": "string"
      },
      "maxItems": 13,
      "minItems": 1
    },
    "family": {
      "enum": [
        "axe",
        "sword",
        "hammer",
        "staff"
      ],
      "type": "string",
      "description": "Required on the first call. Never infer axe vs sword from geometry alone."
    },
    "edgeAxis": {
      "type": "array",
      "prefixItems": [
        {
          "type": "number"
        },
        {
          "type": "number"
        },
        {
          "type": "number"
        }
      ]
    },
    "source_id": {
      "type": "string",
      "pattern": "^lib_[A-Za-z0-9_-]{8,64}$"
    },
    "handleAxis": {
      "type": "array",
      "prefixItems": [
        {
          "type": "number"
        },
        {
          "type": "number"
        },
        {
          "type": "number"
        }
      ]
    },
    "weaponNode": {
      "type": "string",
      "maxLength": 150
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100
    },
    "primaryAnchor": {
      "type": "array",
      "prefixItems": [
        {
          "type": "number"
        },
        {
          "type": "number"
        },
        {
          "type": "number"
        }
      ]
    },
    "idempotency_key": {
      "type": "string",
      "pattern": "^[a-zA-Z0-9_.:-]{8,160}$"
    },
    "secondaryAnchor": {
      "type": "array",
      "description": "Required for two hands; weapon-node local coordinates.",
      "prefixItems": [
        {
          "type": "number"
        },
        {
          "type": "number"
        },
        {
          "type": "number"
        }
      ]
    }
  }
}
gripforge_weapon_motion annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_weapon_motion_review — gripforge_weapon_motion_review
Advertised by the server during the last successful anonymous check.
Advertised read-only

Independently sample the saved weapon-motion GLB at 60 Hz: grip drift, finger pose, wrist rotation, joint discontinuities, second-hand reach and torso overlaps. Reports technicalPassed separately from visualStatus=not_reviewed. Inspect idle, wind-up, impact, recovery and locomotion in GripForge before using the draft. No promotion or mutation.

gripforge_weapon_motion_review input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "source_id"
  ],
  "properties": {
    "source_id": {
      "type": "string",
      "pattern": "^lib_[A-Za-z0-9_-]{8,64}$"
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100
    }
  }
}
gripforge_weapon_motion_review annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_shield_vfx — gripforge_shield_vfx
Advertised by the server during the last successful anonymous check.

ADMIN ONLY. Create an original editable 3D elemental shield using the shared shield-vfx module: 17 styles, radius/stretch, colours, intensity, quality and seed. Same shaders used in Studio and native exports. save=true by default queues persistent rendering/review/workspace save; poll generation_read for Studio URL. save=false returns an unsaved project. No commercial reference assets, collision or damage. Recipe compilation needs no AI; saving uses the normal VFX review pipeline. Work is not visually validated automatically.

gripforge_shield_vfx input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "save": {
      "type": "boolean"
    },
    "config": {
      "type": "object",
      "properties": {
        "seed": {
          "type": "integer",
          "maximum": 65535,
          "minimum": 0
        },
        "color": {
          "type": "string",
          "pattern": "^#[a-f\\d]{6}$"
        },
        "speed": {
          "type": "number",
          "maximum": 4,
          "minimum": 0.1
        },
        "style": {
          "enum": [
            "fire",
            "water",
            "water-petal",
            "blood",
            "cat",
            "cosmic",
            "cyber",
            "cyber-grid",
            "holy",
            "ice",
            "ink",
            "light",
            "lightning",
            "poison",
            "rock",
            "void",
            "wind"
          ],
          "type": "string"
        },
        "accent": {
          "type": "string",
          "pattern": "^#[a-f\\d]{6}$"
        },
        "radius": {
          "type": "number",
          "maximum": 5,
          "minimum": 0.15
        },
        "opacity": {
          "type": "number",
          "maximum": 1,
          "minimum": 0
        },
        "quality": {
          "enum": [
            "low",
            "high"
          ],
          "type": "string"
        },
        "stretch": {
          "type": "array",
          "prefixItems": [
            {
              "type": "number",
              "maximum": 2,
              "minimum": 0.25
            },
            {
              "type": "number",
              "maximum": 2,
              "minimum": 0.25
            },
            {
              "type": "number",
              "maximum": 2,
              "minimum": 0.25
            }
          ]
        },
        "version": {
          "type": "number",
          "const": 1
        },
        "intensity": {
          "type": "number",
          "maximum": 3,
          "minimum": 0.1
        }
      },
      "additionalProperties": false
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100
    },
    "idempotency_key": {
      "type": "string",
      "maxLength": 160,
      "minLength": 8
    }
  }
}
gripforge_shield_vfx annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_shield_export — gripforge_shield_export
Advertised by the server during the last successful anonymous check.
Advertised read-only

ADMIN ONLY. Compile a shield recipe into reusable native source files for Godot 4, Unity or Unreal 5, using the same geometry and shader functions. Returns files keyed by relative path plus install instructions. Write ALL files into a dedicated directory; never overwrite an existing modified package without checking. Includes enable/hit/shatter runtime; no mannequin or preview environment. Native builds require target-engine verification; source export is not visual certification.

gripforge_shield_export input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "engine"
  ],
  "properties": {
    "config": {
      "type": "object",
      "properties": {
        "seed": {
          "type": "integer",
          "maximum": 65535,
          "minimum": 0
        },
        "color": {
          "type": "string",
          "pattern": "^#[a-f\\d]{6}$"
        },
        "speed": {
          "type": "number",
          "maximum": 4,
          "minimum": 0.1
        },
        "style": {
          "enum": [
            "fire",
            "water",
            "water-petal",
            "blood",
            "cat",
            "cosmic",
            "cyber",
            "cyber-grid",
            "holy",
            "ice",
            "ink",
            "light",
            "lightning",
            "poison",
            "rock",
            "void",
            "wind"
          ],
          "type": "string"
        },
        "accent": {
          "type": "string",
          "pattern": "^#[a-f\\d]{6}$"
        },
        "radius": {
          "type": "number",
          "maximum": 5,
          "minimum": 0.15
        },
        "opacity": {
          "type": "number",
          "maximum": 1,
          "minimum": 0
        },
        "quality": {
          "enum": [
            "low",
            "high"
          ],
          "type": "string"
        },
        "stretch": {
          "type": "array",
          "prefixItems": [
            {
              "type": "number",
              "maximum": 2,
              "minimum": 0.25
            },
            {
              "type": "number",
              "maximum": 2,
              "minimum": 0.25
            },
            {
              "type": "number",
              "maximum": 2,
              "minimum": 0.25
            }
          ]
        },
        "version": {
          "type": "number",
          "const": 1
        },
        "intensity": {
          "type": "number",
          "maximum": 3,
          "minimum": 0.1
        }
      },
      "additionalProperties": false
    },
    "engine": {
      "enum": [
        "godot",
        "unity",
        "unreal"
      ],
      "type": "string"
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100
    }
  }
}
gripforge_shield_export annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_projectile_create — Create projectile VFX
Advertised by the server during the last successful anonymous check.

ADMIN ONLY. Create an editable 3D projectile: ignition, elemental volume, world-space trail, embers, contact flash, oriented ring and soot. 20 named variants: darts, short bolts, orbs, wisps, carrot rocket, spinning disc, spears, comets, coils and lightning. config.variant selects the geometry, trail and impact; style/color optionally override its palette. Omit variant to retain the original elemental recipe. To save several catalogue entries, pass variants=[IDs] without config/name: one persistent job renders/reviews each item sequentially, preserves completed items on retry and returns result.items. Publication remains explicit. Uses the shared trail and Scene Engine modules. save=true (default) queues persistent rendering/review/workspace save; poll gripforge_generation_read for Library ID and Studio link. save=false returns an unsaved recipe. Bind the resulting VFX to combat.projectiles/projectile_vfx using the Game Kit tools; gameplay speed/gravity/damage stay in the module. Web player only in v1. Does not install a kit or modify a game automatically. Recipe compilation needs no AI; saved previews use the existing review pipeline. No automatic visual validation.

gripforge_projectile_create input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "name": {
      "type": "string",
      "maxLength": 80,
      "minLength": 1
    },
    "save": {
      "type": "boolean"
    },
    "config": {
      "type": "object",
      "properties": {
        "seed": {
          "type": "integer",
          "maximum": 65535,
          "minimum": 0
        },
        "color": {
          "type": "string",
          "pattern": "^#[a-f\\d]{6}$"
        },
        "style": {
          "enum": [
            "fire",
            "ice",
            "arcane",
            "poison"
          ],
          "type": "string"
        },
        "accent": {
          "type": "string",
          "pattern": "^#[a-f\\d]{6}$"
        },
        "radius": {
          "type": "number",
          "maximum": 1,
          "minimum": 0.04
        },
        "quality": {
          "enum": [
            "low",
            "high"
          ],
          "type": "string"
        },
        "variant": {
          "enum": [
            "elemental",
            "arcane-dart",
            "ember-dart",
            "venom-dart",
            "crimson-bullet",
            "frost-bullet",
            "frost-orb",
            "arcane-orb",
            "solar-wisp",
            "frost-wisp",
            "carrot-shot",
            "arcane-disc",
            "ice-spear",
            "venom-spear",
            "venom-orb",
            "void-comet",
            "solar-comet",
            "flame-coil",
            "frost-coil",
            "storm-bolt",
            "solar-bolt"
          ],
          "type": "string"
        },
        "version": {
          "type": "number",
          "const": 1
        },
        "trailLifetime": {
          "type": "number",
          "maximum": 1,
          "minimum": 0.06
        },
        "impactDuration": {
          "type": "number",
          "maximum": 2,
          "minimum": 0.15
        }
      },
      "additionalProperties": false
    },
    "variants": {
      "type": "array",
      "items": {
        "type": "string",
        "maxLength": 40,
        "minLength": 1
      },
      "maxItems": 20,
      "minItems": 1
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100
    },
    "idempotency_key": {
      "type": "string",
      "maxLength": 160,
      "minLength": 8
    }
  }
}
gripforge_projectile_create annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_architecture_schema — Architecture · schema
Advertised by the server during the last successful anonymous check.
Advertised read-only

Read the reusable Meshy/Tripo building and district contract, example, limits and plan → build workflow. Separate immutable Library assets, scene instances and shared SceneDocument. No paid generation.

gripforge_architecture_schema input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {}
}
gripforge_architecture_schema annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_generate_building — Generate a building
Advertised by the server during the last successful anonymous check.
Open-world

Reusable plan → artistic concept → isolated reference views → review → Meshy or explicitly selected Tripo build workflow. Generate 1–4 images through OpenAI or Imagine; alternate views reference one master but must be checked for actually different viewpoints. If edits repeat the front, use one good concept instead of a false multiview set. Separate explicit budgets for concepts and 3D. Accepts text, owned concept views or a static GLB. Optional delivery preserves the source master and prepares reusable LOD GLBs with PBR and a common metric fit. Durable jobs return workspace links; poll generation_read, cancel/retry preserves finished steps. Review the actual render before publishing. No guaranteed interiors, collisions or runtime LOD switching; no automatic game replacement.

gripforge_generate_building input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "recipe"
  ],
  "properties": {
    "stage": {
      "enum": [
        "plan",
        "concept",
        "build"
      ],
      "type": "string",
      "description": "plan is free: exact prompts and separate image/3D quotes. concept creates reviewable workspace images. First review artistic scene, then isolated views of the SAME building, then build 3D from chosen isolated references."
    },
    "budget": {
      "type": "object",
      "properties": {
        "usd": {
          "type": "number",
          "minimum": 0
        },
        "credits": {
          "type": "number",
          "minimum": 0
        }
      },
      "description": "Required for paid concept/build: maximum GripForge credits OR subscription USD accepted. Use the quote funding currency: insufficient AI allowance falls back to GripForge credits for the whole new job, never both. Use plan.concept_quote for images, plan.quote for Meshy. Provider credits are separate.",
      "additionalProperties": false
    },
    "recipe": {
      "type": "object",
      "required": [
        "prompt"
      ],
      "properties": {
        "id": {
          "type": "string",
          "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_-]{0,47}$"
        },
        "use": {
          "enum": [
            "residential",
            "retail",
            "office",
            "industrial",
            "mixed"
          ],
          "type": "string"
        },
        "look": {
          "enum": [
            "stylized",
            "painted",
            "toon",
            "anime",
            "realistic",
            "lowpoly",
            "pixel"
          ],
          "type": "string",
          "description": "Rendering look, separate from the game style: stylized (neutral) | painted | toon | anime | realistic | lowpoly | pixel. Old values (handpainted, cartoon, low_poly…) are read as aliases. Omit for the style default. Fills style when style is omitted; toon, anime and pixel add their phrase to the prompt."
        },
        "name": {
          "type": "string",
          "maxLength": 100,
          "minLength": 1
        },
        "roof": {
          "enum": [
            "flat",
            "pitched"
          ],
          "type": "string"
        },
        "style": {
          "enum": [
            "realistic",
            "stylized",
            "lowpoly",
            "handpainted"
          ],
          "type": "string"
        },
        "facade": {
          "type": "string",
          "maxLength": 120
        },
        "finish": {
          "type": "object",
          "required": [
            "version",
            "remove",
            "parts"
          ],
          "properties": {
            "parts": {
              "type": "array",
              "items": {
                "oneOf": [
                  {
                    "type": "object",
                    "required": [
                      "kind",
                      "id",
                      "color",
                      "origin",
                      "width",
                      "height"
                    ],
                    "properties": {
                      "id": {
                        "type": "string",
                        "pattern": "^[a-zA-Z0-9_-]{1,48}$"
                      },
                      "yaw": {
                        "type": "number",
                        "maximum": 6.283185307179586,
                        "minimum": -6.283185307179586
                      },
                      "kind": {
                        "type": "string",
                        "const": "shutter"
                      },
                      "color": {
                        "type": "string",
                        "pattern": "^#[0-9a-f]{6}$"
                      },
                      "width": {
                        "type": "number",
                        "maximum": 15,
                        "minimum": 0.2
                      },
                      "height": {
                        "type": "number",
                        "maximum": 12,
                        "minimum": 0.1
                      },
                      "origin": {
                        "type": "array",
                        "prefixItems": [
                          {
                            "type": "number",
                            "maximum": 150,
                            "minimum": -150
                          },
                          {
                            "type": "number",
                            "maximum": 150,
                            "minimum": -150
                          },
                          {
                            "type": "number",
                            "maximum": 150,
                            "minimum": -150
                          }
                        ]
                      },
                      "metalness": {
                        "type": "number",
                        "maximum": 1,
                        "minimum": 0
                      },
                      "roughness": {
                        "type": "number",
                        "maximum": 1,
                        "minimum": 0.05
                      },
                      "slatHeight": {
                        "type": "number",
                        "maximum": 0.3,
                        "minimum": 0.035
                      }
                    },
                    "additionalProperties": false
                  },
                  {
                    "type": "object",
                    "required": [
                      "kind",
                      "id",
                      "color",
                      "points",
                      "height"
                    ],
                    "properties": {
                      "id": {
                        "type": "string",
                        "pattern": "^[a-zA-Z0-9_-]{1,48}$"
                      },
                      "kind": {
                        "type": "string",
                        "const": "railing"
                      },
                      "color": {
                        "type": "string",
                        "pattern": "^#[0-9a-f]{6}$"
                      },
                      "height": {
                        "type": "number",
                        "maximum": 12,
                        "minimum": 0.1
                      },
                      "points": {
                        "type": "array",
                        "items": {
                          "type": "array",
                          "prefixItems": [
                            {
                              "type": "number",
                              "maximum": 150,
                              "minimum": -150
                            },
                            {
                              "type": "number",
                              "maximum": 150,
                              "minimum": -150
                            },
                            {
                              "type": "number",
                              "maximum": 150,
                              "minimum": -150
                            }
                          ]
                        },
                        "maxItems": 16,
                        "minItems": 2
                      },
                      "barRadius": {
                        "type": "number",
                        "maximum": 0.05,
                        "minimum": 0.006
                      },
                      "metalness": {
                        "type": "number",
                        "maximum": 1,
                        "minimum": 0
                      },
                      "roughness": {
                        "type": "number",
                        "maximum": 1,
                        "minimum": 0.05
                      },
                      "barSpacing": {
                        "type": "number",
                        "maximum": 0.5,
                        "minimum": 0.05
                      },
                      "postRadius": {
                        "type": "number",
                        "maximum": 0.1,
                        "minimum": 0.015
                      },
                      "railRadius": {
                        "type": "number",
                        "maximum": 0.08,
                        "minimum": 0.01
                      },
                      "postSpacing": {
                        "type": "number",
                        "maximum": 3,
                        "minimum": 0.2
                      }
                    },
                    "additionalProperties": false
                  }
                ]
              },
              "maxItems": 32,
              "minItems": 1
            },
            "remove": {
              "type": "array",
              "items": {
                "type": "object",
                "required": [
                  "center",
                  "size"
                ],
                "properties": {
                  "size": {
                    "type": "array",
                    "prefixItems": [
                      {
                        "type": "number",
                        "maximum": 100,
                        "minimum": 0.001
                      },
                      {
                        "type": "number",
                        "maximum": 100,
                        "minimum": 0.001
                      },
                      {
                        "type": "number",
                        "maximum": 100,
                        "minimum": 0.001
                      }
                    ]
                  },
                  "center": {
                    "type": "array",
                    "prefixItems": [
                      {
                        "type": "number",
                        "maximum": 150,
                        "minimum": -150
                      },
                      {
                        "type": "number",
                        "maximum": 150,
                        "minimum": -150
                      },
                      {
                        "type": "number",
                        "maximum": 150,
                        "minimum": -150
                      }
                    ]
                  },
                  "rotation": {
                    "type": "array",
                    "prefixItems": [
                      {
                        "type": "number",
                        "maximum": 6.283185307179586,
                        "minimum": -6.283185307179586
                      },
                      {
                        "type": "number",
                        "maximum": 6.283185307179586,
                        "minimum": -6.283185307179586
                      },
                      {
                        "type": "number",
                        "maximum": 6.283185307179586,
                        "minimum": -6.283185307179586
                      }
                    ]
                  }
                },
                "additionalProperties": false
              },
              "maxItems": 64
            },
            "version": {
              "type": "number",
              "const": 1
            }
          },
          "description": "Free deterministic repair of an owned source + delivery. All coordinates are Y-up metres AFTER the returned importTransform. Explicit oriented removal boxes (rotation XYZ radians), regular shutters (+Z outward, yaw radians) and railing paths (feet, vertical posts, supports slopes). Measure and review regions first. Applied AFTER each LOD simplification to keep thin parts straight. Textures outside cuts stay byte-identical; removed surfaces are not capped. Triangle targets remain soft. No AI auto-segmentation or collision repair.",
          "additionalProperties": false
        },
        "floors": {
          "type": "integer",
          "maximum": 30,
          "minimum": 1
        },
        "prompt": {
          "type": "string",
          "maxLength": 300,
          "minLength": 3
        },
        "source": {
          "type": "object",
          "required": [
            "assetId",
            "revisionId"
          ],
          "properties": {
            "assetId": {
              "type": "string",
              "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
            },
            "fileRole": {
              "type": "string",
              "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
            },
            "revisionId": {
              "type": "string",
              "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
            }
          },
          "description": "Reuse an owned static GLB revision instead of paying for this building. The source is never modified.",
          "additionalProperties": false
        },
        "concept": {
          "type": "object",
          "required": [
            "assetId",
            "revisionId"
          ],
          "properties": {
            "assetId": {
              "type": "string",
              "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
            },
            "fileRole": {
              "type": "string",
              "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
            },
            "revisionId": {
              "type": "string",
              "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
            }
          },
          "description": "Owned PNG/JPEG/WebP revision for Meshy image-to-3D. At most 12 MiB. Mutually exclusive with source.",
          "additionalProperties": false
        },
        "concepts": {
          "type": "array",
          "items": {
            "type": "object",
            "required": [
              "assetId",
              "revisionId"
            ],
            "properties": {
              "assetId": {
                "type": "string",
                "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
              },
              "fileRole": {
                "type": "string",
                "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
              },
              "revisionId": {
                "type": "string",
                "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
              }
            },
            "additionalProperties": false
          },
          "maxItems": 4,
          "minItems": 1,
          "description": "Coherent views of ONE building, front first, for Meshy multi-image-to-3D. Exclusive with concept/source. Review coherence before building."
        },
        "delivery": {
          "type": "object",
          "required": [
            "lods"
          ],
          "properties": {
            "lods": {
              "type": "array",
              "items": {
                "type": "object",
                "required": [
                  "triangles",
                  "textureSize"
                ],
                "properties": {
                  "maxError": {
                    "type": "number",
                    "maximum": 0.02,
                    "minimum": 0
                  },
                  "triangles": {
                    "type": "integer",
                    "maximum": 200000,
                    "minimum": 1000
                  },
                  "lockBorder": {
                    "type": "boolean"
                  },
                  "textureSize": {
                    "anyOf": [
                      {
                        "type": "number",
                        "const": 1024
                      },
                      {
                        "type": "number",
                        "const": 2048
                      },
                      {
                        "type": "number",
                        "const": 4096
                      },
                      {
                        "type": "number",
                        "const": 8192
                      }
                    ]
                  }
                },
                "additionalProperties": false
              },
              "maxItems": 3,
              "minItems": 1
            }
          },
          "description": "Preserve an immutable full-detail source without provider remeshing, then prepare 1–3 independent LOD GLBs. Highest detail first, decreasing triangles and texture sizes. Default maxError=.001, lockBorder=true prioritizes detail and may exceed targets. For distant levels, explicitly allow e.g. maxError=.005/.01 and lockBorder=false after review. Shared metric fit and preserved PBR. No normal rebake, runtime LOD switching or inferred collision. Also works with source at no provider cost.",
          "additionalProperties": false
        },
        "provider": {
          "enum": [
            "meshy",
            "tripo"
          ],
          "type": "string",
          "description": "3D provider pinned to this recipe, Meshy by default. Tripo v3.1 requires one reviewed concept (no multiview yet) and uses v3.5 PBR textures. No automatic paid provider fallback."
        },
        "polycount": {
          "type": "integer",
          "maximum": 80000,
          "minimum": 4000
        },
        "dimensions": {
          "type": "object",
          "properties": {
            "depth": {
              "type": "number",
              "maximum": 100,
              "minimum": 3
            },
            "width": {
              "type": "number",
              "maximum": 100,
              "minimum": 3
            },
            "height": {
              "type": "number",
              "maximum": 150,
              "minimum": 3
            }
          },
          "description": "Maximum footprint and height in metres. Uniform fit preserves proportions; actual dimensions are returned.",
          "additionalProperties": false
        },
        "meshQuality": {
          "type": "object",
          "properties": {
            "texture": {
              "enum": [
                "2k",
                "4k",
                "8k"
              ],
              "type": "string"
            },
            "geometry": {
              "enum": [
                "standard",
                "2k",
                "4k"
              ],
              "type": "string"
            }
          },
          "description": "Meshy 7.1 quality. Defaults standard geometry and 2K PBR. Multi-image supports standard/2k geometry only. Texture resolution is preserved during optimization. Read the updated quote.",
          "additionalProperties": false
        },
        "tripoQuality": {
          "type": "object",
          "properties": {
            "texture": {
              "enum": [
                "standard",
                "detailed",
                "extreme"
              ],
              "type": "string"
            },
            "geometry": {
              "enum": [
                "standard",
                "detailed"
              ],
              "type": "string"
            }
          },
          "description": "Tripo-only quality; default detailed geometry and detailed textures. extreme requests 8K. Read the separate provider quote. Exclusive with Meshy meshQuality and source.",
          "additionalProperties": false
        }
      },
      "additionalProperties": false
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100
    },
    "concept_views": {
      "type": "array",
      "items": {
        "enum": [
          "front_right",
          "front_left",
          "rear_right",
          "rear_left"
        ],
        "type": "string"
      },
      "maxItems": 4,
      "minItems": 1,
      "description": "Unique views starting with front_right. Default one view for scene or Tripo, three for isolated Meshy. Tripo requires one view. Alternate views edit the SAME master. recipe.concept reuses an existing master; concept_reference guides a NEW master."
    },
    "idempotency_key": {
      "type": "string",
      "pattern": "^[a-zA-Z0-9_.:-]{8,160}$"
    },
    "concept_provider": {
      "enum": [
        "openai",
        "xai"
      ],
      "type": "string",
      "description": "Default openai (GPT Image 2.5 Sunburst, high quality). xai explicitly selects Imagine. Provider is pinned in the durable job; never silently falls back. Read the provider-specific concept_quote."
    },
    "concept_reference": {
      "type": "object",
      "required": [
        "assetId",
        "revisionId"
      ],
      "properties": {
        "assetId": {
          "type": "string",
          "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
        },
        "fileRole": {
          "type": "string",
          "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
        },
        "revisionId": {
          "type": "string",
          "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
        }
      },
      "description": "Owned artistic reference to EDIT into new scene/isolated views. Distinct from recipe.concept, which reuses an existing front view without generation. Exclusive with recipe.concept/concepts/source and stage=build.",
      "additionalProperties": false
    },
    "concept_presentation": {
      "enum": [
        "scene",
        "isolated"
      ],
      "type": "string",
      "description": "Default scene: artistic concept in its neighbourhood preserving the user atmosphere and lighting. isolated: technical views of the SAME building for 3D reconstruction. Keep rich architectural detail in both."
    }
  }
}
gripforge_generate_building annotations
{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_generate_district — Generate a district
Advertised by the server during the last successful anonymous check.
Open-world

Plan then build a straight-street district from 1–8 distinct Meshy/Tripo buildings, each manufactured once and reused as separate editable instances. Includes road, pavements, spawn, daylight and camera in the shared Map SceneDocument. Optional owned PBR road/pavement maps; otherwise simple solid surfaces. Plan returns layout, provider-credit count and account quote without spending. Build requires a budget and returns a persistent job, then Map Studio link. Private work version requiring visual review; no automatic Community publication or game replacement.

gripforge_generate_district input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "recipe"
  ],
  "properties": {
    "stage": {
      "enum": [
        "plan",
        "build"
      ],
      "type": "string",
      "description": "Default plan is free and does not generate. Read its quote, then explicitly build."
    },
    "budget": {
      "type": "object",
      "properties": {
        "usd": {
          "type": "number",
          "minimum": 0
        },
        "credits": {
          "type": "number",
          "minimum": 0
        }
      },
      "description": "Required for paid concept/build: maximum GripForge credits OR subscription USD accepted. Use the quote funding currency: insufficient AI allowance falls back to GripForge credits for the whole new job, never both. Use plan.concept_quote for images, plan.quote for Meshy. Provider credits are separate.",
      "additionalProperties": false
    },
    "recipe": {
      "type": "object",
      "required": [
        "buildings"
      ],
      "properties": {
        "gap": {
          "type": "number",
          "maximum": 30,
          "minimum": 1
        },
        "name": {
          "type": "string",
          "maxLength": 100,
          "minLength": 1
        },
        "version": {
          "type": "number",
          "const": 1
        },
        "buildings": {
          "type": "array",
          "items": {
            "type": "object",
            "required": [
              "prompt"
            ],
            "properties": {
              "id": {
                "type": "string",
                "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_-]{0,47}$"
              },
              "use": {
                "enum": [
                  "residential",
                  "retail",
                  "office",
                  "industrial",
                  "mixed"
                ],
                "type": "string"
              },
              "look": {
                "enum": [
                  "stylized",
                  "painted",
                  "toon",
                  "anime",
                  "realistic",
                  "lowpoly",
                  "pixel"
                ],
                "type": "string",
                "description": "Rendering look, separate from the game style: stylized (neutral) | painted | toon | anime | realistic | lowpoly | pixel. Old values (handpainted, cartoon, low_poly…) are read as aliases. Omit for the style default. Fills style when style is omitted; toon, anime and pixel add their phrase to the prompt."
              },
              "name": {
                "type": "string",
                "maxLength": 100,
                "minLength": 1
              },
              "roof": {
                "enum": [
                  "flat",
                  "pitched"
                ],
                "type": "string"
              },
              "style": {
                "enum": [
                  "realistic",
                  "stylized",
                  "lowpoly",
                  "handpainted"
                ],
                "type": "string"
              },
              "facade": {
                "type": "string",
                "maxLength": 120
              },
              "finish": {
                "type": "object",
                "required": [
                  "version",
                  "remove",
                  "parts"
                ],
                "properties": {
                  "parts": {
                    "type": "array",
                    "items": {
                      "oneOf": [
                        {
                          "type": "object",
                          "required": [
                            "kind",
                            "id",
                            "color",
                            "origin",
                            "width",
                            "height"
                          ],
                          "properties": {
                            "id": {
                              "type": "string",
                              "pattern": "^[a-zA-Z0-9_-]{1,48}$"
                            },
                            "yaw": {
                              "type": "number",
                              "maximum": 6.283185307179586,
                              "minimum": -6.283185307179586
                            },
                            "kind": {
                              "type": "string",
                              "const": "shutter"
                            },
                            "color": {
                              "type": "string",
                              "pattern": "^#[0-9a-f]{6}$"
                            },
                            "width": {
                              "type": "number",
                              "maximum": 15,
                              "minimum": 0.2
                            },
                            "height": {
                              "type": "number",
                              "maximum": 12,
                              "minimum": 0.1
                            },
                            "origin": {
                              "type": "array",
                              "prefixItems": [
                                {
                                  "type": "number",
                                  "maximum": 150,
                                  "minimum": -150
                                },
                                {
                                  "type": "number",
                                  "maximum": 150,
                                  "minimum": -150
                                },
                                {
                                  "type": "number",
                                  "maximum": 150,
                                  "minimum": -150
                                }
                              ]
                            },
                            "metalness": {
                              "type": "number",
                              "maximum": 1,
                              "minimum": 0
                            },
                            "roughness": {
                              "type": "number",
                              "maximum": 1,
                              "minimum": 0.05
                            },
                            "slatHeight": {
                              "type": "number",
                              "maximum": 0.3,
                              "minimum": 0.035
                            }
                          },
                          "additionalProperties": false
                        },
                        {
                          "type": "object",
                          "required": [
                            "kind",
                            "id",
                            "color",
                            "points",
                            "height"
                          ],
                          "properties": {
                            "id": {
                              "type": "string",
                              "pattern": "^[a-zA-Z0-9_-]{1,48}$"
                            },
                            "kind": {
                              "type": "string",
                              "const": "railing"
                            },
                            "color": {
                              "type": "string",
                              "pattern": "^#[0-9a-f]{6}$"
                            },
                            "height": {
                              "type": "number",
                              "maximum": 12,
                              "minimum": 0.1
                            },
                            "points": {
                              "type": "array",
                              "items": {
                                "type": "array",
                                "prefixItems": [
                                  {
                                    "type": "number",
                                    "maximum": 150,
                                    "minimum": -150
                                  },
                                  {
                                    "type": "number",
                                    "maximum": 150,
                                    "minimum": -150
                                  },
                                  {
                                    "type": "number",
                                    "maximum": 150,
                                    "minimum": -150
                                  }
                                ]
                              },
                              "maxItems": 16,
                              "minItems": 2
                            },
                            "barRadius": {
                              "type": "number",
                              "maximum": 0.05,
                              "minimum": 0.006
                            },
                            "metalness": {
                              "type": "number",
                              "maximum": 1,
                              "minimum": 0
                            },
                            "roughness": {
                              "type": "number",
                              "maximum": 1,
                              "minimum": 0.05
                            },
                            "barSpacing": {
                              "type": "number",
                              "maximum": 0.5,
                              "minimum": 0.05
                            },
                            "postRadius": {
                              "type": "number",
                              "maximum": 0.1,
                              "minimum": 0.015
                            },
                            "railRadius": {
                              "type": "number",
                              "maximum": 0.08,
                              "minimum": 0.01
                            },
                            "postSpacing": {
                              "type": "number",
                              "maximum": 3,
                              "minimum": 0.2
                            }
                          },
                          "additionalProperties": false
                        }
                      ]
                    },
                    "maxItems": 32,
                    "minItems": 1
                  },
                  "remove": {
                    "type": "array",
                    "items": {
                      "type": "object",
                      "required": [
                        "center",
                        "size"
                      ],
                      "properties": {
                        "size": {
                          "type": "array",
                          "prefixItems": [
                            {
                              "type": "number",
                              "maximum": 100,
                              "minimum": 0.001
                            },
                            {
                              "type": "number",
                              "maximum": 100,
                              "minimum": 0.001
                            },
                            {
                              "type": "number",
                              "maximum": 100,
                              "minimum": 0.001
                            }
                          ]
                        },
                        "center": {
                          "type": "array",
                          "prefixItems": [
                            {
                              "type": "number",
                              "maximum": 150,
                              "minimum": -150
                            },
                            {
                              "type": "number",
                              "maximum": 150,
                              "minimum": -150
                            },
                            {
                              "type": "number",
                              "maximum": 150,
                              "minimum": -150
                            }
                          ]
                        },
                        "rotation": {
                          "type": "array",
                          "prefixItems": [
                            {
                              "type": "number",
                              "maximum": 6.283185307179586,
                              "minimum": -6.283185307179586
                            },
                            {
                              "type": "number",
                              "maximum": 6.283185307179586,
                              "minimum": -6.283185307179586
                            },
                            {
                              "type": "number",
                              "maximum": 6.283185307179586,
                              "minimum": -6.283185307179586
                            }
                          ]
                        }
                      },
                      "additionalProperties": false
                    },
                    "maxItems": 64
                  },
                  "version": {
                    "type": "number",
                    "const": 1
                  }
                },
                "description": "Free deterministic repair of an owned source + delivery. All coordinates are Y-up metres AFTER the returned importTransform. Explicit oriented removal boxes (rotation XYZ radians), regular shutters (+Z outward, yaw radians) and railing paths (feet, vertical posts, supports slopes). Measure and review regions first. Applied AFTER each LOD simplification to keep thin parts straight. Textures outside cuts stay byte-identical; removed surfaces are not capped. Triangle targets remain soft. No AI auto-segmentation or collision repair.",
                "additionalProperties": false
              },
              "floors": {
                "type": "integer",
                "maximum": 30,
                "minimum": 1
              },
              "prompt": {
                "type": "string",
                "maxLength": 300,
                "minLength": 3
              },
              "source": {
                "type": "object",
                "required": [
                  "assetId",
                  "revisionId"
                ],
                "properties": {
                  "assetId": {
                    "type": "string",
                    "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
                  },
                  "fileRole": {
                    "type": "string",
                    "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
                  },
                  "revisionId": {
                    "type": "string",
                    "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
                  }
                },
                "description": "Reuse an owned static GLB revision instead of paying for this building. The source is never modified.",
                "additionalProperties": false
              },
              "concept": {
                "type": "object",
                "required": [
                  "assetId",
                  "revisionId"
                ],
                "properties": {
                  "assetId": {
                    "type": "string",
                    "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
                  },
                  "fileRole": {
                    "type": "string",
                    "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
                  },
                  "revisionId": {
                    "type": "string",
                    "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
                  }
                },
                "description": "Owned PNG/JPEG/WebP revision for Meshy image-to-3D. At most 12 MiB. Mutually exclusive with source.",
                "additionalProperties": false
              },
              "concepts": {
                "type": "array",
                "items": {
                  "type": "object",
                  "required": [
                    "assetId",
                    "revisionId"
                  ],
                  "properties": {
                    "assetId": {
                      "type": "string",
                      "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
                    },
                    "fileRole": {
                      "type": "string",
                      "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
                    },
                    "revisionId": {
                      "type": "string",
                      "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$"
                    }
                  },
                  "additionalProperties": false
                },
                "maxItems": 4,
                "minItems": 1,
                "description": "Coherent views of ONE building, front first, for Meshy multi-image-to-3D. Exclusive with concept/source. Review coherence before building."
              },
              "delivery": {
                "type": "object",
                "required": [
                  "lods"
                ],
                "properties": {
                  "lods": {
                    "type": "array",
                    "items": {
                      "type": "object",
                      "required": [
                        "triangles",
                        "textureSize"
                      ],
                      "properties": {
                        "maxError": {
                          "type": "number",
                          "maximum": 0.02,
                          "minimum": 0
                        },
                        "triangles": {
                          "type": "integer",
                          "maximum": 200000,
                          "minimum": 1000
                        },
                        "lockBorder": {
                          "type": "boolean"
                        },
                        "textureSize": {
                          "anyOf": [
                            {
                              "type": "number",
                              "const": 1024
                            },
                            {
                              "type": "number",
                              "const": 2048
                            },
                            {
                              "type": "number",
                              "const": 4096
                            },
                            {
                              "type": "number",
                              "const": 8192
                            }
                          ]
                        }
                      },
                      "additionalProperties": false
                    },
                    "maxItems": 3,
                    "minItems": 1
                  }
                },
                "description": "Preserve an immutable full-detail source without provider remeshing, then prepare 1–3 independent LOD GLBs. Highest detail first, decreasing triangles and texture sizes. Default maxError=.001, lockBorder=true prioritizes detail and may exceed targets. For distant levels, explicitly allow e.g. maxError=.005/.01 and lockBorder=false after review. Shared metric fit and preserved PBR. No normal rebake, runtime LOD switching or inferred collision. Also works with source at no provider cost.",
                "additionalProperties": false
              },
              "provider": {
                "enum": [
                  "meshy",
                  "tripo"
                ],
                "type": "string",
                "description": "3D provider pinned to this recipe, Meshy by default. Tripo v3.1 requires one reviewed concept (no multiview yet) and uses v3.5 PBR textures. No automatic paid provider fallback."
              },
              "polycount": {
                "type": "integer",
                "maximum": 80000,
                "minimum": 4000
              },
              "dimensions": {
                "type": "object",
                "properties": {
                  "depth": {
                    "type": "number",
                    "maximum": 100,
                    "minimum": 3
                  },
                  "width": {
                    "type": "number",
                    "maximum": 100,
                    "minimum": 3
                  },
                  "height": {
                    "type": "number",
                    "maximum": 150,
                    "minimum": 3
                  }
                },
                "description": "Maximum footprint and height in metres. Uniform fit preserves proportions; actual dimensions are returned.",
                "additionalProperties": false
              },
              "meshQuality": {
                "type": "object",
                "properties": {
                  "texture": {
                    "enum": [
                      "2k",
                      "4k",
                      "8k"
                    ],
                    "type": "string"
                  },
                  "geometry": {
                    "enum": [
                      "standard",
                      "2k",
                      "4k"
                    ],
                    "type": "string"
                  }
                },
                "description": "Meshy 7.1 quality. Defaults standard geometry and 2K PBR. Multi-image supports standard/2k geometry only. Texture resolution is preserved during optimization. Read the updated quote.",
                "additionalProperties": false
              },
              "tripoQuality": {
                "type": "object",
                "properties": {
                  "texture": {
                    "enum": [
                      "standard",
                      "detailed",
                      "extreme"
                    ],
                    "type": "string"
                  },
                  "geometry": {
                    "enum": [
                      "standard",
                      "detailed"
                    ],
                    "type": "string"
                  }
                },
                "description": "Tripo-only quality; default detailed geometry and detailed textures. extreme requests 8K. Read the separate provider quote. Exclusive with Meshy meshQuality and source.",
                "additionalProperties": false
              }
            },
            "additionalProperties": false
          },
          "maxItems": 8,
          "minItems": 1,
          "description": "Unique building definitions with distinct ids. Each new model is manufactured once."
        },
        "materials": {
          "type": "object",
          "properties": {
            "road": {
              "type": "object",
              "description": "SceneMaterialOverride: color, roughness, metalness, map/normalMap/roughnessMap/metalnessMap as owned immutable SceneAssetRef, repeat:[u,v]. Validated by the shared Scene Engine.",
              "propertyNames": {
                "type": "string"
              },
              "additionalProperties": {}
            },
            "sidewalk": {
              "type": "object",
              "description": "SceneMaterialOverride: color, roughness, metalness, map/normalMap/roughnessMap/metalnessMap as owned immutable SceneAssetRef, repeat:[u,v]. Validated by the shared Scene Engine.",
              "propertyNames": {
                "type": "string"
              },
              "additionalProperties": {}
            }
          },
          "additionalProperties": false
        },
        "repetitions": {
          "type": "integer",
          "maximum": 4,
          "minimum": 1,
          "description": "Instances per definition, without additional model generation cost."
        },
        "streetWidth": {
          "type": "number",
          "maximum": 30,
          "minimum": 6
        },
        "sidewalkWidth": {
          "type": "number",
          "maximum": 8,
          "minimum": 1
        }
      },
      "additionalProperties": false
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100
    },
    "idempotency_key": {
      "type": "string",
      "pattern": "^[a-zA-Z0-9_.:-]{8,160}$"
    }
  }
}
gripforge_generate_district annotations
{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_environment_module — Create a reusable environment module
Advertised by the server during the last successful anonymous check.
Open-world

Free parametric 3D masonry, independent of any game: pillar, arch, fountain, stairs, wall, pavement, rock, cliff, ruin, bridge, watchtower, shrine or a stone guardian. inspect (default) returns real generated bounds, triangle count, metric recipe and assembly sockets. build saves a private textured GLB in the Library, with bevelled geometry, baked vertex shading and named stone/recess/trim/water materials. Dimensions are nominal metres; bounds report actual moulding overhang. Ground origin, stairs ascend toward -Z, <=23 cm risers; top/bottom sockets support assembly. Seed and palette are repeatable. Does not place assets, generate arbitrary AI models, publish, or guarantee navigation/collisions in a target game. 0 credits.

gripforge_environment_module input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "recipe"
  ],
  "properties": {
    "name": {
      "type": "string",
      "maxLength": 100,
      "minLength": 1
    },
    "stage": {
      "enum": [
        "inspect",
        "build"
      ],
      "type": "string"
    },
    "recipe": {
      "type": "object",
      "required": [
        "module"
      ],
      "properties": {
        "seed": {
          "type": "integer",
          "maximum": 2147483646,
          "minimum": 0
        },
        "depth": {
          "type": "number",
          "maximum": 40,
          "minimum": 0.3
        },
        "width": {
          "type": "number",
          "maximum": 40,
          "minimum": 0.3
        },
        "height": {
          "type": "number",
          "maximum": 20,
          "minimum": 0.05
        },
        "module": {
          "enum": [
            "pillar",
            "arch",
            "fountain",
            "stairs",
            "wall",
            "pavement",
            "rock",
            "cliff",
            "ruin",
            "bridge",
            "watchtower",
            "shrine",
            "guardian"
          ],
          "type": "string"
        },
        "palette": {
          "type": "object",
          "properties": {
            "trim": {
              "type": "string",
              "pattern": "^#[0-9a-f]{6}$"
            },
            "stone": {
              "type": "string",
              "pattern": "^#[0-9a-f]{6}$"
            },
            "water": {
              "type": "string",
              "pattern": "^#[0-9a-f]{6}$"
            },
            "recess": {
              "type": "string",
              "pattern": "^#[0-9a-f]{6}$"
            }
          },
          "additionalProperties": false
        },
        "pattern": {
          "enum": [
            "radial",
            "botanical"
          ],
          "type": "string",
          "description": "Pavement only: botanical adds a broad leaf rosette inlay, radial keeps the original restrained rings."
        }
      },
      "additionalProperties": false
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100
    }
  }
}
gripforge_environment_module annotations
{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_urban_building — Manufacture a reusable urban building
Advertised by the server during the last successful anonymous check.
Open-world

Free, deterministic parametric architecture. plan validates a metric recipe; build queues a durable common-compute job and returns job_id to poll with gripforge_generation_read. Real window reveals, balconies, shopfronts, rooftop HVAC, photographic PBR and optional arid shutters/canopies/water tanks. Private immutable GLB plus recipe/report; reuse via Library bindings or scene instances. Nominal width/depth exclude protrusions: use returned actual bounds and preserve proportions. A solid envelope with storefront depth, not traversable interiors, a complete city or an AI replacement for gripforge_generate_building. Review in the actual game. 0 credits.

gripforge_urban_building input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "recipe"
  ],
  "properties": {
    "stage": {
      "enum": [
        "plan",
        "build"
      ],
      "type": "string"
    },
    "recipe": {
      "type": "object",
      "required": [
        "name",
        "style"
      ],
      "properties": {
        "name": {
          "type": "string",
          "maxLength": 100,
          "minLength": 1
        },
        "seed": {
          "type": "integer",
          "maximum": 2147483646,
          "minimum": 0
        },
        "shop": {
          "type": "integer",
          "maximum": 7,
          "minimum": 0
        },
        "depth": {
          "type": "number",
          "maximum": 30,
          "minimum": 6
        },
        "style": {
          "enum": [
            "brick",
            "balconies",
            "limestone",
            "loft",
            "workshop",
            "office",
            "stucco"
          ],
          "type": "string"
        },
        "width": {
          "type": "number",
          "maximum": 30,
          "minimum": 6
        },
        "detail": {
          "enum": [
            "standard",
            "street"
          ],
          "type": "string",
          "description": "street: bevelled architectural trims, dielectric window glazing, deep room pockets and separate surface families."
        },
        "floors": {
          "type": "integer",
          "maximum": 20,
          "minimum": 1
        },
        "climate": {
          "enum": [
            "temperate",
            "arid"
          ],
          "type": "string"
        },
        "palette": {
          "type": "object",
          "properties": {
            "roof": {
              "type": "string",
              "pattern": "^#[a-fA-F0-9]{6}$"
            },
            "trim": {
              "type": "string",
              "pattern": "^#[a-fA-F0-9]{6}$"
            },
            "stone": {
              "type": "string",
              "pattern": "^#[a-fA-F0-9]{6}$"
            },
            "facade": {
              "type": "string",
              "pattern": "^#[a-fA-F0-9]{6}$"
            }
          },
          "additionalProperties": false
        }
      },
      "additionalProperties": false
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100
    },
    "idempotency_key": {
      "type": "string",
      "pattern": "^[a-zA-Z0-9_.:-]{8,160}$"
    }
  }
}
gripforge_urban_building annotations
{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_game_concepts — Game concepts
Advertised by the server during the last successful anonymous check.
Open-world

Concept art for a whole game, reused before generated. Use it when a user asks for a game like a title they name: call stage=plan with the game as they wrote it. When the user describes specific items (heroes, weapons, props…), pass them in wishes: they are drawn exactly as asked. The plan lists concepts that already exist for that game (GripForge community catalog or the workspace) and theme assets already in the library: reuse them first. It then prices the missing concepts: one style bible, heroes and bosses one image each (MOBA and hero games: each hero with its ability kit and ability icons, see hero_kits), enemies, NPCs, weapons, vehicles, buildings, props and VFX in sheets of 6 cut automatically, textures in sheets of 2 turned into seamless 1024 px textures. Maps (counts.maps) are environment paintings, one image each: the level is then built and dressed to match them. Show the plan and price to the user; only call stage=build with a budget after they agree. Concepts are private review images; nothing is sent to 3D. The plan also returns ambient_kits: the kits of the theme's atmosphere (weather, lighting, snow tracks) with their config; install them in the game project next to the blueprint's gameplay kits.

gripforge_game_concepts input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "game": {
      "type": "string",
      "maxLength": 120,
      "minLength": 2,
      "description": "The game the user named, exactly as they wrote it (a title, \"like <title>\", \"a <title>\"). Matched server side against the recognised titles and aliases."
    },
    "stage": {
      "enum": [
        "catalog",
        "plan",
        "build"
      ],
      "type": "string",
      "description": "catalog: blueprints (slot counts), theme packs and how many named games are recognised (their titles stay server side). plan (default, free): what already exists and is reused, what would be generated, and the price. build: generate the missing concepts, requires budget."
    },
    "budget": {
      "type": "object",
      "properties": {
        "usd": {
          "type": "number",
          "minimum": 0
        },
        "credits": {
          "type": "number",
          "minimum": 0
        }
      },
      "description": "Required for build: maximum credits OR USD, at least the plan price.",
      "additionalProperties": false
    },
    "counts": {
      "type": "object",
      "properties": {
        "vfx": {
          "type": "integer",
          "maximum": 96,
          "minimum": 0
        },
        "maps": {
          "type": "integer",
          "maximum": 96,
          "minimum": 0
        },
        "npcs": {
          "type": "integer",
          "maximum": 96,
          "minimum": 0
        },
        "props": {
          "type": "integer",
          "maximum": 96,
          "minimum": 0
        },
        "bosses": {
          "type": "integer",
          "maximum": 96,
          "minimum": 0
        },
        "heroes": {
          "type": "integer",
          "maximum": 96,
          "minimum": 0
        },
        "enemies": {
          "type": "integer",
          "maximum": 96,
          "minimum": 0
        },
        "weapons": {
          "type": "integer",
          "maximum": 96,
          "minimum": 0
        },
        "textures": {
          "type": "integer",
          "maximum": 96,
          "minimum": 0
        },
        "vehicles": {
          "type": "integer",
          "maximum": 96,
          "minimum": 0
        },
        "buildings": {
          "type": "integer",
          "maximum": 96,
          "minimum": 0
        }
      },
      "description": "Concepts to generate per slot (heroes up to 24, maps up to 6: the first is the whole playfield from above, the others are zones seen through the game camera). Default: what the blueprint needs minus what is already reusable.",
      "additionalProperties": false
    },
    "custom": {
      "type": "object",
      "required": [
        "title",
        "blueprint",
        "pack",
        "build"
      ],
      "properties": {
        "pack": {
          "type": "string",
          "maxLength": 60,
          "description": "Closest theme pack from stage=catalog, e.g. nordic-mythology, cyberpunk."
        },
        "build": {
          "type": "string",
          "maxLength": 300,
          "minLength": 10,
          "description": "One sentence describing the original game to make."
        },
        "title": {
          "type": "string",
          "maxLength": 80,
          "minLength": 2
        },
        "blueprint": {
          "type": "string",
          "maxLength": 60,
          "description": "Closest blueprint from stage=catalog, e.g. third-person-action, open-world-rpg."
        }
      },
      "description": "Only when `game` is not in the catalog: describe the game with the closest blueprint and pack.",
      "additionalProperties": false
    },
    "wishes": {
      "type": "object",
      "properties": {
        "vfx": {
          "type": "array",
          "items": {
            "type": "string",
            "maxLength": 200,
            "minLength": 1
          },
          "maxItems": 24
        },
        "maps": {
          "type": "array",
          "items": {
            "type": "string",
            "maxLength": 200,
            "minLength": 1
          },
          "maxItems": 24
        },
        "npcs": {
          "type": "array",
          "items": {
            "type": "string",
            "maxLength": 200,
            "minLength": 1
          },
          "maxItems": 24
        },
        "props": {
          "type": "array",
          "items": {
            "type": "string",
            "maxLength": 200,
            "minLength": 1
          },
          "maxItems": 24
        },
        "bosses": {
          "type": "array",
          "items": {
            "type": "string",
            "maxLength": 200,
            "minLength": 1
          },
          "maxItems": 24
        },
        "heroes": {
          "type": "array",
          "items": {
            "type": "string",
            "maxLength": 200,
            "minLength": 1
          },
          "maxItems": 24
        },
        "enemies": {
          "type": "array",
          "items": {
            "type": "string",
            "maxLength": 200,
            "minLength": 1
          },
          "maxItems": 24
        },
        "weapons": {
          "type": "array",
          "items": {
            "type": "string",
            "maxLength": 200,
            "minLength": 1
          },
          "maxItems": 24
        },
        "textures": {
          "type": "array",
          "items": {
            "type": "string",
            "maxLength": 200,
            "minLength": 1
          },
          "maxItems": 24
        },
        "vehicles": {
          "type": "array",
          "items": {
            "type": "string",
            "maxLength": 200,
            "minLength": 1
          },
          "maxItems": 24
        },
        "buildings": {
          "type": "array",
          "items": {
            "type": "string",
            "maxLength": 200,
            "minLength": 1
          },
          "maxItems": 24
        }
      },
      "description": "What the user asked for, per slot, one short description per item (max 24 per slot, 200 chars each), e.g. {\"heroes\": [\"old bald karate master in a worn gi\", \"masked luchador\"], \"weapons\": [\"pump shotgun\", \"hunting rifle\"]}. Binding: the pack produces exactly these items, in this order (named and detailed, never replaced). The slot count defaults to the number of wishes; a larger count adds freely invented items. Always pass the characters, weapons or objects the user described here, not only in custom.build.",
      "additionalProperties": false
    },
    "provider": {
      "enum": [
        "openai",
        "xai"
      ],
      "type": "string",
      "description": "Default openai (GPT Image 2.5 sunburst: final quality for style bible, heroes and bosses, medium-quality sheets of 6 for the rest)."
    },
    "hero_kits": {
      "type": "boolean",
      "description": "Each hero comes with its ability kit — role, lane, basic attack, passive + Q/W/E/R (type, range, cooldown, cost, effect, VFX, cast animation) — and a sheet of 5 ability icons in its colours (1 more image per hero). Default from the blueprint: on for lane-arena (MOBA). Turn it on for any game whose heroes have abilities (hero shooter, ARPG)."
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100
    },
    "idempotency_key": {
      "type": "string",
      "pattern": "^[a-zA-Z0-9_.:-]{8,160}$"
    }
  }
}
gripforge_game_concepts annotations
{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_motion_generate — Generate motions from text
Advertised by the server during the last successful anonymous check.
Open-world

Custom animations generated from text with NVIDIA Kimodo on GripForge's GPU, retargeted onto a rigged Library character (or the UAL mannequin): spell casts, signature attacks, emotes, anything the standard clip pack (gripforge_animate) lacks. Kit mode turns a MOBA hero concept's basic attack and Q/W/E/R into clips in one call. Call stage=plan first (free) and show the prompts and price (1 credit per clip); stage=build queues a durable job — poll gripforge_generation_read with job_id (a cold GPU takes a few minutes). The result is a kind=animation Library item, one clip per prompt.

gripforge_motion_generate input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "name": {
      "type": "string",
      "maxLength": 120,
      "minLength": 2
    },
    "stage": {
      "enum": [
        "plan",
        "build"
      ],
      "type": "string",
      "description": "plan (default, free): the clips that would be made and their price. build: queue the GPU job."
    },
    "prompts": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "id",
          "text"
        ],
        "properties": {
          "id": {
            "type": "string",
            "pattern": "^[a-z0-9_]{1,40}$",
            "description": "Clip name, snake_case (e.g. \"slash_combo\")"
          },
          "text": {
            "type": "string",
            "maxLength": 400,
            "minLength": 8,
            "description": "The body movement in one or two sentences, e.g. \"A warrior swings a heavy sword overhead, then spins and slashes horizontally.\""
          },
          "duration": {
            "type": "number",
            "maximum": 10,
            "minimum": 1,
            "description": "Seconds, default 3"
          }
        },
        "additionalProperties": false
      },
      "maxItems": 12,
      "minItems": 1,
      "description": "Free clips, 1 to 12. Give either prompts or hero_concept_id."
    },
    "character_id": {
      "type": "string",
      "description": "Rigged Library character or enemy to retarget onto. Default: the UAL mannequin (any humanoid can reuse the clips later)."
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100
    },
    "hero_concept_id": {
      "type": "string",
      "description": "Kit mode: a hero concept with an ability kit (gripforge_game_concepts with hero_kits). Its basic attack and Q/W/E/R casts become one clip each, from the kit's \"animation\" lines."
    },
    "idempotency_key": {
      "type": "string",
      "pattern": "^[a-zA-Z0-9_.:-]{8,160}$"
    }
  }
}
gripforge_motion_generate annotations
{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_abilities_generate — Generate hero abilities
Advertised by the server during the last successful anonymous check.
Open-world

A hero's abilities ready to play in Character Studio: the kit (role, lane, basic attack, passive + Q/W/E/R with type, range, cooldown, cost, effect, VFX brief, cast animation) from a hero concept or written from one sentence; the basic attack and Q/W/E/R casts animated with NVIDIA Kimodo on the rigged character; and the gripforge.abilities/1 pack (targeting, damage/heal, timings) bound to those clips and stored on the result. Call stage=plan first (free) and show the abilities and price (1 credit per clip, 5 for a kit); then stage=build with the returned kit. Poll gripforge_generation_read with job_id; result.studio_url opens the Abilities tab. Numbers are starting values, not a balance pass; VFX lines are briefs for gripforge_vfx_generate.

gripforge_abilities_generate input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "kit": {
      "type": "object",
      "description": "The kit returned by plan: pass it to build to keep exactly what was shown.",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "name": {
      "type": "string",
      "maxLength": 80,
      "minLength": 2
    },
    "stage": {
      "enum": [
        "plan",
        "build"
      ],
      "type": "string",
      "description": "plan (default, free): the kit, its abilities and clips, and the price. build: queue the GPU job."
    },
    "prompt": {
      "type": "string",
      "maxLength": 600,
      "minLength": 8,
      "description": "The hero in one sentence when there is no concept, e.g. \"a frost archer who slows enemies, ultimate freezes an area\". Its kit is written at plan."
    },
    "character_id": {
      "type": "string",
      "description": "Rigged Library character or enemy the clips and abilities go on. Default: the UAL mannequin."
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100
    },
    "hero_concept_id": {
      "type": "string",
      "description": "A hero concept with an ability kit (gripforge_game_concepts with hero_kits)."
    },
    "idempotency_key": {
      "type": "string",
      "pattern": "^[a-zA-Z0-9_.:-]{8,160}$"
    }
  }
}
gripforge_abilities_generate annotations
{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_game_creation — Prepare and resume a game
Advertised by the server during the last successful anonymous check.
Open-world

The hosted orchestration for creating and continuing GripForge games from the web or terminal, one way among others (a Game Kit project made directly, the user's local project with gripforge game-attach, parts written by the user's AI: all welcome and mixable). Any game is accepted: no character, enemy, level, ending or known genre is required. The server owns planning, fabrication, development, checkpoints, budgets and verification of its own tasks; while one runs, do not run a second copy of it locally. If an existing creation id is supplied, get it and resume that exact project, never create a replacement. Ask which engine (Bevy (the GripForge player), Godot, Unity or Unreal) if unspecified and no engine project is in the folder of the user (project.godot, Unity ProjectSettings, an Unreal .uproject, a Bevy crate: then that engine); do not choose silently. A local project is never exported: once built, gripforge game-attach <gc_id|gkp_id> <folder> brings the game into it, whatever the engine. Creation mode is explicit, never guessed silently: when the user has not said it, ask whether the game is generated at once or built step by step. At once: quote build covers the whole saved queue; show its size and maximum price to the user (the first level is playable early, progress.playable). Step by step: each step is quoted, accepted and validated on its own: quote build for the foundation and the first playable level, then quote develop with a message naming the next step, one step at a time; the total duration or size plays no role. A game asked at once that is too long for one build switches to step by step, and the user is told; it is never refused. create saves a brief without spending. When the user already has their own plan (design documents, chosen kits), offer use_plan instead of the AI plan step: use_plan with expected_revision and plan_document (gripforge.game-plan/1: design = the game-designer proposal schema with origin/basis optional, plus optional title kept as written, modules or preset, controls, world, art_direction) is free, uses no AI and no quote, and reaches the same plan-ready state as an accepted AI plan (design agent user). The server keeps every content choice as written: it refuses only an unreadable or structurally invalid document, naming the exact field path, and returns plan_review { ready, diagnostics, suggestions } (kits that realise the features, missing world or controller, features outside the catalog to implement, items naming an absence, unmeasured quality metrics, a journey without a gameplay state). Show them to the user; apply_plan_suggestions with suggestions = the ids the user chose (apply=true) applies only those, never automatically. quote(operation=plan) never replaces a supplied plan; quote refine reworks it with the AI only on request. quote(operation=plan) estimates AI preparation (player_accounts=true adds player accounts through central.client even to a solo game; off by default, online multiplayer always has it), accept(quote_token) starts its durable job ONLY after user approval of the shown price. get returns a persistent operation log, slots, studio_url and the same project to resume. Planning can select an appropriate preset OR compose real engine-compatible modules. A missing preset never means the genre needs a native engine. composition.modules pins all module versions; composition.tasks lists the custom logic still to implement. New plans return design from a separate game-designer agent: named content lists and their counts, animation clips per actor, user-request versus agent-proposal attribution, assumptions and a machine-readable completion contract. Show this saved scope before assembly; refine changes it. get also returns production_sources. quote(operation=produce, production_source=one source ID) estimates a bounded production batch for any contract content, animation, capability or journey obligation; omit production_source to choose the next unprepared source. After price approval, accept runs decomposition, compatible Library matching, authored source documents and at most one concept board for missing visual assets, cropped into individually traceable review drafts. Audio, animation and executable VFX never become complete through a picture. An unavailable matcher with candidates requires review rather than speculative replacement. production.batches persists tasks, dependencies, acceptance checks, candidates, concepts, text, deferred work and diagnostics. asset_matched is not acquisition or integration. draft_ready is not gameplay verification. Changed design fingerprints retain old batches as stale. Use existing concept review/manufacturing and content tools for integration; Develop can read production batches using creation_production. Never report prepared-source coverage as game completeness. Assembly persists that contract on the project before auditing. A design is not implementation or passing evidence. The quoted planning budget includes this bounded stage; old accepted jobs retain their original behavior. New plans also return world: structure (open_world, semi_open, linear, arena, interior or circuit), deterministic seed, validated kit configurations, level documents and remaining work. Assembly applies this saved layout atomically. Reuse it when continuing in the CLI; a visual-theme change does not imply changing geography. A seed change alone is not a designed level. Show world.remaining, including unbuilt architecture or transitions, before calling the game complete. Assembly is a foundation, not a completed custom game: For contract-backed web games, quote build includes a persistent queue derived from every named source and capability, with isolated authoring sessions and independent final verification; there is no twelve-turn limit for the entire game. Review the quoted maximum before acceptance. Unattempted credit-funded tasks are not charged. development.work records reported_unverified and blocked tasks, retained authoring IDs and pending IDs; these are not release evidence. delivery.status=ready requires the build-specific contract and final checks. For an assembled project, quote operation=develop with an optional message to continue the saved queue under a new approved budget, preserving the same project and completed authoring work. The development result distinguishes agent-declared changes, actual checks, remaining work and unsupported runtime capabilities. Each additional pass needs its own estimate. When the contract requires a HUD, new build/develop quotes expose interface_preparation: they reuse the saved concept or include one bounded HUD concept generation and editable document. Its price is included; accepted older quotes never add it. Read creation_hud during authoring, implement the game data in its presenter and use the existing gripforge_hud runtime artistic review. A concept alone does not complete the HUD. Other asset generation requires its own quoted stage. The hosted development worker currently supports target web. For native targets, keep the shared plan, selections and build, then use the engine delivery/import adapter; native custom-code execution is not implemented by the hosted worker. Inside an already running development task, implement only that assigned task; never recursively create or accept a new creation job. After a build, get also returns creatures (the models bound so that no unit is a capsule) and audit { verdict: complete | playable_with_defects | incomplete, headline, fixed (the free fixes applied: models, standard clips, control scheme), defects [{ severity, message, fix { tool, args, credits? } }], next }: show the user the verdict and what is left, work through next (gripforge_game_audit reads it again), and never present a verdict other than complete as a finished game. quote refine with message updates the same plan after approval, preserves selected assets and reviewed work, and persists the conversation. use_reference with slot_id and an owned image asset_id supplies an uploaded concept for visual review. assets searches workspace/community items by actual role before invented generation details. Generic nature packs may cross world themes while keeping the rendering look. New plans consider available styles before inventing one; selection_reason explains planner choices. other_styles=true reveals alternatives with explicit mismatch/unknown compatibility for manual review; never bind a known look mismatch automatically. Prefer reuse before generation; select chooses one or sets mode=generate with a prompt. For generation: quote concept, obtain approval, accept, poll get, show the concept, approve_concept only after visual user review; quote generate, obtain approval, accept, poll and show the model in its studio. A quote with auto_select_character=true selects the missing main character by default when ready; it remains inspectable and replaceable. Other models, replacement generations and older approved jobs remain drafts: approve_asset only after visual review. Never infer visual approval from technical success. quote build then accept acquires the selected community assets and binds them to a Game Kit prototype; generated artwork and models must appear in the accepted quote. The main playable character is presented first. If no usable matching rigged/animated model is found, offer existing ones (gripforge assets show <lib_id> lists their clips) or its generation. A game without a character simply has no such slot. A slot left without an asset uses the module default or stays empty, and a generated model awaiting review is left out until approved; the answer says so (build_incomplete, character_concept_missing). Show missing_assets before approval; never imply that an incomplete prototype is finished. Native engine projects still need CLI delivery/import; a web project has a play_url. Revision required for edits. Every get, list item and action response carries status: idle | running | failed | cancelled | ready, with status_detail { job_id, operation, job_status, stage, message, actions }. Poll get while status=running; stop on failed or cancelled, show status_detail.message and offer the listed actions (retry, dismiss). On any error or failed job, follow client_guidance: explain, offer retry, step-by-step continuation or making that part in the project, then go on as the user chooses. pending alone never means in progress: a failed job stays pending until retried or dismissed. Cancel/retry preserve completed steps. Forward preparation_resume.resume_token through retry when offered. quote_continuation with geometry_mode=designed then accept_continuation with its quote_token use the same saved continuation as the web. platforms on create records web/mobile/windows/mac independently of the engine. A 2D request is made in 3D with a camera that keeps the 2D feel (warning 2d_not_supported). No automatic spending, invented asset IDs, or unrelated template substitutions. Build the engine of the game, never the game in code. The code holds only generic systems: plugged kits, rules set by parameters, hooks. All content is data loaded at run time: levels and scenes, characters, weapons, items, balance values, texts, assets and inputs, in data files or through modding (the game.engine contract), changeable without recompiling, on every engine (Bevy, Godot, Unity, Unreal) and on a local project. Adding a weapon, a level or an enemy is adding data, not code. Each asset is described by its passport (asset.meta, the mesh passport: skeleton, clips, colliders, LOD, weapon grips, sizes): the game reads clips, bones, grips and sizes from it and never writes a clip name, a bone or a scale in code; changing an asset is changing its passport, not the code (gripforge assets show <lib_id> shows it and says what it lacks). Recommend kits with this in mind: the ones whose config, registries and documents carry the content as data. GripForge never refuses a game action for a business reason: when something blocks, it goes on without it and returns warnings [{ code, message, skipped, howToFix }] (applied=false when nothing could be done). Read every warning, tell the user what was skipped, and follow howToFix or offer it; never treat a warning as a finished result. Only security refusals (sign-in, rights, paths outside the sandbox, payment quotas, data of others) remain errors.

gripforge_game_creation input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "action"
  ],
  "properties": {
    "q": {
      "type": "string",
      "maxLength": 100
    },
    "id": {
      "type": "string",
      "maxLength": 100
    },
    "mode": {
      "enum": [
        "select",
        "generate",
        "default"
      ],
      "type": "string"
    },
    "action": {
      "enum": [
        "list",
        "get",
        "assets",
        "create",
        "update_brief",
        "select",
        "use_reference",
        "approve_concept",
        "approve_asset",
        "quote",
        "accept",
        "cancel",
        "retry",
        "dismiss",
        "quote_continuation",
        "accept_continuation",
        "use_plan",
        "apply_plan_suggestions"
      ],
      "type": "string"
    },
    "engine": {
      "enum": [
        "bevy",
        "godot",
        "unity",
        "unreal",
        "web"
      ],
      "type": "string",
      "description": "bevy (the GripForge player: Rust/Bevy, WebGPU + WebGL2), godot, unity or unreal; web is the former name of bevy."
    },
    "prompt": {
      "type": "string",
      "maxLength": 2000
    },
    "source": {
      "enum": [
        "all",
        "workspace",
        "community"
      ],
      "type": "string"
    },
    "message": {
      "type": "string",
      "maxLength": 1500,
      "minLength": 3
    },
    "slot_id": {
      "type": "string",
      "maxLength": 100
    },
    "asset_id": {
      "type": "string",
      "maxLength": 100
    },
    "operation": {
      "enum": [
        "plan",
        "refine",
        "concept",
        "generate",
        "build",
        "develop",
        "produce"
      ],
      "type": "string"
    },
    "platforms": {
      "type": "array",
      "items": {
        "enum": [
          "web",
          "mobile",
          "windows",
          "mac"
        ],
        "type": "string"
      },
      "maxItems": 4,
      "minItems": 1
    },
    "first_game": {
      "type": "boolean"
    },
    "quote_token": {
      "type": "string",
      "maxLength": 100
    },
    "suggestions": {
      "type": "array",
      "items": {
        "type": "string",
        "maxLength": 200,
        "minLength": 1
      },
      "maxItems": 60,
      "minItems": 1
    },
    "other_styles": {
      "type": "boolean"
    },
    "resume_token": {
      "type": "string",
      "maxLength": 200
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100
    },
    "geometry_mode": {
      "type": "string",
      "const": "designed"
    },
    "plan_document": {
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "player_accounts": {
      "type": "boolean"
    },
    "allow_incomplete": {
      "type": "boolean"
    },
    "geometry_sources": {
      "type": "array",
      "items": {
        "type": "string",
        "maxLength": 100,
        "minLength": 1
      },
      "maxItems": 5000,
      "minItems": 1
    },
    "expected_revision": {
      "type": "integer",
      "maximum": 9007199254740991,
      "exclusiveMinimum": 0
    },
    "production_source": {
      "type": "string",
      "maxLength": 100
    }
  }
}
gripforge_game_creation annotations
{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_generate_weapon_catalog — Generate a weapon catalogue
Advertised by the server during the last successful anonymous check.
Open-world

Plan then manufacture 1–64 original static weapon models using the existing Meshy PBR pipeline. plan is free and returns an exact aggregate quote and plan_hash. build requires that hash, an explicit budget covering the quote and a stable idempotency_key. One durable job, two bounded fabrication lanes, per-weapon checkpoints and billing; cancellation/retry preserves finished work and provider task IDs. Results remain private work assets. Inspect geometry, textures and actual renderer output before publishing. Does not create attack/reload animations, grip bindings, or flexible-chain physics. Poll gripforge_generation_read; result.items contains Library IDs and Studio links.

gripforge_generate_weapon_catalog input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "stage",
    "entries"
  ],
  "properties": {
    "stage": {
      "enum": [
        "plan",
        "build"
      ],
      "type": "string"
    },
    "budget": {
      "type": "object",
      "properties": {
        "usd": {
          "type": "number",
          "minimum": 0
        },
        "credits": {
          "type": "number",
          "minimum": 0
        }
      },
      "additionalProperties": false
    },
    "entries": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "key",
          "name",
          "prompt",
          "subtype"
        ],
        "properties": {
          "key": {
            "type": "string",
            "pattern": "^[a-z0-9][a-z0-9_-]{0,47}$"
          },
          "name": {
            "type": "string",
            "maxLength": 160,
            "minLength": 1
          },
          "tags": {
            "type": "array",
            "items": {
              "type": "string",
              "maxLength": 60,
              "minLength": 1
            },
            "maxItems": 16
          },
          "style": {
            "enum": [
              "gun",
              "melee",
              "shield",
              "staff"
            ],
            "type": "string"
          },
          "prompt": {
            "type": "string",
            "maxLength": 2000,
            "minLength": 3,
            "description": "The weapon to model, up to 2000 characters accepted. The catalogue is made by Meshy text-to-3D: a description longer than its room (about 680 characters) is refused by name (prompt_too_long_for_provider) at the plan, never cut; gripforge_generate_weapon with provider \"gpu\" takes the 2000."
          },
          "subtype": {
            "type": "string",
            "maxLength": 60,
            "minLength": 1
          },
          "polycount": {
            "type": "integer",
            "maximum": 20000,
            "minimum": 500
          }
        },
        "additionalProperties": false
      },
      "maxItems": 64,
      "minItems": 1
    },
    "plan_hash": {
      "type": "string",
      "pattern": "^[a-f0-9]{64}$"
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Authorized workspace; defaults to the connected workspace."
    },
    "idempotency_key": {
      "type": "string",
      "pattern": "^[a-zA-Z0-9_.:-]{8,160}$"
    }
  }
}
gripforge_generate_weapon_catalog annotations
{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_generation_quote — Estimate generation usage before spending
Advertised by the server during the last successful anonymous check.
Advertised read-only

Free quote for a model, concept, texture, rig or animation. Reports the account funding mode, available balance and estimated operation cost. A subscription combines AI and paid asset generation in one monthly limit without also charging generation credits. Quote every missing role, propose the plan, and obtain a generation budget before submitting paid jobs. Estimates cover one operation, not the full concept/rig/review pipeline.

gripforge_generation_quote input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "kind"
  ],
  "properties": {
    "kind": {
      "enum": [
        "model",
        "concept",
        "texture",
        "rig",
        "animation"
      ],
      "type": "string"
    },
    "count": {
      "type": "integer",
      "maximum": 20,
      "minimum": 1
    },
    "source": {
      "enum": [
        "image",
        "text"
      ],
      "type": "string",
      "description": "provider compute: text = four images first (then the 3D when one is validated), image = image → 3D (default)"
    },
    "provider": {
      "enum": [
        "meshy",
        "tripo",
        "compute",
        "xai",
        "openai"
      ],
      "type": "string"
    },
    "auto_pick": {
      "type": "boolean",
      "description": "provider compute, source text: images + 3D in one (first image taken)"
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Authorized workspace; defaults to the connected workspace."
    }
  }
}
gripforge_generation_quote annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_asset_search — Search workspace and Community assets
Advertised by the server during the last successful anonymous check.
Advertised read-only

Search actual asset models, materials and animations, independently of Game Kit modules. Returns provenance, import requirements and Library ids. Results are ranked best first by fitness for a GripForge game (score/100, grade A–D, reasons: triangle budget for the target, rigged and clean rig, clips, empty-handed characters, attachable weapons, classified, file size, adoption); `best` is the top pick across sources. Prefer grade A/B; read the reasons before choosing a C/D. Search both sources before manufacturing missing roles. An empty kit search does not mean there are no assets. Search is free; never substitutes proxy geometry for finished models. In a Game Kit project, use it to fill what gripforge_game_audit reports missing (a creature slot gets ranked proposals from gripforge_gamekit_creatures; a character without clips is animated, not left idle).

gripforge_asset_search input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "q"
  ],
  "properties": {
    "q": {
      "type": "string",
      "maxLength": 200,
      "description": "Visual role or style, e.g. sci-fi turret, rock, soldier."
    },
    "kind": {
      "enum": [
        "character",
        "fps-arms",
        "enemy",
        "creatures",
        "weapon",
        "equipment",
        "prop",
        "vehicle",
        "texture",
        "skybox",
        "vfx",
        "animation",
        "audio",
        "kit"
      ],
      "type": "string",
      "description": "Optional asset kind. `vehicle` = props qualified vehicle (cars, karts, bikes). A single plain word in q matches whole words only (car does not return carbine or carrot)."
    },
    "sort": {
      "enum": [
        "rank",
        "newest"
      ],
      "type": "string",
      "description": "rank (default): best fit first; newest: most recent first."
    },
    "limit": {
      "type": "integer",
      "maximum": 48,
      "minimum": 1,
      "description": "Results per source; default 12."
    },
    "offset": {
      "type": "integer",
      "maximum": 10000,
      "minimum": 0,
      "description": "Pagination offset per source; default 0."
    },
    "source": {
      "enum": [
        "workspace",
        "community",
        "both"
      ],
      "type": "string",
      "description": "Defaults to both."
    },
    "target": {
      "enum": [
        "mobile",
        "desktop"
      ],
      "type": "string",
      "description": "Platform the game ships on: sets the triangle and file budgets of the rank. Defaults to mobile."
    },
    "subtype": {
      "type": "string",
      "maxLength": 40,
      "description": "Optional qualification inside the kind, e.g. vehicle, boot, door."
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Authorized workspace; defaults to the connected workspace."
    }
  }
}
gripforge_asset_search annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_asset_clone — Copy a Community asset to the workspace
Advertised by the server during the last successful anonymous check.

Copy a published Community asset into the connected workspace. Assets and armor sets are free by default. Only an explicit creator price is charged, using paid credits. Repeated takes are not billed again but may create another copy: reuse an existing workspace id when possible. Returns the private Library item and signed file URL. Download it with gripforge_library_pull, then import into the actual game.

gripforge_asset_clone input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "id"
  ],
  "properties": {
    "id": {
      "type": "string",
      "pattern": "^lib_[A-Za-z0-9_-]+$",
      "description": "Published Community Library id."
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Authorized workspace; defaults to the connected workspace."
    }
  }
}
gripforge_asset_clone annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_admin_assets — Platform assets (admin)
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

ADMIN ONLY. Every asset of the platform, all workspaces: filter by kind, owner, tag, pack, style, team rating (rating=none is the review queue) or curation (featured, hidden), sort by rating or size. Each row has its team rating (1–5), featured / hidden flags and its mobile rank (0–100). Pass id for one asset in full. Refused for non-admin keys. Change them with gripforge_admin_assets_update.

gripforge_admin_assets input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "q": {
      "type": "string",
      "maxLength": 120,
      "description": "Name, id, file name, owner or description."
    },
    "id": {
      "type": "string",
      "pattern": "^lib_[A-Za-z0-9_-]{8,64}$",
      "description": "One asset: its full detail (meta, usage, dependents) instead of a list."
    },
    "dir": {
      "enum": [
        "asc",
        "desc"
      ],
      "type": "string"
    },
    "tag": {
      "type": "string",
      "maxLength": 80
    },
    "kind": {
      "type": "string",
      "maxLength": 40
    },
    "pack": {
      "type": "string",
      "maxLength": 160
    },
    "page": {
      "type": "integer",
      "maximum": 9007199254740991,
      "minimum": 1
    },
    "size": {
      "type": "integer",
      "maximum": 100,
      "minimum": 1
    },
    "sort": {
      "enum": [
        "created_at",
        "updated_at",
        "bytes",
        "name",
        "triangles",
        "kind",
        "rating"
      ],
      "type": "string"
    },
    "owner": {
      "type": "string",
      "maxLength": 254
    },
    "style": {
      "type": "string",
      "maxLength": 80
    },
    "rating": {
      "enum": [
        "1",
        "2",
        "3",
        "4",
        "5",
        "none"
      ],
      "type": "string",
      "description": "none = not rated yet (the review queue)."
    },
    "curation": {
      "enum": [
        "featured",
        "hidden"
      ],
      "type": "string"
    },
    "published": {
      "enum": [
        "yes",
        "no"
      ],
      "type": "string"
    },
    "workspace": {
      "type": "string",
      "maxLength": 80
    }
  }
}
gripforge_admin_assets annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_admin_assets_update — Rate, tag and curate assets (admin)
Advertised by the server during the last successful anonymous check.
Open-world

ADMIN ONLY. Curate platform assets in bulk (up to 200 ids): rate 1–5 (moves the community rank), add or remove a tag, replace the tags of one asset, feature (first in the rank sort), hide (out of listings and search, still served by id), publish / unpublish, file into a pack. Every change is audited with the admin who made it. Find ids with gripforge_admin_assets. Deleting stays in the /admin/assets screen. Refused for non-admin keys.

gripforge_admin_assets_update input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "action",
    "ids"
  ],
  "properties": {
    "ids": {
      "type": "array",
      "items": {
        "type": "string",
        "pattern": "^lib_[A-Za-z0-9_-]{8,64}$"
      },
      "maxItems": 200,
      "minItems": 1
    },
    "tag": {
      "type": "string",
      "maxLength": 40,
      "minLength": 1
    },
    "pack": {
      "anyOf": [
        {
          "type": "string",
          "maxLength": 160,
          "minLength": 1
        },
        {
          "type": "null"
        }
      ]
    },
    "tags": {
      "type": "array",
      "items": {
        "type": "string",
        "maxLength": 40,
        "minLength": 1
      },
      "maxItems": 40,
      "description": "set_tags only."
    },
    "action": {
      "enum": [
        "rate",
        "tag",
        "untag",
        "set_tags",
        "feature",
        "unfeature",
        "hide",
        "unhide",
        "publish",
        "unpublish",
        "pack"
      ],
      "type": "string",
      "description": "rate: team rating 1–5 (rating null removes it), weighs on the rank (1★ −16 … 5★ +16). tag / untag: add or remove one tag. set_tags: replace the tags of ONE asset. feature: first in the community rank sort. hide: out of the community listings, search and sitemap, still served by its id (games keep it). publish / unpublish: community visibility. pack: file into a collection (pack null removes it)."
    },
    "rating": {
      "anyOf": [
        {
          "type": "integer",
          "maximum": 5,
          "minimum": 1
        },
        {
          "type": "null"
        }
      ]
    }
  }
}
gripforge_admin_assets_update annotations
{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_attach — Attach weapon to character
Advertised by the server during the last successful anonymous check.
Open-world

Attach a prop (sword, shield, gun, staff/scythe…) onto a rigged character. Finds the hand bone across naming schemes, scales the prop to the character, seats the grip, closes the fist, and returns a bind + ready-to-paste Unity / Godot snippets. For melee, provide prop_grip.edgeAxis (signed cutting direction, distinct from the flat normal) and handleSpan (usable handle length). Read bind.orientation and bind.contact; missing or ambiguous measurements remain needs_review. Pass Library ids (character_id / prop_id) or https URLs. attach_id reuses an existing armed bind GLB as the character. prop_id_2 attaches a second held item (off-hand) onto the first result. The bind (+ armed GLB when export_glb) is saved in Library — not a second credit. To write files into an open repo, use the npm MCP package gripforge_library_pull.

gripforge_attach input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "fist": {
      "type": "number",
      "maximum": 1,
      "minimum": 0,
      "description": "Fist closing 0→1 (default 1)"
    },
    "hand": {
      "enum": [
        "right",
        "left"
      ],
      "type": "string",
      "description": "Hand side (default right)"
    },
    "style": {
      "enum": [
        "melee",
        "gun",
        "shield",
        "staff"
      ],
      "type": "string",
      "description": "Grip style (default: geometric classification)"
    },
    "prop_id": {
      "type": "string",
      "description": "Library id of a prop (lib_…)"
    },
    "style_2": {
      "enum": [
        "melee",
        "gun",
        "shield",
        "staff"
      ],
      "type": "string",
      "description": "Style of the second held item"
    },
    "prop_url": {
      "type": "string",
      "description": "URL of the prop mesh"
    },
    "ai_refine": {
      "type": "boolean",
      "description": "Vision check of the grip (+10-30s)"
    },
    "attach_id": {
      "type": "string",
      "description": "Library bind id — armed GLB used as the character (second prop, or continue a kit)"
    },
    "prop_grip": {
      "type": "object",
      "required": [
        "position",
        "axis",
        "normal"
      ],
      "properties": {
        "axis": {
          "type": "array",
          "description": "Handle direction / shield top (+Y of the grip frame)",
          "prefixItems": [
            {
              "type": "number"
            },
            {
              "type": "number"
            },
            {
              "type": "number"
            }
          ]
        },
        "normal": {
          "type": "array",
          "description": "Blade flat / outward shield face (+Z of the grip frame)",
          "prefixItems": [
            {
              "type": "number"
            },
            {
              "type": "number"
            },
            {
              "type": "number"
            }
          ]
        },
        "edgeAxis": {
          "type": "array",
          "description": "Signed cutting/striking direction in the blade plane, perpendicular to axis and normal. Forward grip: away from wrist. This is NOT the blade flat normal.",
          "prefixItems": [
            {
              "type": "number"
            },
            {
              "type": "number"
            },
            {
              "type": "number"
            }
          ]
        },
        "position": {
          "type": "array",
          "description": "Grip point in the prop scene local coordinates",
          "prefixItems": [
            {
              "type": "number"
            },
            {
              "type": "number"
            },
            {
              "type": "number"
            }
          ]
        },
        "handleSpan": {
          "type": "number",
          "description": "Usable handle length centred on position, in prop-local units. Required for independent mesh section checks; curved handles use their local tangent.",
          "exclusiveMinimum": 0
        }
      },
      "description": "Exact prop grip frame; overrides geometric guesses. Returns orientation/contact diagnostics; missing or ambiguous geometry stays needs_review. A gf_grip locator can supply the same frame."
    },
    "prop_id_2": {
      "type": "string",
      "description": "Optional second held item (off-hand) attached after the first"
    },
    "export_glb": {
      "type": "boolean",
      "description": "Bake attached.glb into Library and return its signed URL"
    },
    "prop_url_2": {
      "type": "string",
      "description": "https URL of a second held item (off-hand)"
    },
    "prop_grip_2": {
      "type": "object",
      "required": [
        "position",
        "axis",
        "normal"
      ],
      "properties": {
        "axis": {
          "type": "array",
          "description": "Handle direction / shield top (+Y of the grip frame)",
          "prefixItems": [
            {
              "type": "number"
            },
            {
              "type": "number"
            },
            {
              "type": "number"
            }
          ]
        },
        "normal": {
          "type": "array",
          "description": "Blade flat / outward shield face (+Z of the grip frame)",
          "prefixItems": [
            {
              "type": "number"
            },
            {
              "type": "number"
            },
            {
              "type": "number"
            }
          ]
        },
        "edgeAxis": {
          "type": "array",
          "description": "Signed cutting/striking direction in the blade plane, perpendicular to axis and normal. Forward grip: away from wrist. This is NOT the blade flat normal.",
          "prefixItems": [
            {
              "type": "number"
            },
            {
              "type": "number"
            },
            {
              "type": "number"
            }
          ]
        },
        "position": {
          "type": "array",
          "description": "Grip point in the prop scene local coordinates",
          "prefixItems": [
            {
              "type": "number"
            },
            {
              "type": "number"
            },
            {
              "type": "number"
            }
          ]
        },
        "handleSpan": {
          "type": "number",
          "description": "Usable handle length centred on position, in prop-local units. Required for independent mesh section checks; curved handles use their local tangent.",
          "exclusiveMinimum": 0
        }
      },
      "description": "Exact prop grip frame; overrides geometric guesses. Returns orientation/contact diagnostics; missing or ambiguous geometry stays needs_review. A gf_grip locator can supply the same frame."
    },
    "character_id": {
      "type": "string",
      "description": "Library id of a character (lib_…)"
    },
    "height_ratio": {
      "type": "number",
      "maximum": 1.5,
      "minimum": 0.05,
      "description": "Prop size as a fraction of body height"
    },
    "character_url": {
      "type": "string",
      "description": "URL of the rigged character (.glb .gltf .fbx .obj)"
    },
    "height_ratio_2": {
      "type": "number",
      "maximum": 1.5,
      "minimum": 0.05
    }
  }
}
gripforge_attach output schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "bind": {
      "type": "object",
      "description": "Bind result: resolved bone, exact propTransform, grip pose, orientation/contact measurements and review reasons",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "credits": {
      "type": "object",
      "properties": {
        "plan": {
          "type": "string"
        },
        "used": {
          "type": "number"
        },
        "limit": {
          "type": "number"
        },
        "period": {
          "type": "string"
        },
        "remaining": {
          "type": "number"
        }
      },
      "description": "Account usage after this call",
      "additionalProperties": false
    },
    "exports": {
      "type": "object",
      "description": "Ready-to-paste engine snippets keyed by target (unity, godot, json)",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {
        "type": "string"
      }
    },
    "first_bind": {
      "type": "object",
      "description": "First hand bind and diagnostics when attaching a second prop",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "glb_download_url": {
      "type": "string",
      "description": "Download URL of the armed GLB (when export_glb is true)"
    }
  },
  "additionalProperties": false
}
gripforge_attach annotations
{
  "title": "Attach weapon to character",
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_hud — Design, apply and visually review a game HUD
Advertised by the server during the last successful anonymous check.
Open-world

Required completion gate: action=workflow stays ready=false until a current runtime capture passes all artistic criteria. After screen_assets/assembly, submit screen_item (or design/project), renderer_version, capture_item, capture and the authorized review_budget; workflow schedules the reviewer automatically. Poll workflow; correct and recapture if changes_requested. No paid retry loop. Genre-independent workflow: pass design (from plan, edited) WITHOUT project to get/quote/concept/review_quote/review. get returns the normalized design hash; quote then concept returns reference_item. For review supply design, reference_item, renderer_version (fingerprint of actual presenter/build including styles/assets/dependencies), capture_item and capture. Forward exact quote.next and poll the generation job. This reviews an immutable snapshot; compare returned identity with current files before reusing the result. No installed kit or per-genre adapter is needed for concept/review. Project mode remains available: Artistic QA: get returns renderer_version and the latest review with current/approved flags. Upload a fresh viewport screenshot to the private Library, then review_quote with capture_item + capture context; submit its exact next payload with review, poll the generation job and read get again. Corrections, stale evidence, missing criteria or unavailable vision never count as approval. Review applies only to the submitted state; preview evidence cannot approve map contrast. v2: action=templates lists reusable compositions and independent themes; plan derives a per-game design from the project art direction and actual capabilities; get reads it; apply writes the same editable document to hud.tactical and ui.theme with expected_revision; quote then concept queues an optional paid visual board. Poll the returned generation job. Studio edits the same document. Live web adapters: FPS hud.tactical, or a shared document presenter for health/mana/XP bars, currencies, quest trackers, panels, text and images using explicit bindings. Other widgets and native document presenters require integration. Never flatten the UI into the concept image or invent gameplay widgets. Omit action for the legacy survivor export. Generate a ready-to-drop survivor HUD: hud.json (layout/anchors, no pixels), original GripForge cartoon PNGs (hearts full/half/empty, portrait frame, currency chips, empty hex slot), a Godot 4 .tscn (Control with named nodes Health/XP/Portrait/Currencies/Minimap), and Unity / Unreal snippets. 1 credit per successful generate. CONSUMER RECIPE — (1) call gripforge_hud; (2) write the PNGs (download the asset URLs) + hud.json (+ hud.tscn) into the game repo, same folder; (3) Godot: instance the tscn, add_child, then get_node("Health").set_health(current, max) and set XP.value; (4) Unreal: the GripForgeHUD plugin must already be in the project (unreal_plugin_url) — point UGFHudWidget::CreateFromFolder at the folder and call BindHealth on your health component. DO NOT redraw the hearts. DO NOT open a UI editor. This hosted endpoint returns file CONTENTS + URLs; pass out_dir only with the npm MCP package, which writes the files for you.

gripforge_hud input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "brief": {
      "type": "string",
      "maxLength": 3000,
      "description": "Preserve user visual references verbatim, then describe typography, shapes, density and hierarchy independently of the world setting. quote returns the exact concept_prompt for inspection."
    },
    "theme": {
      "enum": [
        "harbor",
        "gothic",
        "neon",
        "minimal"
      ],
      "type": "string"
    },
    "title": {
      "type": "string",
      "maxLength": 120
    },
    "action": {
      "enum": [
        "templates",
        "plan",
        "get",
        "apply",
        "quote",
        "concept",
        "review_quote",
        "review",
        "workflow"
      ],
      "type": "string",
      "description": "v2 reusable design workflow; omit to keep the survivor v1 export."
    },
    "design": {
      "type": "object",
      "description": "Full design returned by plan, with edited document/theme/brief. Without project: standalone get, concept and artistic review for any genre. With project: apply only.",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "hud_id": {
      "type": "string"
    },
    "preset": {
      "type": "string",
      "const": "survivor",
      "description": "v1: survivor only (default)"
    },
    "capture": {
      "type": "object",
      "required": [
        "design_hash",
        "renderer_version",
        "viewport",
        "hud_scale",
        "source",
        "state"
      ],
      "properties": {
        "state": {
          "type": "string",
          "maxLength": 500
        },
        "source": {
          "enum": [
            "preview",
            "runtime"
          ],
          "type": "string"
        },
        "viewport": {
          "type": "object",
          "required": [
            "width",
            "height",
            "dpr"
          ],
          "properties": {
            "dpr": {
              "type": "number"
            },
            "width": {
              "type": "number"
            },
            "height": {
              "type": "number"
            }
          }
        },
        "hud_scale": {
          "type": "number"
        },
        "design_hash": {
          "type": "string"
        },
        "renderer_version": {
          "type": "string"
        }
      },
      "description": "Use hashes from get, dimensions in CSS pixels, actual dpr/scale and captured game state. Caller-submitted evidence, not server attestation."
    },
    "minimap": {
      "type": "boolean",
      "description": "default false"
    },
    "out_dir": {
      "type": "string",
      "description": "Suggested folder (hosted returns contents only; npm writes)"
    },
    "project": {
      "type": "string",
      "description": "Game Kit project id."
    },
    "bindings": {
      "type": "object",
      "description": "Non-FPS web apply: element ID to explicit binding. Bars: {kind:\"bar\",value:\"player.health\",max:\"player.health.max\"}; currencies: {kind:\"currencies\",sources:[{variable:\"bolts\",label:\"Bolts\",default:0}]}; quests: {kind:\"quest\",service:\"quest.graph\"} or service:\"mission.run\" for mission.system. Mission guidance is required by default: current objective, direction arrow and distance from the kit target; missing spatial targets remain incomplete. Unsupported visible widgets are rejected.",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "document": {
      "type": "object",
      "description": "Editable HUD Studio v2 document.",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "portrait": {
      "type": "boolean",
      "description": "default true"
    },
    "provider": {
      "enum": [
        "openai",
        "xai"
      ],
      "type": "string"
    },
    "template": {
      "type": "string",
      "maxLength": 40,
      "description": "tactical, rpg, survivor, kart, royale, moba; see templates."
    },
    "currencies": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "maxItems": 6,
      "description": "default [\"gem\",\"mushroom\",\"drop\"] — unknown ids get the empty hex chip"
    },
    "health_max": {
      "type": "integer",
      "maximum": 1000000,
      "minimum": 1,
      "description": "default 5"
    },
    "quote_hash": {
      "type": "string",
      "description": "Required for review and document-mode concept; forward the exact next payload from the quote."
    },
    "health_type": {
      "enum": [
        "hearts",
        "bar"
      ],
      "type": "string",
      "description": "default hearts"
    },
    "screen_item": {
      "type": "string",
      "description": "Analysed/cut screen Library ID. Uses its original concept and stored layout; omit design, project and reference_item. get/workflow/review_quote/review."
    },
    "capture_item": {
      "type": "string",
      "description": "Owned private Library image containing only the actual HUD viewport, not the concept. Required for review_quote/review."
    },
    "health_style": {
      "type": "string",
      "description": "skin of the health display. For hearts: round, pixel, shield, star, orb, potion, skull, croix, goutte, eclair, feuille, losange, soleil, lune, patte, os, flamme, flocon, trefle, couronne, anneau, pomme, viande, bonbon, oeil, plume, gland, cloche, poing, aile, hexplaque, rune, bougie, champi, bouclier_pique, coeur_gel, coeur_or, coeur_ombre, batterie, retro. For bar: ronde, segments, scifi, pixel_bar, fantasy, tube, fleches, cellules_hex, oblique, double, fine, crantee, crochets, capsule, rivets, retro_rouge, retro_vert, retro_bleu, retro_jaune, gothique, scifi_energie, cartoon_aventure, horreur. Also accepts \"custom:<slug>\" from gripforge_hud_bar. Default: round (hearts) / ronde (bar)."
    },
    "review_budget": {
      "type": "object",
      "properties": {
        "max_usd": {
          "type": "number",
          "minimum": 0
        },
        "max_credits": {
          "type": "integer",
          "maximum": 9007199254740991,
          "minimum": 0
        }
      },
      "description": "workflow: authorized cap for one review in the quoted currency. With a capture, schedules the existing reviewer automatically within this cap; repeated calls reuse the job."
    },
    "reference_item": {
      "type": "string",
      "description": "Document-mode review: chosen concept Library ID. No project link required; use concept result.reference_item or an existing reference."
    },
    "idempotency_key": {
      "type": "string",
      "pattern": "^[a-zA-Z0-9_.:-]{8,160}$"
    },
    "review_provider": {
      "enum": [
        "anthropic",
        "xai"
      ],
      "type": "string"
    },
    "reference_region": {
      "type": "object",
      "required": [
        "x",
        "y",
        "width",
        "height"
      ],
      "properties": {
        "x": {
          "type": "number"
        },
        "y": {
          "type": "number"
        },
        "width": {
          "type": "number"
        },
        "height": {
          "type": "number"
        }
      },
      "description": "Normalized 0..1 crop of the concept gameplay panel; exclude menu studies. Defaults to full image."
    },
    "renderer_version": {
      "type": "string",
      "maxLength": 160,
      "minLength": 10,
      "description": "Document mode: fingerprint of the actual HUD presenter/build including styles, fonts/assets and dependencies. Must match capture.renderer_version; declared by caller, not inferred from genre."
    },
    "expected_revision": {
      "type": "integer",
      "maximum": 9007199254740991,
      "description": "Required for project apply/concept/review; omitted in document mode. Forward quote.next.",
      "exclusiveMinimum": 0
    }
  }
}
gripforge_hud output schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {},
  "additionalProperties": {}
}
gripforge_hud annotations
{
  "title": "Design and review a game HUD",
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_cape — Rig a cape onto a character (bones + skinning + spring params)
Advertised by the server during the last successful anonymous check.
Open-world

Cape rig v2: generates a 3-column bone grid (gf_cape_c*r*) anchored to the neck/upper-spine bone, skins the cape mesh onto it (vertical blend × gaussian columns), and bakes attached_cape.glb (character + skinned cape). The cape then ANIMATES: run the returned Godot script (spring bones, attach to the Skeleton3D) — the engine simulates, the bind carries structure + suggested spring params. Inputs: Library ids (lib_…) or https URLs of GLBs. CONSUMER RECIPE — (1) call with character_id/cape_id; (2) download the baked glb from library.file_url; (3) drop cape-godot.gd next to it and attach to the Skeleton3D node. 1 credit.

gripforge_cape input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "rows": {
      "type": "integer",
      "maximum": 8,
      "minimum": 2,
      "description": "bone rows below anchor (default 5)"
    },
    "save": {
      "type": "boolean",
      "description": "save attached_cape.glb into Library (default true)"
    },
    "cape_id": {
      "type": "string",
      "description": "Library id of the cape mesh (lib_…)"
    },
    "columns": {
      "type": "integer",
      "maximum": 5,
      "minimum": 2,
      "description": "bone columns (default 3)"
    },
    "cape_url": {
      "type": "string",
      "description": "https URL of the cape GLB (static mesh)"
    },
    "character_id": {
      "type": "string",
      "description": "Library id of a rigged character (lib_…)"
    },
    "character_url": {
      "type": "string",
      "description": "https URL of a rigged character GLB"
    }
  }
}
gripforge_cape output schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "bind",
    "files",
    "library",
    "notes"
  ],
  "properties": {
    "bind": {
      "type": "object",
      "description": "cape bind v1 — anchor bone, gf_cape_* grid, stiffness per bone, spring params",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "files": {
      "type": "object",
      "description": "cape-bind.json, cape-godot.gd (spring bones script)",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {
        "type": "string"
      }
    },
    "notes": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "library": {
      "anyOf": [
        {
          "type": "object",
          "propertyNames": {
            "type": "string"
          },
          "additionalProperties": {}
        },
        {
          "type": "null"
        }
      ],
      "description": "Library item of the baked attached_cape.glb (skinned, ready to load)"
    }
  },
  "additionalProperties": false
}
gripforge_cape annotations
{
  "title": "Rig a cape onto a character",
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_hud_bar — Forge a custom health bar style
Advertised by the server during the last successful anonymous check.
Open-world

Forge an ORIGINAL themed health-bar style: an image model draws the ornate empty frame (transparent background), the inner trough is located pixel-precisely, and a thematic gradient fill is composed to match — returns an aligned frame+fill PNG pair, same contract as the built-in gripforge_hud bar styles. Describe a THEME (e.g. "gothic demon-hunter, baroque metal, horn ornaments"), never a specific game — styles of a genre, not copies. 2 credits. RECIPE: download frame_url + fill_url next to your hud.json ; Godot: TextureProgressBar (texture_under=frame, texture_progress=fill, custom_minimum_size=size) ; Unity: frame behind, fill cropped horizontally to the health percent. Generation has model variance — if the trough is not found, retry with a clearer theme.

gripforge_hud_bar input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "theme"
  ],
  "properties": {
    "name": {
      "type": "string",
      "maxLength": 60,
      "description": "Slug for the saved Library items"
    },
    "theme": {
      "type": "string",
      "maxLength": 300,
      "minLength": 3,
      "description": "Visual theme of the frame (genre, materials, ornaments)"
    },
    "colors": {
      "type": "array",
      "items": {
        "type": "string",
        "pattern": "^#[0-9a-fA-F]{6}$"
      },
      "maxItems": 3,
      "minItems": 3,
      "description": "Fill gradient [light, mid, dark] hex — default blood red"
    }
  }
}
gripforge_hud_bar output schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "frame_url",
    "fill_url",
    "size",
    "hud_snippet"
  ],
  "properties": {
    "size": {
      "type": "object",
      "required": [
        "w",
        "h"
      ],
      "properties": {
        "h": {
          "type": "number"
        },
        "w": {
          "type": "number"
        }
      },
      "additionalProperties": false
    },
    "notes": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "fill_url": {
      "type": "string",
      "description": "PNG fill (full-width, engine crops) download URL"
    },
    "frame_url": {
      "type": "string",
      "description": "PNG frame (empty ornate bar) download URL"
    },
    "hud_snippet": {
      "type": "object",
      "description": "Ready-to-paste hud.json health block",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    }
  },
  "additionalProperties": false
}
gripforge_hud_bar annotations
{
  "title": "Forge a custom health bar style",
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_character_concepts — Three character / enemy / boss concept pictures
Advertised by the server during the last successful anonymous check.
Open-world

Three LOOK pictures (3/4, Imagine low 1K) of a named character, enemy or boss BEFORE any 3D. Pass weapon to show it on the looks; 3D later is T-pose empty hands. Pick one, then gripforge_generate_character with concept_item. 1 credit per image (default 3).

gripforge_character_concepts input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "name",
    "prompt"
  ],
  "properties": {
    "n": {
      "type": "number",
      "maximum": 4,
      "minimum": 1,
      "description": "Default 3"
    },
    "kind": {
      "enum": [
        "character",
        "enemy",
        "boss"
      ],
      "type": "string",
      "description": "Default character"
    },
    "name": {
      "type": "string",
      "maxLength": 80,
      "minLength": 2,
      "description": "Creation name, stored on each concept"
    },
    "prompt": {
      "type": "string",
      "maxLength": 2000,
      "minLength": 3,
      "description": "Look, outfit, silhouette"
    },
    "weapon": {
      "type": "string",
      "maxLength": 160,
      "description": "Shown on the looks only; empty hands if omitted"
    }
  }
}
gripforge_character_concepts output schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "kind": {
      "type": "string"
    },
    "name": {
      "type": "string"
    },
    "items": {
      "type": "array",
      "items": {
        "type": "object",
        "propertyNames": {
          "type": "string"
        },
        "additionalProperties": {}
      }
    },
    "recipe": {
      "type": "string"
    },
    "credits": {
      "type": "number"
    }
  },
  "additionalProperties": false
}
gripforge_character_concepts annotations
{
  "title": "Three character / enemy / boss concept pictures",
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_generate — Generate a game asset — one door for every mesh kind
Advertised by the server during the last successful anonymous check.
Open-world

CREATE any mesh asset and save it to Library — the canonical generation door. kind decides the pipeline: character/enemy/boss are auto-rigged (pass concept_item or file_url for image-to-3D; otherwise text-to-3D), weapon and prop are direct text-to-model (no rig, no concept step). The workspace Style DNA is applied to the prompt. If the look may already exist, call gripforge_style_kit FIRST. Costs 10 credits. Returns a persistent job_id immediately; poll gripforge_generation_read for progress and the Library/Studio result. Closing this call does not cancel it.

gripforge_generate input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "prompt",
    "kind"
  ],
  "properties": {
    "rig": {
      "type": "boolean",
      "description": "Characters with provider gpu only: true = rig with Tripo (only when Tripo is configured on the server); omitted = automatic rig on the GPU box (GripForge biped skeleton, meta.rig = tokenrig; the character stays unrigged with a note if it fails); false = no rig (meta.rig = none)."
    },
    "kind": {
      "enum": [
        "character",
        "enemy",
        "boss",
        "weapon",
        "prop"
      ],
      "type": "string",
      "description": "What to forge — rigged (character/enemy/boss) or static mesh (weapon/prop)"
    },
    "name": {
      "type": "string",
      "maxLength": 160,
      "description": "Library item name (default: the prompt)"
    },
    "engine": {
      "enum": [
        "hunyuan",
        "trellis2"
      ],
      "type": "string",
      "description": "GPU engine, only with provider gpu: hunyuan (Hunyuan3D 2.1, shape then paint) or trellis2 (TRELLIS.2). Server default GRIPFORGE_GPU_ENGINE, else hunyuan."
    },
    "prompt": {
      "type": "string",
      "maxLength": 2000,
      "minLength": 3,
      "description": "Description of the asset. Up to 2000 characters: the on-demand GPU (provider gpu) always takes them; another provider refuses a text over its own limit with the error prompt_too_long_for_provider."
    },
    "file_url": {
      "type": "string",
      "description": "https URL of a concept or T-pose image. Image-to-3D."
    },
    "provider": {
      "enum": [
        "tripo",
        "meshy",
        "gpu"
      ],
      "type": "string",
      "description": "Default gpu for character/enemy/boss, with or without an image. Weapons and props use the server default. An explicit provider overrides this choice; tripo with an image uses meshy. gpu = our rented GPU: Hunyuan3D 2.1 (default engine) or TRELLIS.2 image-to-3D, then the game-ready chain (shape gate, normalisation, decimation, normal + AO bake from the high-poly, collider for props/weapons, meta.gameReady verdict); text-only first makes a concept image; no Tripo/Meshy generation spend."
    },
    "polycount": {
      "type": "number",
      "description": "Target triangles."
    },
    "underwear": {
      "type": "boolean",
      "description": "Characters: false = keep the described outfit"
    },
    "concept_item": {
      "type": "string",
      "description": "Library concept / T-pose id (lib_…). Image-to-3D — not text-to-3D."
    },
    "idempotency_key": {
      "type": "string",
      "pattern": "^[a-zA-Z0-9_.:-]{8,160}$",
      "description": "Stable key per asset role. Reuse after an uncertain response to avoid duplicate paid jobs."
    }
  }
}
gripforge_generate output schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "job": {
      "type": "string"
    },
    "item": {
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "notes": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "stage": {
      "type": "string"
    },
    "job_id": {
      "type": "string"
    },
    "status": {
      "type": "string"
    },
    "provider": {
      "type": "string"
    },
    "status_url": {
      "type": "string"
    },
    "studio_url": {
      "type": "string"
    },
    "library_url": {
      "type": "string"
    }
  },
  "additionalProperties": {}
}
gripforge_generate annotations
{
  "title": "Generate a game asset",
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_generate_character — Generate a ready-to-use character
Advertised by the server during the last successful anonymous check.
Open-world

CREATE a Mixamo T-pose auto-rigged character, enemy or boss and save it to Library. NEVER describe a handheld weapon, staff or shield in the prompt: characters and enemies are forged empty-handed (the forge enforces it); make the weapon apart with gripforge_generate (kind=weapon) and put it in the hand with gripforge_attach. polycount is honoured (default 8000; keep it at or under 10000 for a mobile game).To sculpt from a picture (image-to-3D): pass concept_item (lib_… from gripforge_concept_correct / character_concepts) or file_url. Without an image this is text-to-3D. If the look may already be in the locker, call gripforge_style_kit FIRST. For knives/guns use gripforge_generate_weapon. Alias of gripforge_generate (the canonical door). Costs 10 credits. Returns a persistent job_id immediately; poll gripforge_generation_read. Closing this call does not cancel it.

gripforge_generate_character input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "prompt"
  ],
  "properties": {
    "rig": {
      "type": "boolean",
      "description": "Characters with provider gpu only: true = rig with Tripo (only when Tripo is configured on the server); omitted = automatic rig on the GPU box (GripForge biped skeleton, meta.rig = tokenrig; the character stays unrigged with a note if it fails); false = no rig (meta.rig = none)."
    },
    "kind": {
      "enum": [
        "character",
        "enemy",
        "boss"
      ],
      "type": "string",
      "description": "character | enemy | boss (boss → enemy + meta.boss)"
    },
    "name": {
      "type": "string",
      "maxLength": 160,
      "description": "Library item name (default: the prompt)"
    },
    "engine": {
      "enum": [
        "hunyuan",
        "trellis2"
      ],
      "type": "string",
      "description": "GPU engine, only with provider gpu: hunyuan (Hunyuan3D 2.1, shape then paint) or trellis2 (TRELLIS.2). Server default GRIPFORGE_GPU_ENGINE, else hunyuan."
    },
    "prompt": {
      "type": "string",
      "maxLength": 2000,
      "minLength": 3,
      "description": "Description. \"stylish gothic action enemy\" → tagged with that look, kind=enemy. Up to 2000 characters: the on-demand GPU (provider gpu) always takes them; another provider refuses a text over its own limit with the error prompt_too_long_for_provider."
    },
    "file_url": {
      "type": "string",
      "description": "https URL of a concept or T-pose image. Image-to-3D."
    },
    "provider": {
      "enum": [
        "tripo",
        "meshy",
        "gpu"
      ],
      "type": "string",
      "description": "Default gpu, with or without an image. An explicit provider overrides this choice; tripo with concept_item / file_url uses meshy. gpu = our rented GPU: Hunyuan3D 2.1 (default engine) or TRELLIS.2 image-to-3D, then the game-ready chain (shape gate, normalisation, decimation, normal + AO bake from the high-poly, meta.gameReady verdict); text-only first makes a concept image; no Tripo/Meshy generation spend."
    },
    "polycount": {
      "type": "number",
      "description": "Target triangles. Meshy characters default 8000 (low-poly FPS)."
    },
    "underwear": {
      "type": "boolean",
      "description": "false = keep the described outfit. Implied false when an image is passed."
    },
    "concept_item": {
      "type": "string",
      "description": "Library concept / T-pose sheet id (lib_…). Image-to-3D from that picture — not text-to-3D."
    },
    "idempotency_key": {
      "type": "string",
      "pattern": "^[a-zA-Z0-9_.:-]{8,160}$",
      "description": "Stable key per asset role. Reuse after an uncertain response to avoid duplicate paid jobs."
    }
  }
}
gripforge_generate_character output schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "job": {
      "type": "string"
    },
    "item": {
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "notes": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "stage": {
      "type": "string"
    },
    "job_id": {
      "type": "string"
    },
    "status": {
      "type": "string"
    },
    "provider": {
      "type": "string"
    },
    "status_url": {
      "type": "string"
    },
    "studio_url": {
      "type": "string"
    },
    "library_url": {
      "type": "string"
    }
  },
  "additionalProperties": {}
}
gripforge_generate_character annotations
{
  "title": "Generate a ready-to-use character",
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_generate_weapon — Generate a weapon (Meshy)
Advertised by the server during the last successful anonymous check.
Open-world

CREATE a game-ready weapon GLB (knife, gun, sword…) and save it to Library as kind=weapon. Default provider Meshy, no T-pose, no biped rig. polycount defaults to 4000. style=melee|gun is written to meta.style for gripforge_attach. 10 credits. Returns a persistent job_id; poll gripforge_generation_read. Do NOT write one-off Meshy scripts.

gripforge_generate_weapon input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "prompt"
  ],
  "properties": {
    "name": {
      "type": "string",
      "maxLength": 160,
      "description": "Library name (default: prompt)"
    },
    "style": {
      "enum": [
        "melee",
        "gun",
        "shield",
        "staff"
      ],
      "type": "string",
      "description": "Grip style for attach (inferred if omitted)"
    },
    "engine": {
      "enum": [
        "hunyuan",
        "trellis2"
      ],
      "type": "string",
      "description": "GPU engine, only with provider gpu: hunyuan (Hunyuan3D 2.1, shape then paint) or trellis2 (TRELLIS.2). Server default GRIPFORGE_GPU_ENGINE, else hunyuan."
    },
    "prompt": {
      "type": "string",
      "maxLength": 2000,
      "minLength": 3,
      "description": "e.g. \"tactical combat knife, silver blade, black grip\". Up to 2000 characters: the on-demand GPU (provider gpu) always takes them; another provider refuses a text over its own limit with the error prompt_too_long_for_provider."
    },
    "provider": {
      "enum": [
        "meshy",
        "tripo",
        "gpu"
      ],
      "type": "string",
      "description": "Default meshy (or the server default). gpu = our rented GPU: Hunyuan3D 2.1 (default engine) or TRELLIS.2 image-to-3D, then the game-ready chain (shape gate, normalisation, decimation, normal + AO bake from the high-poly, collider for props/weapons, meta.gameReady verdict); text-only first makes a concept image; no Tripo/Meshy spend. The server default can be gpu (GRIPFORGE_FORGE_DEFAULT=gpu|meshy)."
    },
    "polycount": {
      "type": "number",
      "description": "Target triangles (default 4000)"
    },
    "idempotency_key": {
      "type": "string",
      "pattern": "^[a-zA-Z0-9_.:-]{8,160}$",
      "description": "Stable key per asset role. Reuse after an uncertain response to avoid duplicate paid jobs."
    }
  }
}
gripforge_generate_weapon output schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "job": {
      "type": "string"
    },
    "item": {
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "notes": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "stage": {
      "type": "string"
    },
    "job_id": {
      "type": "string"
    },
    "status": {
      "type": "string"
    },
    "provider": {
      "type": "string"
    },
    "status_url": {
      "type": "string"
    },
    "studio_url": {
      "type": "string"
    },
    "library_url": {
      "type": "string"
    }
  },
  "additionalProperties": {}
}
gripforge_generate_weapon annotations
{
  "title": "Generate a weapon (Meshy)",
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_generate_prop — Generate a prop (Meshy)
Advertised by the server during the last successful anonymous check.
Open-world

CREATE a game-ready prop GLB (kart, crate, barrel, banana…) and save it to Library as kind=prop. Default Meshy, no T-pose, no biped rig. polycount defaults to 4000. Quoted against the shared subscription, or 10 GripForge credits if it cannot cover the complete operation. Returns a persistent job_id immediately; poll gripforge_generation_read, then download and import the completed model. provider=compute (GripForge Compute, only when asked): stage=quote (free) then stage=generate with quote_token + confirm=true; router type, size, several assets (items), text → four images to validate (gripforge_compute_validate) unless auto_pick; returns studio_url.

gripforge_generate_prop input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "name": {
      "type": "string",
      "maxLength": 160,
      "description": "Library name"
    },
    "type": {
      "enum": [
        "objet",
        "meuble",
        "batiment",
        "vegetation",
        "vehicule",
        "personnage",
        "mob",
        "creature"
      ],
      "type": "string",
      "description": "provider compute: router asset type (gripforge_compute_status lists those available now). personnage / mob / creature: the mesh only; rig it afterwards in the Character studio. Weapons are refused"
    },
    "items": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "name"
        ],
        "properties": {
          "name": {
            "type": "string",
            "maxLength": 100,
            "minLength": 1
          },
          "prompt": {
            "type": "string",
            "maxLength": 500,
            "minLength": 3
          },
          "concept_item": {
            "type": "string",
            "maxLength": 160,
            "minLength": 1
          },
          "image_base64": {
            "type": "string",
            "maxLength": 12000000
          }
        }
      },
      "maxItems": 5,
      "minItems": 1,
      "description": "provider compute: several assets at once, [{name, prompt} or {name, image_base64|concept_item}], one quote and one job each"
    },
    "stage": {
      "enum": [
        "quote",
        "generate"
      ],
      "type": "string",
      "description": "provider compute: quote first (free, returns quote.token and the price), then generate with quote_token and confirm=true. Without stage, provider compute quotes and launches in one call (a text takes its first image)."
    },
    "engine": {
      "enum": [
        "hunyuan",
        "trellis2"
      ],
      "type": "string",
      "description": "GPU engine, only with provider gpu: hunyuan (Hunyuan3D 2.1, shape then paint) or trellis2 (TRELLIS.2). Server default GRIPFORGE_GPU_ENGINE, else hunyuan."
    },
    "prompt": {
      "type": "string",
      "maxLength": 2000,
      "minLength": 3,
      "description": "Required, except provider compute with an image or items. e.g. compact orange open-cockpit racing kart, isolated. Up to 2000 characters: the on-demand GPU (provider gpu) always takes them; another provider refuses a text over its own limit with the error prompt_too_long_for_provider."
    },
    "source": {
      "enum": [
        "image",
        "text"
      ],
      "type": "string",
      "description": "provider compute, single asset: default text when only prompt is given, image with image_base64 / concept_item"
    },
    "confirm": {
      "type": "boolean",
      "description": "provider compute, stage=generate: true once the user accepted the quoted price"
    },
    "options": {
      "type": "array",
      "items": {
        "enum": [
          "photo",
          "matieres",
          "relief",
          "visage",
          "visage_cheveux",
          "peau_humaine",
          "raffinage"
        ],
        "type": "string"
      },
      "maxItems": 7,
      "description": "provider compute: photo, matieres, relief; optional raffinage (slower), peau_humaine, visage, visage_cheveux. Face/hair require description and type personnage or mob; prerequisites are included in the quote."
    },
    "quality": {
      "enum": [
        "standard",
        "detail"
      ],
      "type": "string",
      "description": "provider compute: texture quality, default standard"
    },
    "subtype": {
      "enum": [
        "vehicle",
        "none"
      ],
      "type": "string",
      "description": "vehicle: made as the Vehicles prop sub-kind — no grip style, nose on +Z, the four wheels split with hub pivots so it drives. Then finished like a game car: paint, glass, chrome, grille and lamp materials, smoothed body, modelled wheels. Detected from the prompt (car, truck, van, kart…) when omitted; none opts out."
    },
    "optimize": {
      "type": "boolean",
      "description": "Default true; false retains the provider mesh for close-up review."
    },
    "provider": {
      "enum": [
        "meshy",
        "tripo",
        "gpu",
        "compute"
      ],
      "type": "string",
      "description": "Default meshy (or the server default). gpu = our rented GPU: Hunyuan3D 2.1 (default engine) or TRELLIS.2 image-to-3D, then the game-ready chain (shape gate, normalisation, decimation, normal + AO bake from the high-poly, collider for props/weapons, meta.gameReady verdict); text-only first makes a concept image; no Tripo/Meshy spend. The server default can be gpu (GRIPFORGE_FORGE_DEFAULT=gpu|meshy). compute = GripForge Compute, ONLY when the user asks for it: textured asset from text, one image (concept_item, image_base64) or several (items), two GLBs (scene, detail), quoted and charged like the other providers; type picks the router asset type (furniture, building, vegetation, vehicle, character…); weapons are refused; refused while Compute is closed. Without provider the default generator is used."
    },
    "auto_pick": {
      "type": "boolean",
      "description": "provider compute, text: true = take the first of the four images without asking (only when the user wants it). Default with stage: stop on the images; show them (gripforge_generation_read images[]) and validate one with gripforge_compute_validate"
    },
    "polycount": {
      "type": "number",
      "description": "Target triangles (default 4000)"
    },
    "triangles": {
      "type": "integer",
      "maximum": 200000,
      "minimum": 500,
      "description": "provider compute, image assets: exact triangle count of the « near » GLB (the « scene » one gets half)"
    },
    "description": {
      "type": "string",
      "maxLength": 500,
      "description": "provider compute, face/hair: character appearance in English (age, facial features, hair), required to preserve identity"
    },
    "meshQuality": {
      "type": "object",
      "required": [
        "geometry",
        "texture"
      ],
      "properties": {
        "texture": {
          "enum": [
            "2k",
            "4k",
            "8k"
          ],
          "type": "string"
        },
        "geometry": {
          "enum": [
            "standard",
            "2k",
            "4k"
          ],
          "type": "string"
        }
      },
      "description": "Meshy geometry and PBR texture quality. Requested texture resolution is retained through optimization."
    },
    "object_type": {
      "type": "string",
      "pattern": "^[a-z_]{2,40}$",
      "description": "provider compute: size (budget) of the type, e.g. petit_objet, mobilier_simple; default: the type's default"
    },
    "quote_token": {
      "type": "string",
      "maxLength": 64,
      "minLength": 64,
      "description": "provider compute, stage=generate: quote.token of the quote with the SAME inputs"
    },
    "concept_item": {
      "type": "string",
      "maxLength": 160,
      "minLength": 1,
      "description": "Owned concept image in this workspace (image-to-3D): Meshy by default, or our GPU with provider gpu (Hunyuan or TRELLIS.2 from this exact image)."
    },
    "image_base64": {
      "type": "string",
      "maxLength": 12000000,
      "description": "provider compute, source=image: PNG/JPEG/WebP, raw base64 or data URI, up to 8 MB"
    },
    "quote_tokens": {
      "type": "array",
      "items": {
        "type": "string",
        "maxLength": 64,
        "minLength": 64
      },
      "maxItems": 5,
      "description": "provider compute, stage=generate with items: the quote tokens in item order"
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Explicit workspace id. The key must have access to it."
    },
    "concept_items": {
      "type": "array",
      "items": {
        "type": "string",
        "maxLength": 160,
        "minLength": 1
      },
      "maxItems": 4,
      "minItems": 2,
      "description": "2–4 distinct owned views of the same prop for Meshy multi-image-to-3D (exclusive with concept_item; geometry standard/2k). With provider gpu + engine trellis2: exactly 4 level views in the order front, left, back, right — Pixal3D builds the shape from all four."
    },
    "idempotency_key": {
      "type": "string",
      "pattern": "^[a-zA-Z0-9_.:-]{8,160}$",
      "description": "Stable key per asset role. Reuse after an uncertain response to avoid duplicate paid jobs."
    }
  }
}
gripforge_generate_prop annotations
{
  "title": "Generate a prop (Meshy)",
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_boss — Boss kit (stats + phases + optional mesh)
Advertised by the server during the last successful anonymous check.
Open-world

Create a playable boss for a game look: stats, phases, attacks bound to anim-pack slots, arena, and Godot / Unity / Unreal snippets. Kit is 0 credits. Reuses a locker enemy when one exists. Pass character_id to bind a Library mesh. Pass generate=true to forge a NEW kind=enemy boss mesh (10 credits, 2–8 min) — only if style_kit / locker is empty. Then gripforge_animate(archetype) + gripforge_hitbox. Name stays text.

gripforge_boss input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "prompt"
  ],
  "properties": {
    "name": {
      "type": "string",
      "maxLength": 80,
      "description": "Boss display name"
    },
    "role": {
      "enum": [
        "mini",
        "mid",
        "final"
      ],
      "type": "string",
      "description": "mini | mid | final (inferred from the prompt)"
    },
    "prompt": {
      "type": "string",
      "maxLength": 240,
      "minLength": 2,
      "description": "e.g. \"gothic action phantom boss\""
    },
    "generate": {
      "type": "boolean",
      "description": "Forge a new enemy mesh (10 credits). Skip if locker already has one."
    },
    "provider": {
      "enum": [
        "tripo",
        "meshy"
      ],
      "type": "string",
      "description": "Only used when generate=true (default tripo)"
    },
    "character_id": {
      "type": "string",
      "description": "lib_… character/enemy/bind to bind — 0 credits"
    }
  }
}
gripforge_boss annotations
{
  "title": "Boss kit",
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_concept_correct — Correct a character concept
Advertised by the server during the last successful anonymous check.
Open-world

Turn a character concept image into a strict T-pose sheet (optional: remove flowing cape/train only — sleeved jacket stays; outfit or sport base). Saves PNG to Library. 1 credit. Hosted MCP takes https file_url.

gripforge_concept_correct input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "file_url"
  ],
  "properties": {
    "cape": {
      "type": "boolean",
      "description": "Remove flowing cape/train only; keep sleeved jacket (outfit only, default true)"
    },
    "name": {
      "type": "string",
      "description": "Library name"
    },
    "notes": {
      "type": "string",
      "description": "Extra direction"
    },
    "clothes": {
      "enum": [
        "outfit",
        "base"
      ],
      "type": "string",
      "description": "outfit = keep clothes; base = grey athletic sportswear"
    },
    "file_url": {
      "type": "string",
      "description": "https URL of the concept image"
    }
  }
}
gripforge_concept_correct annotations
{
  "title": "Correct a character concept",
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_formats — Supported formats
Advertised by the server during the last successful anonymous check.
Advertised read-only

List the mesh formats and grip styles GripForge supports.

gripforge_formats input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {}
}
gripforge_formats output schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "formats",
    "styles",
    "docs"
  ],
  "properties": {
    "mcp": {
      "type": "object",
      "required": [
        "client",
        "latest",
        "outdated",
        "npm",
        "hosted"
      ],
      "properties": {
        "npm": {
          "type": "string"
        },
        "client": {
          "type": "string"
        },
        "hosted": {
          "type": "string"
        },
        "latest": {
          "type": "string"
        },
        "outdated": {
          "type": "boolean"
        }
      },
      "additionalProperties": false
    },
    "docs": {
      "type": "string",
      "description": "Documentation URL"
    },
    "styles": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Supported grip styles"
    },
    "formats": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Supported mesh file formats"
    }
  },
  "additionalProperties": false
}
gripforge_formats annotations
{
  "title": "Supported formats",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_make_seamless — Make a texture tileable
Advertised by the server during the last successful anonymous check.
Open-world

Turn an image into a seamless (tileable) texture: 50% wrap offset, then the seams are cross-faded in a narrow band — the pattern is PRESERVED, nothing is generated or invented. Pass image_url (https) or texture_id (Library id, lib_…). Optional size forces a power of two (512/1024/2048), resampled before the seam fix. The result is saved in your Library as a texture and its download URL is returned. No credit consumed.

gripforge_make_seamless input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "band": {
      "type": "number",
      "maximum": 0.25,
      "minimum": 0.02,
      "description": "Blend band as a fraction of the side (default 0.08)"
    },
    "name": {
      "type": "string",
      "description": "Name for the Library item (default <source>_seamless)"
    },
    "size": {
      "type": "number",
      "description": "Force a power-of-two side: 512, 1024, 2048…"
    },
    "image_url": {
      "type": "string",
      "description": "https URL of the image (PNG/JPG)"
    },
    "texture_id": {
      "type": "string",
      "description": "Library id of a texture (lib_…)"
    }
  }
}
gripforge_make_seamless output schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "width": {
      "type": "number"
    },
    "height": {
      "type": "number"
    },
    "file_url": {
      "type": "string",
      "description": "Download URL of the seamless PNG"
    },
    "library_id": {
      "type": "string",
      "description": "Library id of the seamless texture"
    }
  },
  "additionalProperties": false
}
gripforge_make_seamless annotations
{
  "title": "Make a texture tileable",
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
getAttachmentFrame — Skeleton attachment frame
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Return the skeleton frame for a limb. Outward = R_Thigh−L_Thigh (never ask the LLM). Up = Knee→Hip / Ankle→Knee. Match getWearableFrame axes — no Euler.

getAttachmentFrame input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "character_url",
    "bodyPart"
  ],
  "properties": {
    "bodyPart": {
      "enum": [
        "right_thigh",
        "left_thigh",
        "right_shin",
        "left_shin"
      ],
      "type": "string",
      "description": "Limb to seat"
    },
    "character_url": {
      "type": "string",
      "description": "URL of the rigged character"
    }
  }
}
getAttachmentFrame annotations
{
  "title": "Skeleton attachment frame",
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
getWearableFrame — Wearable asset frame
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Analyze an armor asset once: up, bodyFacing, outward, anchor. Never returns rotate X = 180°.

getWearableFrame input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "asset_url"
  ],
  "properties": {
    "side": {
      "enum": [
        "left",
        "right"
      ],
      "type": "string"
    },
    "type": {
      "enum": [
        "thigh",
        "greave"
      ],
      "type": "string"
    },
    "asset_url": {
      "type": "string",
      "description": "URL of the armor piece"
    }
  }
}
getWearableFrame annotations
{
  "title": "Wearable asset frame",
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_texture_prep — Prep a game texture
Advertised by the server during the last successful anonymous check.
Open-world

Prep a game texture (terrain / props): optional 50% wrap + seam blend, then a faithful lanczos upscale (1× / 2× / 4×, capped at 1024 or 2048). The pattern is PRESERVED — nothing is generated (not Magnific, not an image model). Pass texture_id (Library) or image_url (https). Result is saved as kind=texture and the albedo URL is returned. To write the PNG into an open repo, use the npm package with out_dir. No credit consumed.

gripforge_texture_prep input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "name": {
      "type": "string",
      "description": "Library name (default <source>_tile)"
    },
    "save": {
      "type": "boolean",
      "description": "Save to Library (default true on hosted MCP)"
    },
    "size": {
      "anyOf": [
        {
          "type": "number",
          "const": 1024
        },
        {
          "type": "number",
          "const": 2048
        }
      ],
      "description": "Max output side (default 1024)"
    },
    "scale": {
      "anyOf": [
        {
          "type": "number",
          "const": 1
        },
        {
          "type": "number",
          "const": 2
        },
        {
          "type": "number",
          "const": 4
        }
      ],
      "description": "Upscale factor (default 1)"
    },
    "seamless": {
      "type": "boolean",
      "description": "50% offset + seam blend (default true)"
    },
    "image_url": {
      "type": "string",
      "description": "https URL of the image (PNG/JPG/WebP)"
    },
    "texture_id": {
      "type": "string",
      "description": "Library id of a texture (lib_…)"
    }
  }
}
gripforge_texture_prep output schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "id": {
      "type": "string"
    },
    "width": {
      "type": "number"
    },
    "height": {
      "type": "number"
    },
    "file_url": {
      "type": "string",
      "description": "Albedo PNG URL"
    },
    "library_id": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ]
    }
  },
  "additionalProperties": false
}
gripforge_texture_prep annotations
{
  "title": "Prep a game texture",
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_style_kit — Game-style kit from Library
Advertised by the server during the last successful anonymous check.
Advertised read-only

Resolve a game look the user names ("stylish gothic action", "anime open-world adventure") to a game-style id, then return the locker kit already tagged with that look: characters, enemies, weapons, props. Call this BEFORE generating when the user wants that game. Reuse the returned Library ids (attach / pull). Only generate if a bucket is empty.

gripforge_style_kit input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "prompt"
  ],
  "properties": {
    "prompt": {
      "type": "string",
      "maxLength": 240,
      "minLength": 2,
      "description": "e.g. \"stylish gothic action\", \"un ennemi d'aventure anime\", \"souls-like\""
    }
  }
}
gripforge_style_kit annotations
{
  "title": "Game-style kit from Library",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_library_list — List Library
Advertised by the server during the last successful anonymous check.
Advertised read-only

List items in the GripForge Library locker (characters, enemies, weapons, props, textures, HUD, binds, vfx). Filter by kind and/or game style id (e.g. souls-like, open-world-adventure). Every item carries `rank` {score/100, grade A–D, reasons}: fitness for a GripForge game on the target platform. sort=rank lists the best fit first — use it to choose between candidates. engine filters on the generator: engine=compute lists GripForge Compute assets (manufactures and variants), each with a `compute` block {level scene/detail, family, triangles, edit_url, file_url}. Same origin as Studio — not a marketplace.

gripforge_library_list input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "q": {
      "type": "string",
      "description": "Search name/filename/description/tags"
    },
    "kind": {
      "enum": [
        "character",
        "fps-arms",
        "enemy",
        "creatures",
        "weapon",
        "equipment",
        "prop",
        "texture",
        "skybox",
        "loading",
        "hud",
        "button",
        "bind",
        "vfx",
        "animation",
        "audio",
        "kit",
        "asset-kit"
      ],
      "type": "string",
      "description": "Filter by kind"
    },
    "sort": {
      "enum": [
        "newest",
        "rank"
      ],
      "type": "string",
      "description": "newest (default) or rank: best fit for a GripForge game first"
    },
    "limit": {
      "type": "integer",
      "maximum": 500,
      "minimum": 1,
      "description": "Page size (default 200)"
    },
    "style": {
      "type": "string",
      "description": "Game look id or alias (e.g. souls-like, open-world-adventure)"
    },
    "engine": {
      "type": "string",
      "pattern": "^[a-z0-9_-]{2,40}$",
      "description": "Generator that made the item: compute (GripForge Compute), meshy, tripo, gpu…"
    },
    "target": {
      "enum": [
        "mobile",
        "desktop"
      ],
      "type": "string",
      "description": "Platform for the rank budgets (triangles, file size). Defaults to mobile."
    },
    "subtype": {
      "type": "string",
      "description": "Subtype within the selected kind, e.g. quadruped under creatures."
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Explicit workspace id. The key must have access to it."
    }
  }
}
gripforge_library_list annotations
{
  "title": "List Library",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_library_optimize — Derive a lighter version
Advertised by the server during the last successful anonymous check.

Derive a lighter version of a static model (prop, weapon, equipment, vehicle) for a target: decimated to `triangles`, textures bounded to `texture` px, saved as a NEW Library item linked to its master (meta.lod_of). The master is never changed — generate high once, derive mobile/desktop versions. Wheel pivots and nodes are kept. 0 credits.

gripforge_library_optimize input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "id",
    "triangles"
  ],
  "properties": {
    "id": {
      "type": "string",
      "description": "Library id of the master model (lib_…)"
    },
    "name": {
      "type": "string",
      "maxLength": 160
    },
    "error": {
      "type": "number",
      "maximum": 0.2,
      "minimum": 0.001,
      "description": "Largest decimation error relative to the model size (default 0.005); far levels of detail use 0.02–0.08 to reach low counts"
    },
    "texture": {
      "anyOf": [
        {
          "type": "number",
          "const": 512
        },
        {
          "type": "number",
          "const": 1024
        },
        {
          "type": "number",
          "const": 2048
        },
        {
          "type": "number",
          "const": 4096
        }
      ],
      "description": "Max texture size in px (default 2048)"
    },
    "triangles": {
      "type": "integer",
      "maximum": 200000,
      "minimum": 500,
      "description": "Target triangles, e.g. 12000 for a mobile car, 40000 desktop"
    }
  }
}
gripforge_library_optimize annotations
{
  "title": "Derive a lighter version",
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_vehicle_finish — Finish a vehicle
Advertised by the server during the last successful anonymous check.

Repair generated automotive surfaces. Preferred: source (immutable static GLB with Body/Wheel_* groups) + repair recipe queues a persistent Blender job; guided glazing/panel regions, paint cleanup, coloured caliper extraction, measured replacement panels/curves with PBR and fitted boundaries, optional rebuilt wheels and rigid wheel rig. features.marks adds surface-fitted pinned PNG logos, relief badges and mesh lettering; wheel markings follow their wheel, named authored marks are replaced in the new work copy. For grilles or trim on a reconstructed recess, set curves.fitSurface.panel to its non-structural panel name to follow the final part. Returns a NEW private work version with GLB/Blend/optional FBX and GripForge review link. Does not promote or overwrite the source. Regions use +Y up/+Z forward metres, bounded displacement; region-only glass stays opaque, authored transmissive panes need an authored cabin. Poll/cancel/retry generation-jobs. 0 provider credits. Legacy id without repair uses one-time material/wheel finish and rewrites its Library file.

gripforge_vehicle_finish input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "id": {
      "type": "string",
      "description": "Library id; with repair pins source, without repair uses legacy finish"
    },
    "name": {
      "type": "string"
    },
    "repair": {
      "type": "object",
      "required": [
        "regions"
      ],
      "properties": {
        "rig": {
          "type": "object",
          "required": [
            "wheelRadius",
            "wheelWidth"
          ],
          "properties": {
            "wheelWidth": {
              "type": "number"
            },
            "wheelRadius": {
              "type": "number"
            }
          }
        },
        "denoise": {
          "type": "object",
          "properties": {
            "iterations": {
              "type": "integer",
              "maximum": 80,
              "minimum": 1
            },
            "maxOffsetM": {
              "type": "number",
              "maximum": 0.05,
              "minimum": 0
            },
            "normalIterations": {
              "type": "integer",
              "maximum": 30,
              "minimum": 0
            }
          },
          "description": "Bounded Body smoothing across UV seams; pins open boundaries, retains UVs and wheel/caliper transforms; review small details"
        },
        "regions": {
          "type": "array",
          "items": {
            "type": "object",
            "required": [
              "name",
              "bounds",
              "select",
              "surface",
              "fitAxis"
            ],
            "properties": {
              "name": {
                "type": "string"
              },
              "bounds": {
                "type": "array",
                "prefixItems": [
                  {
                    "type": "array",
                    "prefixItems": [
                      {
                        "type": "number"
                      },
                      {
                        "type": "number"
                      },
                      {
                        "type": "number"
                      }
                    ]
                  },
                  {
                    "type": "array",
                    "prefixItems": [
                      {
                        "type": "number"
                      },
                      {
                        "type": "number"
                      },
                      {
                        "type": "number"
                      }
                    ]
                  }
                ]
              },
              "select": {
                "enum": [
                  "neutral",
                  "paint",
                  "all"
                ],
                "type": "string"
              },
              "fitAxis": {
                "enum": [
                  "x",
                  "y",
                  "z"
                ],
                "type": "string"
              },
              "surface": {
                "enum": [
                  "glass",
                  "paint"
                ],
                "type": "string"
              },
              "maxOffsetM": {
                "type": "number",
                "maximum": 0.05,
                "minimum": 0
              }
            }
          },
          "maxItems": 16
        },
        "calipers": {
          "type": "object",
          "required": [
            "color"
          ],
          "properties": {
            "color": {
              "type": "array",
              "prefixItems": [
                {
                  "type": "number"
                },
                {
                  "type": "number"
                },
                {
                  "type": "number"
                }
              ]
            },
            "tolerance": {
              "type": "number",
              "maximum": 0.4,
              "minimum": 0.05
            }
          }
        },
        "features": {
          "type": "object",
          "properties": {
            "marks": {
              "type": "array",
              "items": {
                "type": "object",
                "required": [
                  "name",
                  "kind",
                  "position",
                  "normal",
                  "up",
                  "widthM",
                  "heightM"
                ],
                "properties": {
                  "up": {
                    "type": "array",
                    "prefixItems": [
                      {
                        "type": "number"
                      },
                      {
                        "type": "number"
                      },
                      {
                        "type": "number"
                      }
                    ]
                  },
                  "kind": {
                    "enum": [
                      "decal",
                      "badge",
                      "text"
                    ],
                    "type": "string"
                  },
                  "name": {
                    "type": "string",
                    "maxLength": 80,
                    "minLength": 1
                  },
                  "text": {
                    "type": "string",
                    "maxLength": 48,
                    "minLength": 1
                  },
                  "depthM": {
                    "type": "number",
                    "maximum": 0.01,
                    "minimum": 0
                  },
                  "normal": {
                    "type": "array",
                    "prefixItems": [
                      {
                        "type": "number"
                      },
                      {
                        "type": "number"
                      },
                      {
                        "type": "number"
                      }
                    ]
                  },
                  "target": {
                    "enum": [
                      "Body",
                      "Wheel_FL",
                      "Wheel_FR",
                      "Wheel_RL",
                      "Wheel_RR"
                    ],
                    "type": "string"
                  },
                  "widthM": {
                    "type": "number",
                    "maximum": 0.8,
                    "minimum": 0.005
                  },
                  "artwork": {
                    "type": "object",
                    "required": [
                      "assetId",
                      "revisionId"
                    ],
                    "properties": {
                      "assetId": {
                        "type": "string"
                      },
                      "fileRole": {
                        "type": "string"
                      },
                      "revisionId": {
                        "type": "string"
                      }
                    }
                  },
                  "heightM": {
                    "type": "number",
                    "maximum": 0.8,
                    "minimum": 0.005
                  },
                  "mirrorX": {
                    "type": "boolean"
                  },
                  "offsetM": {
                    "type": "number",
                    "maximum": 0.01,
                    "minimum": 0.0002
                  },
                  "outline": {
                    "type": "array",
                    "items": {
                      "type": "array",
                      "prefixItems": [
                        {
                          "type": "number",
                          "maximum": 0.5,
                          "minimum": -0.5
                        },
                        {
                          "type": "number",
                          "maximum": 0.5,
                          "minimum": -0.5
                        }
                      ]
                    },
                    "maxItems": 64,
                    "minItems": 3
                  },
                  "material": {
                    "type": "object",
                    "properties": {
                      "ior": {
                        "type": "number",
                        "maximum": 2.5,
                        "minimum": 1
                      },
                      "coat": {
                        "type": "number",
                        "maximum": 1,
                        "minimum": 0
                      },
                      "color": {
                        "type": "array",
                        "prefixItems": [
                          {
                            "type": "number"
                          },
                          {
                            "type": "number"
                          },
                          {
                            "type": "number"
                          }
                        ]
                      },
                      "emission": {
                        "type": "number",
                        "maximum": 10,
                        "minimum": 0
                      },
                      "metallic": {
                        "type": "number",
                        "maximum": 1,
                        "minimum": 0
                      },
                      "roughness": {
                        "type": "number",
                        "maximum": 1,
                        "minimum": 0.02
                      },
                      "transmission": {
                        "type": "number",
                        "maximum": 1,
                        "minimum": 0
                      }
                    }
                  },
                  "position": {
                    "type": "array",
                    "prefixItems": [
                      {
                        "type": "number"
                      },
                      {
                        "type": "number"
                      },
                      {
                        "type": "number"
                      }
                    ]
                  },
                  "receiver": {
                    "type": "string",
                    "maxLength": 120,
                    "minLength": 1
                  },
                  "segments": {
                    "type": "integer",
                    "maximum": 32,
                    "minimum": 4
                  },
                  "maxDistanceM": {
                    "type": "number",
                    "maximum": 0.12,
                    "minimum": 0.001
                  }
                }
              },
              "maxItems": 32,
              "description": "Surface-fitted logos and relief: decals require pinned PNG artwork; badges add thickness and a convex outline; text makes mesh lettering. Explicit normal/up frame; target wheel marks spin with that wheel. Optional receiver scopes fitting to a mesh in the target. PNGs <=1 MiB/2048px, max 16 distinct sources. No URLs or local paths."
            },
            "curves": {
              "type": "array",
              "items": {
                "type": "object",
                "required": [
                  "name",
                  "points"
                ],
                "properties": {
                  "name": {
                    "type": "string"
                  },
                  "closed": {
                    "type": "boolean"
                  },
                  "points": {
                    "type": "array",
                    "items": {
                      "type": "array",
                      "prefixItems": [
                        {
                          "type": "number"
                        },
                        {
                          "type": "number"
                        },
                        {
                          "type": "number"
                        }
                      ]
                    },
                    "maxItems": 128,
                    "minItems": 2
                  },
                  "mirrorX": {
                    "type": "boolean"
                  },
                  "radiusM": {
                    "type": "number",
                    "maximum": 0.08,
                    "minimum": 0.0005
                  },
                  "material": {
                    "type": "object",
                    "properties": {
                      "ior": {
                        "type": "number",
                        "maximum": 2.5,
                        "minimum": 1
                      },
                      "coat": {
                        "type": "number",
                        "maximum": 1,
                        "minimum": 0
                      },
                      "color": {
                        "type": "array",
                        "prefixItems": [
                          {
                            "type": "number"
                          },
                          {
                            "type": "number"
                          },
                          {
                            "type": "number"
                          }
                        ]
                      },
                      "emission": {
                        "type": "number",
                        "maximum": 10,
                        "minimum": 0
                      },
                      "metallic": {
                        "type": "number",
                        "maximum": 1,
                        "minimum": 0
                      },
                      "roughness": {
                        "type": "number",
                        "maximum": 1,
                        "minimum": 0.02
                      },
                      "transmission": {
                        "type": "number",
                        "maximum": 1,
                        "minimum": 0
                      }
                    }
                  },
                  "fitSurface": {
                    "type": "object",
                    "required": [
                      "axis"
                    ],
                    "properties": {
                      "axis": {
                        "enum": [
                          "x",
                          "y",
                          "z"
                        ],
                        "type": "string"
                      },
                      "panel": {
                        "type": "string",
                        "maxLength": 80,
                        "minLength": 1
                      },
                      "offsetM": {
                        "type": "number",
                        "maximum": 0.01,
                        "minimum": 0
                      },
                      "direction": {
                        "anyOf": [
                          {
                            "type": "number",
                            "const": 1
                          },
                          {
                            "type": "number",
                            "const": -1
                          }
                        ]
                      }
                    }
                  }
                }
              },
              "maxItems": 256
            },
            "panels": {
              "type": "array",
              "items": {
                "type": "object",
                "required": [
                  "name",
                  "points"
                ],
                "properties": {
                  "name": {
                    "type": "string"
                  },
                  "normal": {
                    "type": "array",
                    "prefixItems": [
                      {
                        "type": "number"
                      },
                      {
                        "type": "number"
                      },
                      {
                        "type": "number"
                      }
                    ]
                  },
                  "points": {
                    "type": "array",
                    "items": {
                      "type": "array",
                      "items": {
                        "type": "array",
                        "prefixItems": [
                          {
                            "type": "number"
                          },
                          {
                            "type": "number"
                          },
                          {
                            "type": "number"
                          }
                        ]
                      },
                      "maxItems": 12,
                      "minItems": 2
                    },
                    "maxItems": 12,
                    "minItems": 2
                  },
                  "mirrorX": {
                    "type": "boolean"
                  },
                  "replace": {
                    "type": "object",
                    "required": [
                      "axis"
                    ],
                    "properties": {
                      "axis": {
                        "enum": [
                          "x",
                          "y",
                          "z"
                        ],
                        "type": "string"
                      },
                      "depthM": {
                        "type": "number",
                        "maximum": 0.5,
                        "minimum": 0.001
                      }
                    }
                  },
                  "material": {
                    "type": "object",
                    "properties": {
                      "ior": {
                        "type": "number",
                        "maximum": 2.5,
                        "minimum": 1
                      },
                      "coat": {
                        "type": "number",
                        "maximum": 1,
                        "minimum": 0
                      },
                      "color": {
                        "type": "array",
                        "prefixItems": [
                          {
                            "type": "number"
                          },
                          {
                            "type": "number"
                          },
                          {
                            "type": "number"
                          }
                        ]
                      },
                      "emission": {
                        "type": "number",
                        "maximum": 10,
                        "minimum": 0
                      },
                      "metallic": {
                        "type": "number",
                        "maximum": 1,
                        "minimum": 0
                      },
                      "roughness": {
                        "type": "number",
                        "maximum": 1,
                        "minimum": 0.02
                      },
                      "transmission": {
                        "type": "number",
                        "maximum": 1,
                        "minimum": 0
                      }
                    }
                  },
                  "segmentsU": {
                    "type": "integer",
                    "maximum": 96,
                    "minimum": 4
                  },
                  "segmentsV": {
                    "type": "integer",
                    "maximum": 96,
                    "minimum": 4
                  },
                  "structural": {
                    "type": "boolean",
                    "description": "New coachwork shell, required with replaceBody; cannot fit or clip the discarded source."
                  },
                  "fitBoundary": {
                    "type": "object",
                    "required": [
                      "axis"
                    ],
                    "properties": {
                      "axis": {
                        "enum": [
                          "x",
                          "y",
                          "z"
                        ],
                        "type": "string"
                      },
                      "offsetM": {
                        "type": "number",
                        "maximum": 0.01,
                        "minimum": 0
                      },
                      "direction": {
                        "anyOf": [
                          {
                            "type": "number",
                            "const": 1
                          },
                          {
                            "type": "number",
                            "const": -1
                          }
                        ]
                      },
                      "fullSurface": {
                        "type": "boolean"
                      }
                    }
                  },
                  "sealRadiusM": {
                    "type": "number",
                    "maximum": 0.03,
                    "minimum": 0.0005
                  }
                }
              },
              "maxItems": 32
            },
            "replaceBody": {
              "type": "boolean",
              "description": "Explicitly replace coachwork in a new work copy using structural panels; preserve wheels and Body calipers."
            }
          },
          "description": "Measured panels, curves, badges and decals; explicit PBR, clipping, symmetry, 250k vertex budget."
        },
        "cleanPaint": {
          "type": "boolean"
        },
        "paintColor": {
          "type": "array",
          "prefixItems": [
            {
              "type": "number"
            },
            {
              "type": "number"
            },
            {
              "type": "number"
            }
          ]
        },
        "wheelRebuild": {
          "type": "object",
          "required": [
            "radiusM",
            "widthM"
          ],
          "properties": {
            "spokes": {
              "type": "integer",
              "maximum": 12,
              "minimum": 3
            },
            "trackM": {
              "type": "number",
              "maximum": 6,
              "minimum": 0.3
            },
            "widthM": {
              "type": "number",
              "maximum": 0.8,
              "minimum": 0.05
            },
            "radiusM": {
              "type": "number",
              "maximum": 1.5,
              "minimum": 0.1
            },
            "segments": {
              "type": "integer",
              "maximum": 128,
              "minimum": 24
            }
          },
          "description": "Replace generated wheel meshes with measured tyres, dished spokes and brake rotors. Optional trackM adjusts axle track and matching explicit Body calipers together; omitted preserves wheel pivots."
        }
      },
      "description": "Guided surface repair; never edits the source"
    },
    "smooth": {
      "type": "integer",
      "maximum": 60,
      "minimum": 0,
      "description": "Body smoothing passes (default 15, 0 = none)"
    },
    "source": {
      "type": "object",
      "required": [
        "assetId",
        "revisionId"
      ],
      "properties": {
        "assetId": {
          "type": "string"
        },
        "fileRole": {
          "type": "string"
        },
        "revisionId": {
          "type": "string"
        }
      },
      "description": "Pinned static source, instead of id"
    },
    "wheels": {
      "type": "boolean",
      "description": "false keeps the generated wheels"
    },
    "segments": {
      "type": "integer",
      "maximum": 128,
      "minimum": 12,
      "description": "Wheel roundness: 64 default, 24 for mobile"
    },
    "idempotency_key": {
      "type": "string",
      "maxLength": 160,
      "minLength": 8
    }
  }
}
gripforge_vehicle_finish annotations
{
  "title": "Finish a vehicle",
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_library_get — Get Library item
Advertised by the server during the last successful anonymous check.
Advertised read-only

Get one Library item (metadata + signed file_url). A forged mesh shows its game-ready verdict first (meta.gameReady: ready, missing checks; meta.collider). VFX items also return studio_url to open the editable effect in GripForge, and workspace_id. A GripForge Compute asset also returns `compute` {edit_url, family: original + colour / material / polygon versions}. Pull bytes into a repo with the npm package.

gripforge_library_get input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "id"
  ],
  "properties": {
    "id": {
      "type": "string",
      "description": "Library id (lib_…)"
    },
    "workspace_id": {
      "type": "string",
      "maxLength": 100,
      "description": "Explicit workspace id. The key must have access to it."
    }
  }
}
gripforge_library_get annotations
{
  "title": "Get Library item",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_library_push — Push to Library
Advertised by the server during the last successful anonymous check.
Open-world

Upload a file into the Library locker from a URL (or small base64). Local paths need the npm MCP package.

gripforge_library_push input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "kind",
    "name"
  ],
  "properties": {
    "kind": {
      "enum": [
        "character",
        "fps-arms",
        "enemy",
        "creatures",
        "weapon",
        "equipment",
        "prop",
        "texture",
        "skybox",
        "loading",
        "hud",
        "button",
        "bind",
        "vfx",
        "animation",
        "audio"
      ],
      "type": "string",
      "description": "Locker kind"
    },
    "name": {
      "type": "string",
      "description": "Display name"
    },
    "base64": {
      "type": "string",
      "description": "Raw file as base64 (small files only)"
    },
    "file_url": {
      "type": "string",
      "description": "https URL of the file to store"
    },
    "filename": {
      "type": "string",
      "description": "Original filename"
    }
  }
}
gripforge_library_push annotations
{
  "title": "Push to Library",
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_library_pull — Pull from Library
Advertised by the server during the last successful anonymous check.
Advertised read-only

Return a signed same-origin file URL for a Library item you own (free). This hosted endpoint cannot write into your agent's working tree — use npx @gripforgeai/mcp gripforge_library_pull for that (that is the sync). Community assets are free to clone into your locker unless their creator sets a price in credits.

gripforge_library_pull input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "id"
  ],
  "properties": {
    "id": {
      "type": "string",
      "description": "Library id (lib_…)"
    }
  }
}
gripforge_library_pull annotations
{
  "title": "Pull from Library",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_library_tag — Tag a Library item
Advertised by the server during the last successful anonymous check.

Add a game look (e.g. souls-like, open-world-adventure) to tags so gripforge_style_kit can find the item. Does NOT overwrite grip style melee/gun/shield/staff — that stays on meta.style.

gripforge_library_tag input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "id"
  ],
  "properties": {
    "id": {
      "type": "string",
      "description": "Library id (lib_…)"
    },
    "kind": {
      "type": "string",
      "maxLength": 60,
      "description": "Reclassify the main type, for example creatures. The server validates compatibility with the file."
    },
    "tags": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Replace tags (canonicalized). Omit to keep existing and just add style."
    },
    "style": {
      "type": "string",
      "description": "Game look id or alias (e.g. souls-like, open-world-adventure)"
    },
    "subtypes": {
      "type": "array",
      "items": {
        "type": "string",
        "maxLength": 60
      },
      "maxItems": 24
    },
    "also_kinds": {
      "type": "array",
      "items": {
        "type": "string",
        "maxLength": 60
      },
      "maxItems": 24
    }
  }
}
gripforge_library_tag annotations
{
  "title": "Tag a Library item",
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_animate — Apply standard animation pack
Advertised by the server during the last successful anonymous check.

Retarget the Universal Animation Library pack onto a Mixamo-named Library character/enemy/armed bind. In a Game Kit project gripforge_gamekit_creatures runs it for free on every bound creature, and gripforge_game_audit lists the models still lacking movement or action clips. Base slots + extras (taunt, stinger, knockback, block, jump_start/loop/land, idle_guns, shoot). archetype remaps the base slots: sword (default), claws, heavy, brawler, puppet. Opt-in slots fire_breath (mouth exhalation) and energy_cast (two-hand azure wave) use the Studio VFX character motions. For captured two-hand saber guards/parries use actions with pack=touche and TC_Saber_* clips from GET /api/v1/animate-pack; retains CC BY 4.0 attribution. Explicit actions replace the preset selection. Saves kind=animation. 0 credits.

gripforge_animate input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "character_id"
  ],
  "properties": {
    "name": {
      "type": "string",
      "description": "Library name for the animated GLB"
    },
    "slots": {
      "type": "array",
      "items": {
        "enum": [
          "idle",
          "walk",
          "run",
          "attack1",
          "attack2",
          "attack3",
          "hit",
          "death",
          "dodge",
          "taunt",
          "stinger",
          "knockback",
          "block",
          "jump_start",
          "jump_loop",
          "jump_land",
          "idle_guns",
          "shoot",
          "fire_breath",
          "energy_cast"
        ],
        "type": "string"
      },
      "description": "Subset of clips (default: all)"
    },
    "actions": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "slot",
          "pack",
          "clip"
        ],
        "properties": {
          "clip": {
            "type": "string",
            "maxLength": 80,
            "minLength": 1
          },
          "pack": {
            "enum": [
              "ual1",
              "ual2",
              "kim",
              "kmd",
              "touche"
            ],
            "type": "string"
          },
          "slot": {
            "type": "string",
            "maxLength": 80,
            "minLength": 1
          }
        }
      },
      "maxItems": 32,
      "description": "Explicit library clips; Touché is two-hand defensive motion, not a full duel."
    },
    "archetype": {
      "enum": [
        "sword",
        "claws",
        "heavy",
        "brawler",
        "puppet"
      ],
      "type": "string",
      "description": "Movement/strike archetype — remaps the base slots (default sword)"
    },
    "character_id": {
      "type": "string",
      "description": "Library character, enemy, or armed bind id"
    }
  }
}
gripforge_animate annotations
{
  "title": "Apply standard animation pack",
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_audio_kit — Audio kit for a game style
Advertised by the server during the last successful anonymous check.
Advertised read-only

Search locker + Community audio. Prompt matches name, description, tags and use (gunshot, ui, magic, footsteps, announcer, dinosaure, magie, pas…). Each hit has id, description, use[], pack, file_url. Community hits: clone with /api/v1/community/{id}/clone (free unless the creator sets a price in credits) then pull. Free to search.

gripforge_audio_kit input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "prompt": {
      "type": "string",
      "description": "What you need, e.g. \"gunshot\", \"ui click\", \"dinosaur roar\", \"magie\", \"annonceur fps\". Omit for a short catalog."
    }
  }
}
gripforge_audio_kit annotations
{
  "title": "Audio kit for a game style",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_aim — Aim-offset poses (two-bone IK per hand)
Advertised by the server during the last successful anonymous check.
Advertised read-only

Aim-offset poses for a Library character/armed bind (0 credits): per hand, two-bone IK + wrist alignment so the WEAPON AXIS (gf_muzzle locator from loadout, else the seat forward) points at every direction of a yaw×pitch grid. Returns bone-local quaternions per pose + rest, and a Godot blend snippet. Dual wield ready (independent hands).

gripforge_aim input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "yaws": {
      "type": "array",
      "items": {
        "type": "number"
      },
      "description": "Default [-60,-30,0,30,60]"
    },
    "hands": {
      "type": "array",
      "items": {
        "enum": [
          "left",
          "right"
        ],
        "type": "string"
      }
    },
    "pitches": {
      "type": "array",
      "items": {
        "type": "number"
      },
      "description": "Default [-40,-20,0,20,40]"
    },
    "attach_id": {
      "type": "string",
      "description": "Armed bind / loadout id (lib_…) — preferred"
    },
    "extension": {
      "type": "number",
      "description": "Arm extension 0.5–0.98 (default 0.9)"
    },
    "character_id": {
      "type": "string",
      "description": "Character id if no bind"
    }
  }
}
gripforge_aim annotations
{
  "title": "Aim-offset poses (two-bone IK per hand)",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_level — Plan a playable level from a prompt
Advertised by the server during the last successful anonymous check.
Advertised read-only

Plan a playable level from a prompt (0 credits): rooms placed in metres (entrance, combat rooms, key/lock, boss room, treasure, secret), connections, critical path, shortcuts, and gameplay spawns (player/packs/boss/rewards). Same seed → same level. Pair with gripforge_scene_kit for dressing props.

gripforge_level input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "prompt"
  ],
  "properties": {
    "seed": {
      "type": "number"
    },
    "floors": {
      "type": "number"
    },
    "prompt": {
      "type": "string",
      "description": "e.g. \"gothic castle dungeon, 3 combat rooms, one boss\""
    },
    "combat_rooms": {
      "type": "number"
    },
    "optional_branches": {
      "type": "number"
    }
  }
}
gripforge_level annotations
{
  "title": "Plan a playable level from a prompt",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_loadout — Multi-weapon loadout (attach + manifest + clips)
Advertised by the server during the last successful anonymous check.

Build a multi-weapon character in ONE call: attaches every prop of every set onto the same rig, names each prop node gf_prop_<slug>_<l|r>, stamps glTF extras { gripforge: { prop, set, hand } } and a scene manifest { default, sets }, then retargets the standard clip pack (animate: false to skip). The engine switches weapons by toggling node visibility. Example sets: { "sword": [{"prop_id":"lib_sword"}], "guns": [{"prop_id":"lib_gun","hand":"left","style":"gun"}, {"prop_id":"lib_gun","hand":"right","style":"gun"}] }. Credits: one attach per prop.

gripforge_loadout input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "character_id",
    "sets"
  ],
  "properties": {
    "name": {
      "type": "string"
    },
    "sets": {
      "type": "object",
      "description": "set name → props held in that set",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {
        "type": "array",
        "items": {
          "type": "object",
          "required": [
            "prop_id"
          ],
          "properties": {
            "hand": {
              "enum": [
                "left",
                "right"
              ],
              "type": "string"
            },
            "style": {
              "enum": [
                "melee",
                "gun",
                "shield",
                "staff"
              ],
              "type": "string"
            },
            "prop_id": {
              "type": "string"
            },
            "prop_grip": {
              "type": "object",
              "required": [
                "position",
                "axis",
                "normal"
              ],
              "properties": {
                "axis": {
                  "type": "array",
                  "description": "Handle direction / shield top (+Y of the grip frame)",
                  "prefixItems": [
                    {
                      "type": "number"
                    },
                    {
                      "type": "number"
                    },
                    {
                      "type": "number"
                    }
                  ]
                },
                "normal": {
                  "type": "array",
                  "description": "Blade flat / outward shield face (+Z of the grip frame)",
                  "prefixItems": [
                    {
                      "type": "number"
                    },
                    {
                      "type": "number"
                    },
                    {
                      "type": "number"
                    }
                  ]
                },
                "edgeAxis": {
                  "type": "array",
                  "description": "Signed cutting/striking direction in the blade plane, perpendicular to axis and normal. Forward grip: away from wrist. This is NOT the blade flat normal.",
                  "prefixItems": [
                    {
                      "type": "number"
                    },
                    {
                      "type": "number"
                    },
                    {
                      "type": "number"
                    }
                  ]
                },
                "position": {
                  "type": "array",
                  "description": "Grip point in the prop scene local coordinates",
                  "prefixItems": [
                    {
                      "type": "number"
                    },
                    {
                      "type": "number"
                    },
                    {
                      "type": "number"
                    }
                  ]
                },
                "handleSpan": {
                  "type": "number",
                  "description": "Usable handle length centred on position, in prop-local units. Required for independent mesh section checks; curved handles use their local tangent.",
                  "exclusiveMinimum": 0
                }
              },
              "description": "Exact prop grip frame; overrides geometric guesses. Returns orientation/contact diagnostics; missing or ambiguous geometry stays needs_review. A gf_grip locator can supply the same frame."
            },
            "height_ratio": {
              "type": "number",
              "maximum": 1.5,
              "minimum": 0.05
            }
          }
        }
      }
    },
    "animate": {
      "type": "boolean",
      "description": "Also retarget the standard clip pack (default true)"
    },
    "default": {
      "type": "string",
      "description": "Set visible by default (first set otherwise)"
    },
    "archetype": {
      "enum": [
        "sword",
        "claws",
        "heavy",
        "brawler",
        "puppet"
      ],
      "type": "string",
      "description": "Movement/strike archetype — remaps the base slots (default sword)"
    },
    "character_id": {
      "type": "string",
      "description": "Library character id (lib_…)"
    }
  }
}
gripforge_loadout annotations
{
  "title": "Multi-weapon loadout (attach + manifest + clips)",
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_retarget — Retarget a clip onto another skeleton
Advertised by the server during the last successful anonymous check.

Convert animation clips from skeleton A (source_id GLB) onto skeleton B (target_id). Bone-name heuristic (Mixamo / UAL / Tripo). Saves kind=animation.

gripforge_retarget input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "source_id",
    "target_id"
  ],
  "properties": {
    "clip": {
      "type": "string",
      "description": "Clip name on the source (default: first clip)"
    },
    "name": {
      "type": "string"
    },
    "source_id": {
      "type": "string",
      "description": "Library GLB that already has clips"
    },
    "target_id": {
      "type": "string",
      "description": "Library character/enemy to drive"
    }
  }
}
gripforge_retarget annotations
{
  "title": "Retarget a clip onto another skeleton",
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_rest_pose — Idle rest pose (arms down)
Advertised by the server during the last successful anonymous check.

Lower the character's arms from T-pose until they would clip THIS mesh (cape/chest/hips), then save an arms-down rest GLB (clip "idle"). Armed binds keep attached weapons in the hands. 0 credits. Attach first, then rest_pose on the bind id.

gripforge_rest_pose input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "character_id"
  ],
  "properties": {
    "name": {
      "type": "string"
    },
    "character_id": {
      "type": "string",
      "description": "Library character, enemy, or armed bind"
    }
  }
}
gripforge_rest_pose annotations
{
  "title": "Idle rest pose (arms down)",
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_fps_kit — Tactical FPS engine
Advertised by the server during the last successful anonymous check.
Advertised read-only

Reusable FPS rules, map and runtime exports for Godot and web: weapons, reload markers, viewmodel, camera, bots, grenades and bomb rounds. Offline bots. Persist changes with gripforge_kit. 0 credits.

gripforge_fps_kit input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "map": {
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "rules": {
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "action": {
      "enum": [
        "get",
        "validate",
        "export"
      ],
      "type": "string",
      "default": "get"
    },
    "kit_id": {
      "type": "string"
    },
    "target": {
      "enum": [
        "web",
        "godot",
        "both"
      ],
      "type": "string",
      "default": "both"
    },
    "asset_slots": {
      "type": "array",
      "items": {
        "type": "string"
      }
    }
  }
}
gripforge_fps_kit annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_kit — Game Kits — read and compose game engines (manifest + rules)
Advertised by the server during the last successful anonymous check.

A game kit IS an engine: its manifest carries asset slots AND GameRules — the genre as a document (movement, camera, world, objective, entities, pickups, ai, hud, audio). action=list → kits of the workspace. action=get {id} → manifest + rules (lib_… id). action=create {style?, name?, rules?, slots?} → new kit, rules default to the style then merge yours. action=patch {id, rules?, slots?, prompts?, name?} → partial update; rules merge section by section, a section set to null resets it. Slot refs inside rules must point at slot ids of the kit (unknown refs are dropped, the renderer falls back to procedural). Compose a NEW genre by writing rules: e.g. movement vehicle-boost + world arena-ring + objective knockout = sumo cars, no code.

gripforge_kit input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "action"
  ],
  "properties": {
    "id": {
      "type": "string",
      "maxLength": 80,
      "description": "kit id (lib_…) — get/patch"
    },
    "name": {
      "type": "string",
      "maxLength": 160
    },
    "rules": {
      "anyOf": [
        {
          "type": "object",
          "propertyNames": {
            "type": "string"
          },
          "additionalProperties": {}
        },
        {
          "type": "null"
        }
      ],
      "description": "GameRules document or partial patch"
    },
    "slots": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "id",
          "itemId"
        ],
        "properties": {
          "id": {
            "type": "string",
            "maxLength": 40
          },
          "itemId": {
            "anyOf": [
              {
                "type": "string",
                "maxLength": 64
              },
              {
                "type": "null"
              }
            ]
          }
        }
      },
      "description": "slot assignments"
    },
    "style": {
      "type": "string",
      "maxLength": 64,
      "description": "create: preset style (e.g. arena-car, custom)"
    },
    "action": {
      "enum": [
        "list",
        "get",
        "create",
        "patch"
      ],
      "type": "string",
      "description": "what to do"
    },
    "prompts": {
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {
        "type": "string",
        "maxLength": 4000
      }
    }
  }
}
gripforge_kit annotations
{
  "title": "Game Kit engine",
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_hud_import — HUD Studio — import a game HUD from the project, list and read the workspace HUDs
Advertised by the server during the last successful anonymous check.

Not the survivor generator (that is gripforge_hud): this one READS an existing HUD. action=import {text, filename?, name?} → reads the HUD of the project and saves it as a HUD document of the workspace; Pass screenshot (a capture of the screen while the game runs) so My HUDs shows the real thing; action shot attaches one to a HUD imported earlier.returns the studio URL to open it. `text` is the engine file as-is: a Godot .tscn scene, a Unity .uxml (UI Toolkit) or a .unity / .prefab (RectTransforms), the Unreal UMG designer clipboard (select the widgets, Ctrl+C — .uasset files are binary), or a GripForge hud.json / hud.v2.json. Read the file yourself and pass its content; `filename` helps detect the format. Controls are recognised by name (health, mana, minimap, ammo, quest…) and type, placed on nine anchors; the report lists what was created and skipped. action=list → HUDs of the workspace. action=get {id} → one HUD document (hud_… id).

gripforge_hud_import input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "action"
  ],
  "properties": {
    "id": {
      "type": "string",
      "description": "get / shot: the HUD (hud_…); import: re-import into that existing HUD — its name, level, role and capture stay, its elements are replaced"
    },
    "name": {
      "type": "string",
      "maxLength": 120,
      "description": "import: name of the HUD in the studio"
    },
    "role": {
      "enum": [
        "screen",
        "widget"
      ],
      "type": "string",
      "description": "import: \"screen\" (a menu, a loading screen, the in-game HUD, a page) or \"widget\" (a component: a bar, a minimap, a button, a damage number); the studio lists a level's screens first and its widgets apart. Inferred from the footprint when omitted: a screen spans ≥ 45 % of the width or ≥ 60 % of the height"
    },
    "text": {
      "type": "string",
      "maxLength": 6291456,
      "description": "import: the engine file content"
    },
    "level": {
      "type": "string",
      "maxLength": 80,
      "description": "import: the level / map where this screen shows (MainMenu, Desert_Castle…) — the studio groups a project's screens by level; the Unreal bridge /hud/list gives it from the asset registry (widget ← blueprints ← map), otherwise trace which map references the screen"
    },
    "action": {
      "enum": [
        "import",
        "list",
        "get",
        "shot"
      ],
      "type": "string",
      "description": "import a screen · list the workspace HUDs · get one · shot = attach a capture of the screen in play to an existing HUD (id + screenshot)"
    },
    "embeds": {
      "type": "object",
      "description": "import (Unreal): the nested Widget Blueprints this screen places (asset name → their T3D export, e.g. { WBP_Menu: \"Begin Object…\" }) so their buttons, bars and texts become elements of the screen instead of an empty box; the Unreal bridge /hud/get returns them as embeds",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {
        "type": "string"
      }
    },
    "project": {
      "type": "string",
      "maxLength": 80,
      "description": "import: game project name (e.g. the .uproject / project folder) — the studio groups HUDs by project"
    },
    "filename": {
      "type": "string",
      "maxLength": 200,
      "description": "import: original file name (hud.tscn, HUD.prefab, GameHud.uxml, umg.txt…)"
    },
    "pictures": {
      "type": "object",
      "description": "import: texture name → base64 PNG/JPEG of that picture (≤ 6 MB each, 60 max): stored in the Library and linked to the screen's images, buttons and bars — one call gives the screen its real art",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {
        "type": "string"
      }
    },
    "textures": {
      "type": "object",
      "description": "import: texture name → lib_… id of that picture pushed with gripforge_library_push (kind hud); links the screen's images, buttons and bars to their real art",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {
        "type": "string"
      }
    },
    "screenshot": {
      "type": "string",
      "description": "import / shot: base64 PNG or JPEG (≤ 16 MB, data URL accepted; stored packed to 1080p JPEG) of this screen captured while the game runs — becomes its thumbnail in My HUDs and the backdrop of the editor preview. Capture it in the engine: Unreal bridge GET http://127.0.0.1:8439/shot?play=1&level=/Game/Maps/MainMenu&wait=5 (opens that map, starts Play In Editor, captures with the UI, stops; without play=1 it captures the editor viewport), or an Unreal MCP capture_viewport during PIE; Godot get_viewport().get_texture().get_image().save_png(); Unity ScreenCapture.CaptureScreenshot"
    }
  }
}
gripforge_hud_import annotations
{
  "title": "HUD import",
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_settings — Game Settings of the workspace — genre, controls, match, menu
Advertised by the server during the last successful anonymous check.

The workspace IS the game: genre (a game kit style id, e.g. arena-car), remappable controls (same InputKit as the Godot input.json AND the web players), match rules (rounds/laps/score/timers/ports) and menu options (title, HUD toggles). Once set, every *-kit route called WITHOUT ?prompt= reads them (explicit prompt always wins), and the web players use the same bindings. Call with no args to READ (settings + resolved defaults). Pass fields to MERGE-SET. Pass a section as null to reset it to the genre preset. Set genre at project start, right after gripforge_style.

gripforge_settings input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "menu": {
      "anyOf": [
        {
          "type": "object",
          "propertyNames": {
            "type": "string"
          },
          "additionalProperties": {}
        },
        {
          "type": "null"
        }
      ],
      "description": "{title, preset, hud:{…}} — null resets"
    },
    "genre": {
      "anyOf": [
        {
          "type": "string",
          "maxLength": 64
        },
        {
          "type": "null"
        }
      ],
      "description": "game kit style id (e.g. arena-car) — null resets"
    },
    "match": {
      "anyOf": [
        {
          "type": "object",
          "propertyNames": {
            "type": "string"
          },
          "additionalProperties": {}
        },
        {
          "type": "null"
        }
      ],
      "description": "partial match rules — null resets"
    },
    "controls": {
      "anyOf": [
        {
          "type": "object",
          "required": [
            "actions"
          ],
          "properties": {
            "kit_id": {
              "type": "string",
              "maxLength": 32
            },
            "actions": {
              "type": "array",
              "items": {
                "type": "object",
                "propertyNames": {
                  "type": "string"
                },
                "additionalProperties": {}
              }
            }
          }
        },
        {
          "type": "null"
        }
      ],
      "description": "full InputKit actions (InputBind[]) — null resets to genre preset"
    }
  }
}
gripforge_settings annotations
{
  "title": "Workspace Game Settings",
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_style — Workspace Style DNA — set once, applied to every generation
Advertised by the server during the last successful anonymous check.

The visual identity of the workspace: palette (hex colors), written art direction, and sliders (realism/saturation/edges). Once set, it is AUTOMATICALLY appended to every generation prompt (characters, enemies, props, HUD bars…) so ten assets come out as ONE game — and gripforge_inspect gains a style check flagging assets whose dominant colors drift from the palette. Call with no args to READ the current DNA (+ the compiled prompt block). Pass fields to SET it. Pass extract_from (image lib ids) to auto-build the palette from reference art. clear:true removes it. Set the DNA at the START of a game project, before generating.

gripforge_style input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "refs": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "maxItems": 5,
      "description": "pinned reference lib ids"
    },
    "clear": {
      "type": "boolean",
      "description": "remove the workspace style"
    },
    "edges": {
      "enum": [
        "soft",
        "hard"
      ],
      "type": "string"
    },
    "palette": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "hex"
        ],
        "properties": {
          "hex": {
            "type": "string"
          },
          "name": {
            "type": "string"
          }
        }
      },
      "maxItems": 6,
      "description": "2-6 colors, e.g. [{hex:\"#8b1a1a\",name:\"blood red\"}]"
    },
    "realism": {
      "enum": [
        "stylized",
        "semi",
        "realistic"
      ],
      "type": "string"
    },
    "direction": {
      "type": "string",
      "maxLength": 500,
      "description": "art direction, e.g. \"gothic, worn leather, tarnished metal\""
    },
    "saturation": {
      "enum": [
        "muted",
        "balanced",
        "vivid"
      ],
      "type": "string"
    },
    "extract_from": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "maxItems": 5,
      "description": "image lib ids — extract the palette from them"
    }
  }
}
gripforge_style annotations
{
  "title": "Workspace Style DNA",
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_inspect — Inspect an asset: metrics, QA checks, multi-angle sheet
Advertised by the server during the last successful anonymous check.
Advertised read-only

THE FEEDBACK LOOP: call this after every generate/attach/rig to SEE and VERIFY what you made, before building on top of it. Deterministic, free, repeatable. Returns (1) a structured report — kind guess, triangles/vertices, materials+textures, skeleton (bones, finger bones per hand, cape grid), animations, size in metres — and (2) QA checks with ok/warn/fail + why: plausible scale, poly budget, normals/UVs, rig skinned, strict T-pose arms, five-finger bones, feet on ground. Also returns a multi-angle render sheet (front/right/back/left by default) so you can look at the asset. Fix warns/fails (regenerate, rest_pose, retarget…) then inspect again.

gripforge_inspect input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "id"
  ],
  "properties": {
    "id": {
      "type": "string",
      "description": "Library id (lib_…) of a GLB"
    },
    "sheet": {
      "type": "boolean",
      "description": "include the multi-angle PNG (default true)"
    },
    "angles": {
      "type": "array",
      "items": {
        "type": "number"
      },
      "maxItems": 6,
      "description": "yaw angles in degrees (default [0,90,180,270])"
    }
  }
}
gripforge_inspect annotations
{
  "title": "Inspect an asset",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_render — Render a Library mesh to PNG
Advertised by the server during the last successful anonymous check.
Advertised read-only

Server-side software preview (PNG) of a Library GLB so the agent can see pose/attach without a browser. Not a path-traced studio shot.

gripforge_render input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "id"
  ],
  "properties": {
    "id": {
      "type": "string",
      "description": "Library id (lib_…)"
    },
    "width": {
      "type": "number"
    },
    "height": {
      "type": "number"
    }
  }
}
gripforge_render annotations
{
  "title": "Render a Library mesh to PNG",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_scene_kit — Scene dressing kit
Advertised by the server during the last successful anonymous check.
Advertised read-only

Return locker props for a game look plus a suggested layout (metres, Y-up). Call after style_kit. Empty slots mean generate that dressing prop, tag it, retry. Does not generate meshes.

gripforge_scene_kit input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "prompt"
  ],
  "properties": {
    "prompt": {
      "type": "string",
      "maxLength": 240,
      "minLength": 2,
      "description": "e.g. \"stylish gothic action\", \"anime adventure plaza\""
    }
  }
}
gripforge_scene_kit annotations
{
  "title": "Scene dressing kit",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_hitbox — Gameplay hitboxes
Advertised by the server during the last successful anonymous check.
Advertised read-only

Body capsules (head/torso/limbs) plus weapons[] — one reach capsule per gf_prop_ wrapper on a loadout/armed bind. Pass id of a loadout GLB (or character_id / attach_id). 0 credits. Use weapons[] not the single weapon field for dual-wield.

gripforge_hitbox input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "id": {
      "type": "string",
      "description": "Library id of a loadout / bind / character (lib_…)"
    },
    "attach_id": {
      "type": "string",
      "description": "Library armed bind id"
    },
    "character_id": {
      "type": "string",
      "description": "Library character/enemy id"
    }
  }
}
gripforge_hitbox annotations
{
  "title": "Gameplay hitboxes",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_vehicle_orient — Vehicle / kart mesh yaw
Advertised by the server during the last successful anonymous check.
Advertised read-only

Yaw so a kart/vehicle GLB nose is local +Z (Meshy often faces +X). Then heading = yawToward(track tangent) = atan2(fx, fz). Pass Library id of the kart prop. Returns meshYaw + Godot snippets. 0 credits.

gripforge_vehicle_orient input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "id": {
      "type": "string",
      "description": "Library id of the vehicle/kart GLB (lib_…)"
    },
    "prop_id": {
      "type": "string",
      "description": "Same as id"
    }
  }
}
gripforge_vehicle_orient annotations
{
  "title": "Vehicle / kart mesh yaw",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_map_plan — Top-down FPS map plan
Advertised by the server during the last successful anonymous check.
Advertised read-only

For original competitive 5v5 maps use target=tactical: deterministic modular greybox, real controller/bot paths, standing/crouched sightlines, timings and diagnostic links. Optional art_profile applies reusable PBR harbor facades without changing gameplay collision. Human playtests required. Legacy FPS/bomb map in metres. Interprets the overhead as a 3D compound: hollow rooms, corniche/catwalk, A plat + pit, arches/windows, vaulted tunnels, T/CT, sidewalks. Preview: https://gripforge.ai/map-plan?prompt=bomb%20defusal. Pair gripforge_map_props (crates/cars) + gripforge_map_wires (cables). 0 credits. Not a dungeon — use gripforge_level.

gripforge_map_plan input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "prompt"
  ],
  "properties": {
    "item": {
      "type": "string",
      "description": "lib_… traced plan from gripforge_map_concept (overrides the preset)"
    },
    "seed": {
      "type": "integer",
      "maximum": 4294967295,
      "minimum": 0
    },
    "prompt": {
      "type": "string",
      "maxLength": 600,
      "minLength": 2,
      "description": "e.g. \"Original industrial harbor, 5v5, two objective sites and contested Mid\""
    },
    "target": {
      "enum": [
        "legacy",
        "tactical"
      ],
      "type": "string",
      "description": "tactical: original fixed 5v5 greybox + controller route, collision and sightline reports; not certified balance"
    },
    "variant": {
      "enum": [
        "quay",
        "switchyard",
        "arcade"
      ],
      "type": "string"
    },
    "windows": {
      "enum": [
        "shuttered",
        "barred",
        "none"
      ],
      "type": "string",
      "description": "Boundary windows: volets entrouverts (default), grilles bois, ou aucune"
    },
    "art_profile": {
      "enum": [
        "mediterranean-harbor",
        "limestone-harbor"
      ],
      "type": "string",
      "description": "Reusable environment dressing; omit to qualify the greybox first"
    },
    "window_density": {
      "type": "number",
      "maximum": 1,
      "minimum": 0,
      "description": "Share of boundary segments that get a window (default 0.25)"
    }
  }
}
gripforge_map_plan annotations
{
  "title": "Top-down FPS map plan",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_map_concept — AI-drawn map layout
Advertised by the server during the last successful anonymous check.
Open-world

gpt-image-2 draws a top-down plan schematic (solid white walls on pure black) + a 3/4 aerial greybox concept render, auto-traces the plan into MapPlan wall boxes and saves both images to the Library. Reuse the traced plan with gripforge_map_plan { item } or https://gripforge.ai/map-plan?item=lib_…&greybox=1. Use when the layout should come from an image instead of the code presets. ~2 images of generation cost.

gripforge_map_concept input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "prompt"
  ],
  "properties": {
    "prompt": {
      "type": "string",
      "maxLength": 400,
      "minLength": 3,
      "description": "e.g. \"moroccan desert village bomb map, tight alleys, two plazas\""
    },
    "extent_m": {
      "type": "number",
      "maximum": 300,
      "minimum": 40,
      "description": "Playfield size in metres (default 110)"
    },
    "threshold": {
      "type": "number",
      "maximum": 240,
      "minimum": 30,
      "description": "Wall luminance threshold (default 110)"
    }
  }
}
gripforge_map_concept annotations
{
  "title": "AI-drawn map layout",
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_map_refs — Map in-game screenshot refs
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Look up reference stills of a known map the user names (A, B, mid, catwalk, tunnels, spawn). Returns HTTPS URLs of their owner. Reference only — do not rehost, do not send to Meshy image-to-3d. Read materials then generate ORIGINAL locker props. live=true HEAD-checks links. 0 credits. Preview https://gripforge.ai/map-plan?prompt=bomb%20defusal

gripforge_map_refs input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "prompt"
  ],
  "properties": {
    "live": {
      "type": "boolean",
      "description": "HEAD-check URLs (default false)"
    },
    "prompt": {
      "type": "string",
      "maxLength": 240,
      "minLength": 2,
      "description": "e.g. \"bomb defusal\""
    }
  }
}
gripforge_map_refs annotations
{
  "title": "Map in-game screenshot refs",
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_map_props — FPS map callout props
Advertised by the server during the last successful anonymous check.
Advertised read-only

Dressing for an FPS map in metres: crates (A default, B big box, cover boxes), doors (mid, long, B), palms at a spawn, barrels, cars. Matches locker props when tagged. Empty slot → generate that prop. Pair with gripforge_map_plan. 0 credits. Preview https://gripforge.ai/map-plan?prompt=bomb%20defusal

gripforge_map_props input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "prompt"
  ],
  "properties": {
    "prompt": {
      "type": "string",
      "maxLength": 240,
      "minLength": 2,
      "description": "e.g. \"tactical bomb defusal\""
    }
  }
}
gripforge_map_props annotations
{
  "title": "FPS map callout props",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_map_wires — FPS map overhead electricals
Advertised by the server during the last successful anonymous check.
Advertised read-only

Sagging electrical cables for an FPS map: spans with two anchors (metres) + sag + strands. Not a generated mesh — GfMap tessellates cylinders (role=wire). Typical spans: spawn yard, catwalk, mid, A site. Pair with gripforge_map_plan. 0 credits. Preview https://gripforge.ai/map-plan?prompt=bomb%20defusal

gripforge_map_wires input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "prompt"
  ],
  "properties": {
    "prompt": {
      "type": "string",
      "maxLength": 240,
      "minLength": 2,
      "description": "e.g. \"tactical bomb defusal\""
    }
  }
}
gripforge_map_wires annotations
{
  "title": "FPS map overhead electricals",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_map_reconstruct — Hierarchical FPS map reconstruction
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Reconstruct an FPS map: collect official stills (HTTPS LINKS, classified by folder) → MapGraph (callouts/chokes) → footprint greybox (no props) → zone parts → camera match → dress. prompt e.g. "Reconstruct map: desert bomb-defusal map with two sites". stage=collect|graph|greybox|zone|validate|capture|dress|all. zone=LONG_A|A_SITE|…. stage=dress keeps greybox volumes and adds original tileable materials + map_props + map_wires (never the owner's pixels). Preview /map-plan?prompt=bomb%20defusal. A known map stays its owner's IP — internal greybox benchmark, not a commercial clone. Never Meshy a screenshot, never ingest BSP/VPK. 0 credits. Greybox preview https://gripforge.ai/map-plan?prompt=bomb%20defusal&greybox=1

gripforge_map_reconstruct input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "prompt"
  ],
  "properties": {
    "zone": {
      "type": "string",
      "maxLength": 40,
      "minLength": 2,
      "description": "LONG_A | A_SITE | CATWALK | T_SPAWN | …"
    },
    "stage": {
      "enum": [
        "collect",
        "graph",
        "greybox",
        "zone",
        "validate",
        "capture",
        "dress",
        "all"
      ],
      "type": "string",
      "description": "collect | graph | greybox | zone | validate | capture | dress | all (default all)"
    },
    "prompt": {
      "type": "string",
      "maxLength": 240,
      "minLength": 2,
      "description": "e.g. \"Reconstruct map: desert bomb-defusal map with two sites\""
    }
  }
}
gripforge_map_reconstruct annotations
{
  "title": "Hierarchical FPS map reconstruction",
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_map_look — Map still → camera + dressing
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Reproduce a reference still of the built-in reference map WITHOUT copying pixels. Returns camera (pos/target/fov) + volume/prop/wire ids for that shot. shot=shot21a (A site), shot1a (spawn yard), shot5a (catwalk). Official URL is a LINK only — never rehost, never Meshy image-to-3d. Pair with gripforge_map_plan + map_props + map_wires. 0 credits.

gripforge_map_look input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "prompt"
  ],
  "properties": {
    "shot": {
      "type": "string",
      "maxLength": 80,
      "minLength": 2,
      "description": "shot21a | a-site | shot1a | catwalk | URL fragment"
    },
    "prompt": {
      "type": "string",
      "maxLength": 240,
      "minLength": 2,
      "description": "e.g. \"bomb defusal\""
    }
  }
}
gripforge_map_look annotations
{
  "title": "Map still → camera + dressing",
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_viewmodel_kit — FPS viewmodel (CS hands)
Advertised by the server during the last successful anonymous check.
Advertised read-only

CS-style first-person arms + gun under Camera3D/Hold. Returns viewmodel.json, gf_viewmodel.gd, clip shader. Pull Mixamo T-pose characters (palms down) into bodies paths. Gun is a sibling under Hold, not the world-body hand bone. Pair with gripforge_input_kit. 0 credits.

gripforge_viewmodel_kit input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "prompt"
  ],
  "properties": {
    "prompt": {
      "type": "string",
      "maxLength": 240,
      "minLength": 2,
      "description": "e.g. \"fps\" or \"tactical bomb defusal\""
    }
  }
}
gripforge_viewmodel_kit annotations
{
  "title": "FPS viewmodel (CS hands)",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_match_kit — Listen-server match contract
Advertised by the server during the last successful anonymous check.
Advertised read-only

Party size, teams, maps, ranked flag, join-by-IP. Write res://gripforge/match.json and autoload GfMatch on top of GfNet. GripForge does not host a matchmaking queue. 0 credits.

gripforge_match_kit input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "prompt"
  ],
  "properties": {
    "prompt": {
      "type": "string",
      "maxLength": 240,
      "minLength": 2,
      "description": "e.g. tactical 5v5, deathmatch, ranked 5v5"
    }
  }
}
gripforge_match_kit annotations
{
  "title": "Listen-server match contract",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_performance — Diagnose game stutter from measured frames and network delivery
Advertised by the server during the last successful anonymous check.
Advertised read-only

Analyze a supplied game performance report, or read the latest instrumented kit capture in your authenticated workspace. Separates frame pacing, measured CPU/GPU work, render counters and stale network snapshots; returns evidence, recommendations and explicit measurement limits. Captures expire after 10 minutes or server restart. Explicit reports are not stored. Does not edit, deploy or automatically fix a game. 0 credits.

gripforge_performance input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "kit_id": {
      "type": "string",
      "pattern": "^[A-Za-z0-9_.:-]+$",
      "maxLength": 128,
      "minLength": 1,
      "description": "Optional kit/library id to select a recent capture; omitted selects latest in your workspace."
    },
    "report": {
      "type": "object",
      "required": [
        "samples"
      ],
      "properties": {
        "game": {
          "type": "string",
          "maxLength": 80
        },
        "samples": {
          "type": "array",
          "items": {
            "type": "object",
            "properties": {
              "fps": {
                "type": "number",
                "maximum": 1000,
                "minimum": 0
              },
              "cpuMs": {
                "type": "number",
                "maximum": 60000,
                "minimum": 0
              },
              "gpuMs": {
                "anyOf": [
                  {
                    "type": "number",
                    "maximum": 60000,
                    "minimum": 0
                  },
                  {
                    "type": "null"
                  }
                ]
              },
              "level": {
                "type": "integer",
                "maximum": 10,
                "minimum": 0
              },
              "p95Ms": {
                "type": "number",
                "maximum": 60000,
                "minimum": 0
              },
              "frameMs": {
                "type": "number",
                "maximum": 60000,
                "minimum": 0
              },
              "quality": {
                "enum": [
                  "auto",
                  "high",
                  "performance"
                ],
                "type": "string"
              },
              "submitMs": {
                "type": "number",
                "maximum": 60000,
                "minimum": 0
              },
              "drawCalls": {
                "type": "integer",
                "maximum": 1000000,
                "minimum": 0
              },
              "networkMs": {
                "anyOf": [
                  {
                    "type": "number",
                    "maximum": 60000,
                    "minimum": 0
                  },
                  {
                    "type": "null"
                  }
                ]
              },
              "triangles": {
                "type": "integer",
                "maximum": 1000000000,
                "minimum": 0
              },
              "pixelRatio": {
                "type": "number",
                "maximum": 8,
                "minimum": 0.01
              },
              "snapshotAgeMs": {
                "type": "number",
                "maximum": 60000,
                "minimum": 0
              }
            }
          },
          "maxItems": 120,
          "minItems": 1
        },
        "version": {
          "type": "string",
          "maxLength": 80
        },
        "viewport": {
          "type": "object",
          "required": [
            "width",
            "height"
          ],
          "properties": {
            "width": {
              "type": "integer",
              "maximum": 32768,
              "minimum": 1
            },
            "height": {
              "type": "integer",
              "maximum": 32768,
              "minimum": 1
            }
          }
        }
      },
      "description": "Optional measured report with 1–120 sample windows. Omit to read a recent workspace capture."
    }
  }
}
gripforge_performance annotations
{
  "title": "Diagnose game stutter",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_net_kit — Godot ENet listen-server (Godot only)
Advertised by the server during the last successful anonymous check.
Advertised read-only

GfNet autoload host/join/spawn with server-side hit validation, gf_round.gd for the round + bomb, MultiplayerSpawner/Synchronizer wiring. 0 credits. Godot only: for a web game built on the Game Kits the network model is the installed sync kit (net.claim = claim, net.authoritative, net.rollback, net.state; room config.net {model, sync, physics} is read from the project): use gripforge_gamekit_install / gripforge_gamekit_configure, then gripforge_docs topics net and web-multiplayer (rooms at /play/online/host/<project_id>?players=N).

gripforge_net_kit input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "prompt"
  ],
  "properties": {
    "prompt": {
      "type": "string",
      "maxLength": 240,
      "minLength": 2,
      "description": "e.g. tactical 5v5, deathmatch, fps"
    }
  }
}
gripforge_net_kit annotations
{
  "title": "Godot ENet listen-server",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_menu_kit — Menu + lobby + HUD
Advertised by the server during the last successful anonymous check.
Advertised read-only

Main menu (host/join/quit), lobby listing connected peers where only the host starts, in-game HUD reading replicated state. Pairs with gripforge_net_kit. 0 credits.

gripforge_menu_kit input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "prompt"
  ],
  "properties": {
    "prompt": {
      "type": "string",
      "maxLength": 240,
      "minLength": 2,
      "description": "e.g. tactical, minimal"
    }
  }
}
gripforge_menu_kit annotations
{
  "title": "Menu + lobby + HUD",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_bot_kit — Server-owned navmesh bots
Advertised by the server during the last successful anonymous check.
Advertised read-only

Navmesh bots as server-owned player scenes so spawner/synchronizer/net-kit damage apply unchanged. 0 credits.

gripforge_bot_kit input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "prompt"
  ],
  "properties": {
    "prompt": {
      "type": "string",
      "maxLength": 240,
      "minLength": 2,
      "description": "difficulty: easy, normal, hard"
    }
  }
}
gripforge_bot_kit annotations
{
  "title": "Server-owned navmesh bots",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_input_kit — Input maps and optional third-person character facing
Advertised by the server during the last successful anonymous check.
Advertised read-only

Godot InputMap for an FPS: move_forward/back/left/right bound to WASD AND arrow keys, plus jump/crouch/fire/reload/buy. Write res://gripforge/input.json and autoload GfInput (snippet_godot). Player still uses Input.is_action_pressed("move_*"). Optional third_person=true adds portable character-facing JavaScript: movement-facing, independent camera, aim/fire/build facing. Orientation only, not a physics controller. 0 credits.

gripforge_input_kit input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "prompt"
  ],
  "properties": {
    "prompt": {
      "type": "string",
      "maxLength": 240,
      "minLength": 2,
      "description": "e.g. \"fps\" or \"tactical bomb defusal\""
    },
    "third_person": {
      "type": "boolean",
      "description": "Include character-facing JavaScript (default false; existing input map unchanged)."
    }
  }
}
gripforge_input_kit annotations
{
  "title": "Input maps and character facing",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_light_kit — Scene lights + fog
Advertised by the server during the last successful anonymous check.
Advertised read-only

Moon / sun / candle point lights + fog + environment intensity for a game look, plus a Godot snippet. 0 credits. Does not generate meshes. Pair with scene_kit placements (candle tags match candelabra xyz).

gripforge_light_kit input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "prompt"
  ],
  "properties": {
    "prompt": {
      "type": "string",
      "maxLength": 240,
      "minLength": 2,
      "description": "e.g. \"stylish gothic action\""
    }
  }
}
gripforge_light_kit annotations
{
  "title": "Scene lights + fog",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_font — HUD webfont + rank copy
Advertised by the server during the last successful anonymous check.
Advertised read-only

Google-font CSS + exact HUD copy for a game look (stylish action: Cinzel D–SSS, kart: Teko, tactical FPS: Barlow Condensed). Put letters in HTML/Text nodes. Do NOT rasterize ranks, km/h, or HUD numbers with an image model. 0 credits.

gripforge_font input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "prompt"
  ],
  "properties": {
    "prompt": {
      "type": "string",
      "maxLength": 240,
      "minLength": 2,
      "description": "e.g. \"stylish gothic action\""
    }
  }
}
gripforge_font annotations
{
  "title": "HUD webfont + rank copy",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_loading_page — Game loading overlay
Advertised by the server during the last successful anonymous check.

Loading overlay for a game look. Returns html/css/js (web) plus engines.godot | unity | unreal. With project_id, action quote → accept → get → apply generates reviewed artwork via a persistent job and binds it to the game; creation_id and quote_token resume it. Title is text — do not rasterize. Overlay alone is 0 credits. Pass character_id (lib_… character/enemy/bind) to generate a cinematic 16:9 background still of that character (1 credit). No letters in the still.

gripforge_loading_page input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "prompt"
  ],
  "properties": {
    "action": {
      "enum": [
        "quote",
        "accept",
        "get",
        "apply"
      ],
      "type": "string"
    },
    "prompt": {
      "type": "string",
      "maxLength": 2000,
      "minLength": 2,
      "description": "e.g. \"stylish gothic action\""
    },
    "project_id": {
      "type": "string"
    },
    "creation_id": {
      "type": "string"
    },
    "quote_token": {
      "type": "string"
    },
    "character_id": {
      "type": "string",
      "description": "Library character / enemy / loadout bind id — generates background still (1 credit)"
    }
  }
}
gripforge_loading_page annotations
{
  "title": "Game loading overlay",
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_navmesh — Walkable floor JSON
Advertised by the server during the last successful anonymous check.
Advertised read-only

Walkable XZ AABB + circular holes (pillars) for a scene_kit room. JSON the engine clamps against — not a baked .navmesh. 0 credits.

gripforge_navmesh input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "prompt"
  ],
  "properties": {
    "prompt": {
      "type": "string",
      "maxLength": 240,
      "minLength": 2,
      "description": "e.g. \"stylish gothic action\""
    }
  }
}
gripforge_navmesh annotations
{
  "title": "Walkable floor JSON",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_vfx_generate — Text / image to editable VFX (admin)
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

ADMIN ONLY. Text-to-VFX or image-to-VFX: interpret a prompt or reference into an editable animated effect specification. No Library save or credit charge. Pass the resulting type, style, look, color, duration, width, name, emitters and generation to gripforge_vfx to save/export (1 credit). Image mode requires a configured vision provider.

gripforge_vfx_generate input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "preset": {
      "enum": [
        "slash-trail",
        "slash-emerald",
        "slash-steel",
        "slash-fire",
        "slash-ice",
        "slash-nature",
        "arc-pulse",
        "fire-breath",
        "neon-impact"
      ],
      "type": "string",
      "description": "Load a ready-to-play preset instantly, without AI. Supply this field alone."
    },
    "prompt": {
      "type": "string",
      "maxLength": 500,
      "description": "Effect description; optional with an image."
    },
    "image_id": {
      "type": "string",
      "description": "Owned Library image id; use instead of image_data."
    },
    "image_data": {
      "type": "string",
      "maxLength": 12582912,
      "description": "PNG/JPEG/WebP base64 data URI, up to 8 MB decoded."
    },
    "visual_style": {
      "enum": [
        "realistic",
        "stylized",
        "anime",
        "lowpoly"
      ],
      "type": "string"
    }
  }
}
gripforge_vfx_generate annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": false
}
gripforge_vfx — Strike VFX on an attach (admin)
Advertised by the server during the last successful anonymous check.
Open-world

ADMIN ONLY. Generate + export a 3D slash/thrust/spin VFX parented to an existing attach bind, or a world-space fire meteor (head + ribbon trail + impact). Pass prompt to fill type/style/color/emitters. Returns studio_url (open this link to edit the saved effect in GripForge), workspace_id, GLB, PNG and vfx.json. Refused for non-admin API keys.

gripforge_vfx input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "core": {
      "type": "number",
      "maximum": 0.4,
      "minimum": 0.02,
      "description": "portal only: shadow-core radius as a fraction of the portal (default 0.09)"
    },
    "look": {
      "enum": [
        "toon",
        "solid",
        "crystal",
        "flame",
        "pulse",
        "firejet",
        "impact"
      ],
      "type": "string",
      "description": "toon: stylized ribbon/lightning; solid: filled beam; crystal: faceted weapon trail; flame: burning crescent; pulse: released electric orb; firejet: flared fire stream with torn tongues and pressure rings; impact: slam-family comic explosion with red telegraph, violet core, ink debris and optional impact frames"
    },
    "name": {
      "type": "string",
      "maxLength": 80
    },
    "type": {
      "enum": [
        "slash",
        "thrust",
        "spin",
        "meteor",
        "beam",
        "swing",
        "claw",
        "charge",
        "shield",
        "portal",
        "slam"
      ],
      "type": "string",
      "description": "Strike type (default slash). portal = standing blood rift / demonic seal (world-space, loops); slam = ground-impact eruption: light pillar + fireball + sparks/debris (world-space, one-shot)"
    },
    "color": {
      "type": "string",
      "description": "Hex color"
    },
    "style": {
      "enum": [
        "energy",
        "metal",
        "magic"
      ],
      "type": "string",
      "description": "Look (default energy)"
    },
    "width": {
      "type": "number",
      "description": "Ribbon width in metres"
    },
    "prompt": {
      "type": "string",
      "description": "Natural-language VFX prompt. Fills type/style/color/emitters when omitted."
    },
    "duration": {
      "type": "number",
      "description": "Seconds (default 0.25)"
    },
    "emitters": {
      "type": "array",
      "items": {
        "type": "object",
        "propertyNames": {
          "type": "string"
        },
        "additionalProperties": {}
      },
      "maxItems": 6,
      "description": "Emitters returned by gripforge_vfx_generate."
    },
    "attach_id": {
      "type": "string",
      "description": "Library bind id (lib_…). Not required for meteor."
    },
    "generation": {
      "type": "object",
      "description": "Generation provenance returned by gripforge_vfx_generate.",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    }
  }
}
gripforge_vfx output schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "id": {
      "type": "string"
    },
    "vfx": {
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "urls": {
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "snippets": {
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {
        "type": "string"
      }
    },
    "studio_url": {
      "type": "string",
      "description": "Direct link to the saved effect in the GripForge VFX Studio; requires an authorized user session."
    },
    "workspace_id": {
      "type": "string"
    }
  },
  "additionalProperties": false
}
gripforge_vfx annotations
{
  "title": "Strike VFX on an attach (admin)",
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_vfx_preview — VFX timeline sample (admin)
Advertised by the server during the last successful anonymous check.
Advertised read-only

ADMIN ONLY. Play/scrub pose of a strike VFX at time t (seconds). t=0 is empty. No credits. Arc reveal / trail length / burst particles. Refused for non-admin keys.

gripforge_vfx_preview input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "bind"
  ],
  "properties": {
    "t": {
      "type": "number",
      "description": "Seconds on the timeline (default 0)"
    },
    "bind": {
      "type": "object",
      "description": "Attach bind.json object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    },
    "type": {
      "enum": [
        "slash",
        "thrust",
        "spin",
        "meteor",
        "beam",
        "swing",
        "claw",
        "charge",
        "shield"
      ],
      "type": "string"
    },
    "style": {
      "enum": [
        "energy",
        "metal",
        "magic"
      ],
      "type": "string"
    },
    "duration": {
      "type": "number"
    }
  }
}
gripforge_vfx_preview annotations
{
  "title": "VFX timeline sample (admin)",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_shaders — List shaders
Advertised by the server during the last successful anonymous check.
Advertised read-only

List shaders from the GripForge catalog (authorized GodotShaders.com mirror). Returns { id, name, engines }. Search q=slash_reveal. Then pull with gripforge_shader_pull. Free.

gripforge_shaders input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "properties": {
    "q": {
      "type": "string",
      "description": "Search id/name/alias (e.g. slash_reveal)"
    },
    "type": {
      "enum": [
        "canvas_item",
        "spatial",
        "sky",
        "particles",
        "fog"
      ],
      "type": "string",
      "description": "Godot shader_type"
    },
    "limit": {
      "type": "number",
      "description": "Page size (default 50, max 200)"
    },
    "offset": {
      "type": "number",
      "description": "Offset"
    }
  }
}
gripforge_shaders annotations
{
  "title": "List shaders",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
gripforge_shader_pull — Pull a shader
Advertised by the server during the last successful anonymous check.
Advertised read-only

Pull a catalog shader (id or alias like slash_reveal) for godot | unity. Three.js is no longer a supported target. Returns file contents + assignment snippet (Godot ShaderMaterial / Unity Material). This hosted endpoint cannot write into the working tree — use npx @gripforgeai/mcp gripforge_shader_pull with out_dir for that. v1 pull is free (no credit).

gripforge_shader_pull input schema
{
  "type": "object",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "required": [
    "id",
    "engine"
  ],
  "properties": {
    "id": {
      "type": "string",
      "description": "Shader id or alias (slash_reveal, …)"
    },
    "engine": {
      "enum": [
        "godot",
        "unity"
      ],
      "type": "string",
      "description": "Target engine"
    },
    "out_dir": {
      "type": "string",
      "description": "Suggested folder (hosted returns contents only; npm writes)"
    }
  }
}
gripforge_shader_pull annotations
{
  "title": "Pull a shader",
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}

Prompts

Not advertised

No prompt definitions available.

Resources

Not advertised

No resource definitions available.

30-day availability

Aggregated from read-only remote checks; this is not a tool-execution or security guarantee.

Successful checks
1 of 1 (100%)
Average latency
2613 ms
95th percentile latency
2613 ms

Maintenance history

Public check and source-refresh events. Editorial and ownership records remain private.

  • · probe · passed · 2613 ms · metadata changed · 241 tool(s)

Connect from your client

Each snippet registers the same endpoint; pick the client you use.

This server is operated by the named third party. Listing and endpoint checks are not an endorsement or a security audit. Review the operator's permissions, terms, and data handling before connecting. How listings are checked and corrected.

Claude Code

Run this once in a terminal. It registers the remote server. Use --scope project to write .mcp.json for the repo.
Claude Code configuration
claude mcp add --transport http gripforge-mcp https://gripforge.ai/mcp

Codex

Run this once. Codex stores MCP servers in ~/.codex/config.toml (or .codex/config.toml in a trusted project).
Codex configuration
codex mcp add gripforge-mcp --url https://gripforge.ai/mcp

Cursor

Merge this server into .cursor/mcp.json in your project, then enable gripforge-mcp in your MCP settings.
Cursor configuration
{
  "mcpServers": {
    "gripforge-mcp": {
      "url": "https://gripforge.ai/mcp"
    }
  }
}

Cline

Merge this into cline_mcp_settings.json (Cline → MCP Servers → Configure).
Cline configuration
{
  "mcpServers": {
    "gripforge-mcp": {
      "type": "streamableHttp",
      "url": "https://gripforge.ai/mcp",
      "disabled": false
    }
  }
}

VS Code

Merge this server into .vscode/mcp.json. Use MCP: List Servers to start gripforge-mcp and inspect its tools.
VS Code configuration
{
  "servers": {
    "gripforge-mcp": {
      "type": "http",
      "url": "https://gripforge.ai/mcp"
    }
  }
}

Gemini CLI

Run this once. It writes .gemini/settings.json in the current project; pass --scope user for ~/.gemini/settings.json.
Gemini CLI configuration
gemini mcp add --transport http gripforge-mcp https://gripforge.ai/mcp

Claude Desktop

Open Claude Settings > Connectors > Add custom connector, enter this server URL and enable it for the conversation. This is a manual remote-connector handoff, not a desktop JSON configuration.
Claude Desktop configuration
https://gripforge.ai/mcp

Windsurf

Merge this into ~/.codeium/windsurf/mcp_config.json, then refresh MCP in Cascade. Windsurf remote servers use serverUrl, not url.
Windsurf configuration
{
  "mcpServers": {
    "gripforge-mcp": {
      "serverUrl": "https://gripforge.ai/mcp"
    }
  }
}

Let your agent find its tools

Find servers like GripForge MCP from your agent. Add Koskamo once to search the index for endpoints, access requirements, and client setup. Public discovery needs no key.

Connect Koskamo Explore workflows
See all 8,313