@gripforgeai/mcp 0.1.10 → 0.1.12

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 GripForge
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -6,7 +6,87 @@ Turn prompts into production-ready game assets — animated characters with thei
 
 MCP client for the [GripForge](https://gripforge.ai) API — from Claude Code, Cursor, Windsurf, VS Code or any MCP client.
 
-## Hosted endpoint (zero install)
+## How to use
+
+**Hosted — nothing to install.** Point any remote-capable MCP client at `https://gripforge.ai/mcp`
+with your API key ([create one here](https://gripforge.ai/account)):
+
+```jsonc
+{
+  "mcpServers": {
+    "gripforge": {
+      "url": "https://gripforge.ai/mcp",
+      "headers": { "x-api-key": "gf_..." }
+    }
+  }
+}
+```
+
+**Claude Code**, in one line:
+
+```bash
+claude mcp add --transport http gripforge https://gripforge.ai/mcp --header "x-api-key: gf_..."
+```
+
+**Local, via npm** — when the agent must write files into your repository:
+
+```jsonc
+{
+  "mcpServers": {
+    "gripforge": {
+      "command": "npx",
+      "args": ["-y", "@gripforgeai/mcp"],
+      "env": { "GRIPFORGE_API_KEY": "gf_..." }
+    }
+  }
+}
+```
+
+## Key features
+
+- **Characters that move.** Describe one, get a rigged T-pose with an animation set — idle, run,
+  attack — ready to drop into a scene.
+- **Weapons in hand.** GripForge finds the hand bone on any rig, scales the prop, closes the fist
+  around the grip, and returns the bind plus Three.js, Unity and Godot snippets.
+- **Seamless textures.** Tileable material sets from a prompt or from your own image, upscaled
+  without invention.
+- **Terrain and maps.** Playable room graphs, top-down shooter layouts with spawns and lanes,
+  greybox reconstruction from references.
+- **VFX and HUD.** Animated effects and interface kits exported for your engine.
+- **Playable game kits.** Assemble modular capabilities — movement, combat, enemies, worlds — into
+  a game that runs in the browser, then bind your own assets to it.
+- **One Library.** Everything generated lands in a locker your engine can pull from, and that your
+  agent can search by look ("Devil May Cry like", "genshin").
+
+## Use cases
+
+- *"Attach this sword to my knight, right hand, then export the armed GLB."* — the agent handles the
+  bone, the scale and the fist; you get a file that loads.
+- *"Make me a boss for an ashen underworld, with three phases and an arena."* — stats, attacks and
+  engine snippets come back together.
+- *"Give this floor a mossy cobblestone texture that tiles."* — a seamless set, saved to the Library.
+- *"Build a playable roguelike slice I can try in the browser."* — a game kit project with its
+  assets bound, playable from a link.
+
+## FAQ
+
+**Do I need to install anything?** No. The hosted endpoint works from any MCP client that speaks
+streamable HTTP. The npm package exists for one reason: letting the agent write files directly into
+your repository.
+
+**Which engines are supported?** Unity, Godot, Unreal and Three.js — assets come with the binds and
+snippets each one expects.
+
+**How is it billed?** Credits, per generation. Reading the Library, animating an existing character,
+level and map kits cost nothing; generating a character or a weapon costs 10.
+
+**Where do my assets live?** In your workspace Library. You can pull them into your repository, push
+your own, and share them with the community catalog.
+
+**Can I use my own concept art?** Yes — pass an image and GripForge builds the T-pose sheet from it
+rather than inventing a character.
+
+## Hosted endpoint
 
 No Node required — point any remote-capable MCP client at:
 
@@ -85,7 +165,7 @@ Also works with Cursor, Windsurf and any MCP-compatible client — same
 `command` / `args` / `env` triple.
 
 
-## Tools
+## Tool reference
 
 Hosted HTTP MCP (`https://gripforge.ai/mcp`) is always current. This npm package
 writes files into the repo (`out_dir`), including `gripforge_hud`,

package/dist/ability-tools.js

@@ -0,0 +1,21 @@
+import { z } from 'zod/v4';
+export const ABILITY_TOOL_NAMES = ['gripforge_abilities'];
+export function registerAbilityTools(register, options, schema = z) {
+    const shape = { action: schema.enum(['schema', 'example', 'validate', 'export']), target: schema.enum(['threejs', 'godot', 'unity', 'unreal', 'all']).optional(), pack: schema.record(schema.string(), schema.unknown()).optional().describe('Versioned ability pack. Read schema/example first; author a reusable pack then validate it.'), model_asset: schema.string().regex(/^lib_[A-Za-z0-9_-]{8,64}$/).optional().describe('Library model id bound to the example. Does not rig or animate it.') };
+    register('gripforge_abilities', { title: 'Abilities / skills · four engines', description: 'combat.abilities: inspect schema, get an editable Chrono Crab example, validate a pack or export executable Three.js, 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.', inputSchema: shape, annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false } }, async (args) => {
+        const parsed = schema.object(shape).strict().safeParse(args);
+        if (!parsed.success)
+            return { isError: true, content: [{ type: 'text', text: parsed.error.message }] };
+        const key = options.getApiKey();
+        if (!key)
+            return { isError: true, content: [{ type: 'text', text: 'GripForge API key required.' }] };
+        try {
+            const response = await fetch(options.apiUrl.replace(/\/$/, '') + '/api/v1/abilities', { method: 'POST', headers: { 'content-type': 'application/json', 'x-api-key': key, 'x-gripforge-client': 'mcp' }, body: JSON.stringify(parsed.data), signal: AbortSignal.timeout(30000) });
+            const data = await response.json();
+            return { ...(!response.ok ? { isError: true } : {}), content: [{ type: 'text', text: JSON.stringify(data) }], structuredContent: data };
+        }
+        catch (e) {
+            return { isError: true, content: [{ type: 'text', text: e instanceof Error ? e.message : 'Ability request failed' }] };
+        }
+    });
+}

package/dist/architecture-tools.js

@@ -0,0 +1,83 @@
+import { z } from 'zod/v4';
+import { LOOK_DESCRIPTION, LOOK_VALUES } from './look.js';
+export const ARCHITECTURE_TOOL_NAMES = ['gripforge_architecture_schema', 'gripforge_generate_building', 'gripforge_generate_district', 'gripforge_environment_module'];
+/** Hosted and local MCP share the same recipe and durable server workflow. */
+export function registerArchitectureTools(register, options, schema = z) {
+    const identifier = schema.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9_.:-]{0,159}$/);
+    const ref = schema.object({ assetId: identifier, revisionId: identifier, fileRole: identifier.optional() }).strict();
+    const building = schema.object({
+        id: schema.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9_-]{0,47}$/).optional(),
+        name: schema.string().min(1).max(100).optional(), prompt: schema.string().min(3).max(300),
+        style: schema.enum(['realistic', 'stylized', 'lowpoly', 'handpainted']).optional(),
+        look: schema.enum(LOOK_VALUES).optional().describe(`${LOOK_DESCRIPTION} Fills style when style is omitted; toon, anime and pixel add their phrase to the prompt.`),
+        use: schema.enum(['residential', 'retail', 'office', 'industrial', 'mixed']).optional(),
+        floors: schema.number().int().min(1).max(30).optional(),
+        dimensions: schema.object({ width: schema.number().min(3).max(100).optional(), depth: schema.number().min(3).max(100).optional(), height: schema.number().min(3).max(150).optional() }).strict().optional().describe('Maximum footprint and height in metres. Uniform fit preserves proportions; actual dimensions are returned.'),
+        roof: schema.enum(['flat', 'pitched']).optional(), facade: schema.string().max(120).optional(),
+        polycount: schema.number().int().min(4000).max(80000).optional(),
+        concept: ref.optional().describe('Owned PNG/JPEG/WebP revision for Meshy image-to-3D. At most 12 MiB. Mutually exclusive with source.'),
+        concepts: schema.array(ref).min(1).max(4).optional().describe('Coherent views of ONE building, front first, for Meshy multi-image-to-3D. Exclusive with concept/source. Review coherence before building.'),
+        meshQuality: schema.object({ geometry: schema.enum(['standard', '2k', '4k']).optional(), texture: schema.enum(['2k', '4k', '8k']).optional() }).strict().optional().describe('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.'),
+        source: ref.optional().describe('Reuse an owned static GLB revision instead of paying for this building. The source is never modified.'),
+    }).strict();
+    const material = schema.record(schema.string(), schema.unknown()).describe('SceneMaterialOverride: color, roughness, metalness, map/normalMap/roughnessMap/metalnessMap as owned immutable SceneAssetRef, repeat:[u,v]. Validated by the shared Scene Engine.');
+    const district = schema.object({
+        version: schema.literal(1).optional(), name: schema.string().min(1).max(100).optional(),
+        buildings: schema.array(building).min(1).max(8).describe('Unique building definitions with distinct ids. Each new model is manufactured once.'),
+        repetitions: schema.number().int().min(1).max(4).optional().describe('Instances per definition, without additional model generation cost.'),
+        streetWidth: schema.number().min(6).max(30).optional(), sidewalkWidth: schema.number().min(1).max(8).optional(), gap: schema.number().min(1).max(30).optional(),
+        materials: schema.object({ road: material.optional(), sidewalk: material.optional() }).strict().optional(),
+    }).strict();
+    const shared = {
+        stage: schema.enum(['plan', 'build']).optional().describe('Default plan is free and does not generate. Read its quote, then explicitly build.'),
+        budget: schema.object({ credits: schema.number().nonnegative().optional(), usd: schema.number().nonnegative().optional() }).strict().optional().describe('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.'),
+        workspace_id: schema.string().max(100).optional(),
+        idempotency_key: schema.string().regex(/^[a-zA-Z0-9_.:-]{8,160}$/).optional(),
+    };
+    const moduleRecipe = schema.object({
+        module: schema.enum(['pillar', 'arch', 'fountain', 'stairs', 'wall', 'pavement', 'rock', 'cliff', 'ruin', 'bridge', 'watchtower', 'shrine', 'guardian']),
+        width: schema.number().min(.3).max(40).optional(), depth: schema.number().min(.3).max(40).optional(), height: schema.number().min(.05).max(20).optional(),
+        seed: schema.number().int().min(0).max(2147483646).optional(),
+        pattern: schema.enum(['radial', 'botanical']).optional().describe('Pavement only: botanical adds a broad leaf rosette inlay, radial keeps the original restrained rings.'),
+        palette: schema.object({ stone: schema.string().regex(/^#[0-9a-f]{6}$/i).optional(), recess: schema.string().regex(/^#[0-9a-f]{6}$/i).optional(), trim: schema.string().regex(/^#[0-9a-f]{6}$/i).optional(), water: schema.string().regex(/^#[0-9a-f]{6}$/i).optional() }).strict().optional(),
+    }).strict();
+    const definitions = [
+        { name: ARCHITECTURE_TOOL_NAMES[0], kind: 'schema', shape: {}, title: 'Architecture · schema', description: 'Read the reusable Meshy building and district contract, example, limits and plan → build workflow. Separate immutable Library assets, scene instances and shared SceneDocument. No paid generation.' },
+        { name: ARCHITECTURE_TOOL_NAMES[1], kind: 'building', shape: { ...shared, recipe: building,
+                stage: schema.enum(['plan', 'concept', 'build']).optional().describe('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.'),
+                concept_provider: schema.enum(['openai', 'xai']).optional().describe('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_presentation: schema.enum(['scene', 'isolated']).optional().describe('Default scene: artistic concept in its neighbourhood preserving the user atmosphere and lighting. isolated: technical views of the SAME building for Meshy. Keep rich architectural detail in both.'),
+                concept_reference: ref.optional().describe('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.'),
+                concept_views: schema.array(schema.enum(['front_right', 'front_left', 'rear_right', 'rear_left'])).min(1).max(4).optional().describe('Unique views starting with front_right. Default one view for scene, three for isolated. Alternate views edit the SAME master. recipe.concept reuses an existing master; concept_reference guides a NEW master.'),
+            }, title: 'Generate a building', description: 'Reusable plan → artistic concept → isolated reference views → review → Meshy build workflow. Generate 1–4 coherent images through OpenAI (1536×1024 high quality, default) or Imagine (2K), saved as private Library drafts; alternate views reference one master. Separate explicit budgets for concepts and 3D. Accepts text, owned single/multiple concept views or an owned static GLB. Meshy PBR/geometry quality, bounded geometry and uniform metric fit. Durable jobs return workspace links; poll generation_read, cancel/retry preserves finished steps. Review images before building and the real Studio render before publishing. No guaranteed interiors, collisions or LODs. Never substitutes procedural geometry or automatically replaces a game asset.' },
+        { name: ARCHITECTURE_TOOL_NAMES[2], kind: 'district', shape: { ...shared, recipe: district }, title: 'Generate a district', description: 'Plan then build a straight-street district from 1–8 distinct Meshy 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.' },
+        { name: ARCHITECTURE_TOOL_NAMES[3], kind: 'module', shape: { stage: schema.enum(['inspect', 'build']).optional(), recipe: moduleRecipe, name: schema.string().min(1).max(100).optional(), workspace_id: schema.string().max(100).optional() }, title: 'Create a reusable environment module', description: '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.' },
+    ];
+    for (const tool of definitions)
+        register(tool.name, { title: tool.title, description: tool.description, inputSchema: tool.shape,
+            annotations: { readOnlyHint: tool.kind === 'schema', destructiveHint: false, idempotentHint: tool.kind === 'schema', openWorldHint: tool.kind !== 'schema' } }, async (args, extra) => {
+            const parsed = schema.object(tool.shape).strict().safeParse(args);
+            if (!parsed.success)
+                return { isError: true, content: [{ type: 'text', text: parsed.error.message }] };
+            const key = options.getApiKey();
+            if (!key && tool.kind !== 'schema')
+                return { isError: true, content: [{ type: 'text', text: 'GripForge API key required.' }] };
+            const { workspace_id, ...body } = parsed.data;
+            try {
+                const response = await fetch(options.apiUrl.replace(/\/$/, '') + (tool.kind === 'module' ? '/api/v1/environment-modules' : '/api/v1/architecture'), {
+                    method: tool.kind === 'schema' ? 'GET' : 'POST',
+                    headers: { 'content-type': 'application/json', 'x-gripforge-client': 'mcp', ...(key ? { 'x-api-key': key } : {}), ...(typeof workspace_id === 'string' ? { 'x-workspace-id': workspace_id } : {}) },
+                    ...(tool.kind === 'schema' ? {} : { body: JSON.stringify(tool.kind === 'module' ? body : { ...body, kind: tool.kind }) }),
+                    signal: AbortSignal.any([AbortSignal.timeout(60_000), ...(extra?.signal ? [extra.signal] : [])]),
+                });
+                const data = await response.json();
+                for (const field of ['studio_url', 'status_url'])
+                    if (typeof data[field] === 'string' && data[field].startsWith('/'))
+                        data[field] = new URL(data[field], options.apiUrl).href;
+                return { ...(!response.ok ? { isError: true } : {}), structuredContent: data, content: [{ type: 'text', text: JSON.stringify(data) }] };
+            }
+            catch (error) {
+                return { isError: true, content: [{ type: 'text', text: error instanceof Error ? error.message : 'Architecture request failed.' }] };
+            }
+        });
+}

package/dist/asset-production-tools.js

@@ -0,0 +1,101 @@
+import { z } from 'zod/v4';
+/** Shared hosted/npm contract: assets are discovered independently of game modules. */
+export function registerAssetProductionTools(register, options, schema = z) {
+    const origin = options.apiUrl.replace(/\/$/, '');
+    const workspace = schema.string().max(100).optional().describe('Authorized workspace; defaults to the connected workspace.');
+    const result = (data) => ({ content: [{ type: 'text', text: JSON.stringify(data, null, 2) }], structuredContent: data });
+    async function request(path, workspaceId, method = 'GET', body) {
+        const key = options.getApiKey();
+        if (!key)
+            throw Error('GripForge API key required.');
+        const response = await fetch(origin + '/api/v1/' + path, { method, headers: { 'x-api-key': key, 'x-gripforge-client': 'mcp', ...(body ? { 'content-type': 'application/json' } : {}), ...(typeof workspaceId === 'string' ? { 'x-workspace-id': workspaceId } : {}) }, ...(body ? { body: JSON.stringify(body) } : {}), signal: AbortSignal.timeout(60000) });
+        const data = await response.json();
+        if (!response.ok)
+            throw Error(String(data.error ?? `HTTP ${response.status}`));
+        return data;
+    }
+    const wrap = (run) => async (args) => {
+        try {
+            return result(await run(args));
+        }
+        catch (e) {
+            return { isError: true, content: [{ type: 'text', text: e instanceof Error ? e.message : String(e) }] };
+        }
+    };
+    register('gripforge_generate_weapon_catalog', {
+        title: 'Generate a weapon catalogue',
+        description: '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.',
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
+        inputSchema: {
+            stage: schema.enum(['plan', 'build']), workspace_id: workspace,
+            entries: schema.array(schema.object({ key: schema.string().regex(/^[a-z0-9][a-z0-9_-]{0,47}$/), name: schema.string().min(1).max(160), prompt: schema.string().min(3).max(600), subtype: schema.string().min(1).max(60), style: schema.enum(['gun', 'melee', 'shield', 'staff']).optional(), polycount: schema.number().int().min(500).max(20000).optional(), tags: schema.array(schema.string().min(1).max(60)).max(16).optional() }).strict()).min(1).max(64),
+            plan_hash: schema.string().regex(/^[a-f0-9]{64}$/).optional(),
+            budget: schema.object({ credits: schema.number().nonnegative().optional(), usd: schema.number().nonnegative().optional() }).strict().optional(),
+            idempotency_key: schema.string().regex(/^[a-zA-Z0-9_.:-]{8,160}$/).optional(),
+        },
+    }, wrap(args => request('weapons/catalog', args.workspace_id, 'POST', args)));
+    register('gripforge_generation_quote', {
+        title: 'Estimate generation usage before spending',
+        description: '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.',
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+        inputSchema: { kind: schema.enum(['model', 'concept', 'texture', 'rig', 'animation']), provider: schema.enum(['meshy', 'tripo', 'xai', 'openai']).optional(), count: schema.number().int().min(1).max(20).optional(), workspace_id: workspace },
+    }, wrap(args => {
+        const params = new URLSearchParams({ kind: String(args.kind), count: String(args.count ?? 1) });
+        if (args.provider)
+            params.set('provider', String(args.provider));
+        return request(`generation-quote?${params}`, args.workspace_id);
+    }));
+    register('gripforge_asset_search', {
+        title: 'Search workspace and Community assets',
+        description: '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.',
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+        inputSchema: {
+            q: schema.string().max(200).describe('Visual role or style, e.g. sci-fi turret, rock, soldier.'),
+            kind: schema.enum(['character', 'fps-arms', 'enemy', 'weapon', 'equipment', 'prop', 'texture', 'skybox', 'vfx', 'animation', 'audio', 'kit']).optional().describe('Optional asset kind.'),
+            source: schema.enum(['workspace', 'community', 'both']).optional().describe('Defaults to both.'),
+            limit: schema.number().int().min(1).max(48).optional().describe('Results per source; default 12.'),
+            offset: schema.number().int().min(0).max(10000).optional().describe('Pagination offset per source; default 0.'),
+            target: schema.enum(['mobile', 'desktop']).optional().describe('Platform the game ships on: sets the triangle and file budgets of the rank. Defaults to mobile.'),
+            sort: schema.enum(['rank', 'newest']).optional().describe('rank (default): best fit first; newest: most recent first.'),
+            workspace_id: workspace,
+        },
+    }, wrap(async (args) => {
+        const limit = Number(args.limit ?? 12), offset = Number(args.offset ?? 0);
+        const target = args.target === 'desktop' ? 'desktop' : 'mobile';
+        const qs = new URLSearchParams({ q: String(args.q ?? ''), limit: String(limit), offset: String(offset), sort: args.sort === 'newest' ? 'newest' : 'rank', target });
+        if (args.kind)
+            qs.set('kind', String(args.kind));
+        const sources = args.source === 'workspace' ? ['workspace'] : args.source === 'community' ? ['community'] : ['workspace', 'community'];
+        const data = await Promise.all(sources.map(async (source) => {
+            const response = await request(`${source === 'workspace' ? 'library' : 'community'}?${qs}`, args.workspace_id);
+            const items = (Array.isArray(response.items) ? response.items : []).slice(0, limit);
+            return { source, total: response.total ?? items.length, items: items.map(item => {
+                    const meta = (item.meta && typeof item.meta === 'object' ? item.meta : {});
+                    const rank = (item.rank && typeof item.rank === 'object' ? item.rank : null);
+                    return { id: item.id, name: item.name, kind: item.kind, filename: item.filename, source,
+                        score: rank?.score ?? null, grade: rank?.grade ?? null, reasons: (rank?.reasons ?? []).slice(0, 5).map(r => `${r.points > 0 ? '+' : ''}${r.points} ${r.note}`),
+                        triangles: meta.triangles, tags: meta.tags, rigged: meta.rigged, placeholder: meta.placeholder === true || /proxy_|volume de travail/i.test(String(item.filename) + ' ' + String(item.name)),
+                        next: source === 'community' ? 'gripforge_asset_clone, then gripforge_library_pull' : 'gripforge_library_get / gripforge_library_pull',
+                    };
+                }) };
+        }));
+        // The top pick across sources; a workspace copy wins a tie (no credit to take it).
+        const best = data.flatMap(d => d.items).filter(i => typeof i.score === 'number' && !i.placeholder)
+            .sort((a, b) => b.score - a.score || (a.source === 'workspace' ? -1 : 1))[0] ?? null;
+        return { target, best, results: data, note: 'Ranked for a GripForge game (see reasons). Inspect suitability and textures/animations before importing. Downloads alone are not runtime integration.' };
+    }));
+    register('gripforge_asset_clone', {
+        title: 'Copy a Community asset to the workspace',
+        description: '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.',
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
+        inputSchema: { id: schema.string().regex(/^lib_[A-Za-z0-9_-]+$/).describe('Published Community Library id.'), workspace_id: workspace },
+    }, wrap(args => request(`community/${encodeURIComponent(String(args.id))}/clone`, args.workspace_id, 'POST')));
+}
+/** 202 response: do not strip job ids or misrepresent a queued model as a Library item. */
+export function assetGenerationOutput(schema = z) {
+    return schema.object({
+        job: schema.string().optional(), job_id: schema.string().optional(), status: schema.string().optional(), stage: schema.string().optional(),
+        status_url: schema.string().optional(), studio_url: schema.string().optional(), library_url: schema.string().optional(),
+        item: schema.record(schema.string(), schema.unknown()).optional(), provider: schema.string().optional(), notes: schema.array(schema.string()).optional(),
+    }).passthrough();
+}

package/dist/creature-rig-tools.js

@@ -0,0 +1,41 @@
+import { z } from 'zod/v4';
+export const CREATURE_RIG_TOOL_NAMES = ['gripforge_creature_rig_schema', 'gripforge_creature_analyze', 'gripforge_creature_rig'];
+/** Same contract for hosted MCP and the local client; Blender runs in the durable worker. */
+export function registerCreatureRigTools(register, options, schema = z) {
+    const shared = { workspace_id: schema.string().max(100).optional(), name: schema.string().min(1).max(100).optional(), idempotency_key: schema.string().regex(/^[a-zA-Z0-9_.:-]{8,160}$/).optional() };
+    const analyze = { ...shared, source_id: schema.string().regex(/^lib_[A-Za-z0-9_-]{8,64}$/), kind: schema.enum(['enemy', 'character']).optional() };
+    const rig = { ...shared, analysis_job: schema.string().regex(/^gen_[A-Za-z0-9_-]{8,64}$/), profile: schema.record(schema.string(), schema.unknown()).optional().describe('Optional corrected anatomy in the exact coordinate system returned by analyze. Read the schema and inspect the multiview preview first.'), reviewed_anatomy: schema.boolean().optional().describe('Required: true only after inspecting/correcting the anatomy and its skeleton overlay.'), allow_rerig: schema.boolean().optional().describe('Explicitly create a NEW rigged copy if the source already contains bones. The source is never overwritten.') };
+    async function call(action, args, signal) {
+        const key = options.getApiKey();
+        if (!key && action !== 'schema')
+            return { isError: true, content: [{ type: 'text', text: 'GripForge API key required.' }] };
+        const { workspace_id, ...body } = args;
+        try {
+            const response = await fetch(options.apiUrl.replace(/\/$/, '') + '/api/v1/creature-rigs', {
+                method: action === 'schema' ? 'GET' : 'POST', headers: { 'content-type': 'application/json', 'x-gripforge-client': 'mcp', ...(key ? { 'x-api-key': key } : {}), ...(typeof workspace_id === 'string' ? { 'x-workspace-id': workspace_id } : {}) },
+                ...(action === 'schema' ? {} : { body: JSON.stringify({ action, ...body }) }), signal: AbortSignal.any([AbortSignal.timeout(60_000), ...(signal ? [signal] : [])]),
+            });
+            const data = await response.json();
+            for (const field of ['studio_url', 'status_url'])
+                if (typeof data[field] === 'string' && data[field].startsWith('/'))
+                    data[field] = new URL(data[field], options.apiUrl).href;
+            return { ...(!response.ok ? { isError: true } : {}), structuredContent: data, content: [{ type: 'text', text: JSON.stringify(data) }] };
+        }
+        catch (error) {
+            return { isError: true, content: [{ type: 'text', text: error instanceof Error ? error.message : 'Creature rig request failed.' }] };
+        }
+    }
+    const tools = [
+        { name: CREATURE_RIG_TOOL_NAMES[0], action: 'schema', title: 'Creature rig · schema', shape: {}, description: '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.' },
+        { name: CREATURE_RIG_TOOL_NAMES[1], action: 'analyze', title: 'Creature rig · detect anatomy', shape: analyze, description: '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.' },
+        { name: CREATURE_RIG_TOOL_NAMES[2], action: 'rig', title: 'Creature rig · manufacture', shape: rig, description: '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.' },
+    ];
+    for (const tool of tools)
+        register(tool.name, { title: tool.title, description: tool.description, inputSchema: tool.shape,
+            annotations: { readOnlyHint: tool.action === 'schema', destructiveHint: false, idempotentHint: tool.action === 'schema', openWorldHint: false } }, async (args, extra) => {
+            const parsed = schema.object(tool.shape).strict().safeParse(args);
+            if (!parsed.success)
+                return { isError: true, content: [{ type: 'text', text: parsed.error.message }] };
+            return call(tool.action, parsed.data, extra?.signal);
+        });
+}

package/dist/game-concept-tools.js

@@ -0,0 +1,56 @@
+import { z } from 'zod/v4';
+export const GAME_CONCEPT_TOOL_NAMES = ['gripforge_game_concepts'];
+const SLOTS = ['heroes', 'bosses', 'enemies', 'npcs', 'weapons', 'vehicles', 'buildings', 'props', 'textures', 'vfx', 'maps'];
+/**
+ * Concepts of a whole game, reused before generated. Hosted and local MCP share the same REST
+ * workflow: GET the catalog, POST stage=plan (free), then stage=build with an explicit budget.
+ */
+export function registerGameConceptTools(register, options, schema = z) {
+    const counts = schema.object(Object.fromEntries(SLOTS.map((s) => [s, schema.number().int().min(0).max(96).optional()]))).strict();
+    const shape = {
+        stage: schema.enum(['catalog', 'plan', 'build']).optional().describe('catalog: known games, blueprints (slot counts) and theme packs. plan (default, free): what already exists and is reused, what would be generated, and the price. build: generate the missing concepts, requires budget.'),
+        game: schema.string().min(2).max(120).optional().describe('The game the user named, as written ("God of War", "like Dark Souls", "a GTA"). Matched against titles and aliases of the catalog.'),
+        custom: schema.object({
+            title: schema.string().min(2).max(80),
+            blueprint: schema.string().max(60).describe('Closest blueprint from stage=catalog, e.g. third-person-action, open-world-rpg.'),
+            pack: schema.string().max(60).describe('Closest theme pack from stage=catalog, e.g. nordic-mythology, cyberpunk.'),
+            build: schema.string().min(10).max(300).describe('One sentence describing the original game to make.'),
+        }).strict().optional().describe('Only when `game` is not in the catalog: describe the game with the closest blueprint and pack.'),
+        counts: counts.optional().describe('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.'),
+        hero_kits: schema.boolean().optional().describe('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).'),
+        provider: schema.enum(['openai', 'xai']).optional().describe('Default openai (GPT Image 2.5 sunburst: final quality for style bible, heroes and bosses, medium-quality sheets of 6 for the rest).'),
+        budget: schema.object({ credits: schema.number().nonnegative().optional(), usd: schema.number().nonnegative().optional() }).strict().optional().describe('Required for build: maximum credits OR USD, at least the plan price.'),
+        workspace_id: schema.string().max(100).optional(),
+        idempotency_key: schema.string().regex(/^[a-zA-Z0-9_.:-]{8,160}$/).optional(),
+    };
+    register(GAME_CONCEPT_TOOL_NAMES[0], {
+        title: 'Game concepts',
+        description: 'Concept art for a whole game, reused before generated. Use it when a user asks for a game "like God of War", "a GTA", "a Zelda": call stage=plan with the game they named. 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.',
+        inputSchema: shape,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
+    }, async (args, extra) => {
+        const parsed = schema.object(shape).strict().safeParse(args);
+        if (!parsed.success)
+            return { isError: true, content: [{ type: 'text', text: parsed.error.message }] };
+        const key = options.getApiKey();
+        const { workspace_id, stage = 'plan', ...body } = parsed.data;
+        if (!key && stage !== 'catalog')
+            return { isError: true, content: [{ type: 'text', text: 'GripForge API key required.' }] };
+        try {
+            const response = await fetch(options.apiUrl.replace(/\/$/, '') + '/api/v1/game-concepts', {
+                method: stage === 'catalog' ? 'GET' : 'POST',
+                headers: { 'content-type': 'application/json', 'x-gripforge-client': 'mcp', ...(key ? { 'x-api-key': key } : {}), ...(typeof workspace_id === 'string' ? { 'x-workspace-id': workspace_id } : {}) },
+                ...(stage === 'catalog' ? {} : { body: JSON.stringify({ ...body, stage }) }),
+                signal: AbortSignal.any([AbortSignal.timeout(60_000), ...(extra?.signal ? [extra.signal] : [])]),
+            });
+            const data = await response.json();
+            for (const field of ['studio_url', 'status_url'])
+                if (typeof data[field] === 'string' && data[field].startsWith('/'))
+                    data[field] = new URL(data[field], options.apiUrl).href;
+            return { ...(!response.ok ? { isError: true } : {}), structuredContent: data, content: [{ type: 'text', text: JSON.stringify(data) }] };
+        }
+        catch (error) {
+            return { isError: true, content: [{ type: 'text', text: error instanceof Error ? error.message : 'Game concepts request failed.' }] };
+        }
+    });
+}

package/dist/game-creation-tools.js

@@ -0,0 +1,45 @@
+import { z } from 'zod/v4';
+export const GAME_CREATION_TOOL_NAMES = ['gripforge_game_creation'];
+export function registerGameCreationTools(register, options, schema = z) {
+    const shape = {
+        action: schema.enum(['list', 'get', 'assets', 'create', 'select', 'use_reference', 'approve_concept', 'approve_asset', 'quote', 'accept', 'cancel', 'retry', 'dismiss']),
+        id: schema.string().max(100).optional(), workspace_id: schema.string().max(100).optional(),
+        expected_revision: schema.number().int().positive().optional(), prompt: schema.string().max(2000).optional(),
+        engine: schema.enum(['web', 'unity', 'godot', 'unreal']).optional(), slot_id: schema.string().max(100).optional(),
+        mode: schema.enum(['select', 'generate', 'default']).optional(), asset_id: schema.string().max(100).optional(),
+        operation: schema.enum(['plan', 'refine', 'concept', 'generate', 'build']).optional(), quote_token: schema.string().max(100).optional(),
+        message: schema.string().trim().min(3).max(1500).optional(), allow_incomplete: schema.boolean().optional(),
+        source: schema.enum(['all', 'workspace', 'community']).optional(), q: schema.string().max(100).optional(),
+    };
+    register(GAME_CREATION_TOOL_NAMES[0], {
+        title: 'Prepare and resume a game',
+        description: 'The website and CLI share this saved 3D game creation workflow. Ask which engine (Unity, Godot, Unreal, Three.js) if unspecified; do not choose silently. create saves a brief without spending. quote(operation=plan) estimates AI preparation, 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. Assembly is a foundation, not a completed custom game: use the coding agent to finish those tasks on the selected engine (including web/Three.js). 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 compatible workspace/community items ranked by the brief and role; 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, show the model in its studio, 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, without generating extra assets. With explicit allow_incomplete=true on the build quote, unreviewed models are excluded and missing slots use module defaults where available or remain empty. 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. Cancel/retry preserve completed steps. 2D unsupported. No automatic spending, invented asset IDs, or unrelated template substitutions.',
+        inputSchema: shape, annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
+    }, async (args, extra) => {
+        const parsed = schema.object(shape).strict().safeParse(args);
+        if (!parsed.success)
+            return { isError: true, content: [{ type: 'text', text: parsed.error.message }] };
+        const key = options.getApiKey();
+        if (!key)
+            return { isError: true, content: [{ type: 'text', text: 'GripForge login required.' }] };
+        const { workspace_id, ...body } = parsed.data;
+        const read = ['list', 'get', 'assets'].includes(body.action);
+        const url = new URL('/api/v1/game-creations', options.apiUrl);
+        if (read)
+            for (const [k, v] of Object.entries(body))
+                if (v !== undefined)
+                    url.searchParams.set(k, String(v));
+        try {
+            const response = await fetch(url, { method: read ? 'GET' : 'POST',
+                headers: { 'content-type': 'application/json', 'x-api-key': key, 'x-gripforge-client': 'mcp', ...(workspace_id ? { 'x-workspace-id': workspace_id } : {}) },
+                ...(read ? {} : { body: JSON.stringify(body) }), signal: AbortSignal.any([AbortSignal.timeout(60_000), ...(extra?.signal ? [extra.signal] : [])]) });
+            const data = await response.json();
+            if (typeof data.studio_url === 'string')
+                data.studio_url = new URL(data.studio_url, options.apiUrl).href;
+            return { ...(!response.ok ? { isError: true } : {}), structuredContent: data, content: [{ type: 'text', text: JSON.stringify(data) }] };
+        }
+        catch (error) {
+            return { isError: true, content: [{ type: 'text', text: error instanceof Error ? error.message : 'Creation request failed.' }] };
+        }
+    });
+}

package/dist/gamekit-deliver-local.js

@@ -19,8 +19,9 @@ export const GAMEKIT_LOCAL_TOOL_NAMES = ['gripforge_gamekit_deliver_local', 'gri
 const LOCK_PATH = 'gripforge/gamekits.lock.json';
 const PREV_LOCK_PATH = 'gripforge/gamekits.lock.prev.json';
 const BACKUP_DIR = 'gripforge/.backup';
-const SCAN_ROOTS = ['gripforge', 'assets/gripforge'];
-const GODOT_ROOTS = ['gripforge/', 'assets/gripforge/'];
+const SCAN_ROOTS = ['gripforge', 'assets/gripforge', 'addons/gripforge_gameplay', 'addons/gripforge_net'];
+/** Godot: the kits, bound assets, and the GripForge addons (gameplay core, network transport) the delivery owns. */
+const GODOT_ROOTS = ['gripforge/', 'assets/gripforge/', 'addons/gripforge_gameplay/', 'addons/gripforge_net/'];
 const MAX_FILES = 5000;
 const MAX_BINARY_BYTES = 256 * 1024 * 1024;
 const DERIVED = ['.uid', '.import'];
@@ -67,7 +68,7 @@ function projectPath(dir, rel, opts) {
     if (!norm.startsWith(`${BACKUP_DIR}/`) && segments.some((s) => s.startsWith('.')))
         throw new LocalError('forbidden_path', `${what} ${rel} has a hidden segment`, { path: rel });
     if (opts.godot && !GODOT_ROOTS.some((root) => norm.startsWith(root)))
-        throw new LocalError('forbidden_path', `${what} ${rel} is outside gripforge/ and assets/gripforge/`, { path: rel });
+        throw new LocalError('forbidden_path', `${what} ${rel} is outside gripforge/, assets/gripforge/ and the GripForge addons`, { path: rel });
     const absolute = resolve(dir, ...segments);
     const back = relative(dir, absolute);
     if (!back || back.startsWith('..') || isAbsolute(back))
@@ -423,14 +424,13 @@ export function registerGameKitLocalTools(register, options, schema = z) {
     }
     register('gripforge_gamekit_deliver_local', {
         title: 'Deliver Game Kits into a local engine project',
-        description: 'npm client only. Deliver Game Kits straight into an engine project folder on this machine: hashes project_dir/gripforge/**, reads gripforge/gamekits.lock.json, asks the GripForge API for the plan, then executes plan.actions with fs — every overwritten or deleted file is copied to gripforge/.backup/<plan id>/ first and the lock is written last. Paths are checked inside project_dir (Godot: gripforge/ and assets/gripforge/ only) and every hash is verified before anything is written. Run dry_run=true first. A blocked plan (conflicts, breaking update) returns the conflicts without touching files: re-run with force or accept_breaking. verify=true runs Godot headless (import, then each kit smoke.gd) when GODOT_BIN is set. Undo with gripforge_gamekit_rollback_local. Credits: the first delivery of a kit major version to an engine costs 1 credit per workspace; re-deliveries, updates within a major and dry runs are free.',
+        description: 'npm client only. Deliver Game Kits straight into an engine project folder on this machine: hashes project_dir/gripforge/**, reads gripforge/gamekits.lock.json, asks the GripForge API for the plan, then executes plan.actions with fs — every overwritten or deleted file is copied to gripforge/.backup/<plan id>/ first and the lock is written last. Paths are checked inside project_dir (Godot: gripforge/, assets/gripforge/ and addons/gripforge_gameplay|gripforge_net only) and every hash is verified before anything is written. Run dry_run=true first. A blocked plan (files edited in the project) returns the conflicts without touching files: re-run with force to back them up and overwrite. Kits always deliver at their latest version. verify=true runs Godot headless (import, then each kit smoke.gd) when GODOT_BIN is set. Undo with gripforge_gamekit_rollback_local. Credits: the first delivery of a kit major version to an engine costs 1 credit per workspace; re-deliveries, updates within a major and dry runs are free.',
         inputSchema: {
             project_dir: projectDirField,
             target: schema.enum(TARGETS).optional().describe('Engine of the project: godot (default), unity or unreal.'),
             kits: schema
                 .array(schema.object({
                 id: kitId,
-                version: schema.string().max(40).optional().describe('Exact version; only the latest is deliverable.'),
                 config: schema.record(schema.string(), schema.unknown()).optional().describe('Kit config, validated against its configSchema.'),
                 bindings: schema.record(schema.string(), schema.string()).optional().describe('Asset slot → Library item id (lib_…).'),
             }))
@@ -441,7 +441,6 @@ export function registerGameKitLocalTools(register, options, schema = z) {
             mode: schema.enum(['install', 'update', 'uninstall']).optional().describe('install (default), update to the latest catalogue version, or uninstall (uses the lock).'),
             dry_run: schema.boolean().optional().describe('true → plan only; nothing is written or charged.'),
             force: schema.boolean().optional().describe('true → back up then overwrite edited managed files and existing seed files.'),
-            accept_breaking: schema.boolean().optional().describe('true → allow a breaking (major) update.'),
             verify: schema.boolean().optional().describe('true → after writing, run Godot headless (import + smoke.gd per kit) when GODOT_BIN is set.'),
             ...workspace,
         },
@@ -477,7 +476,6 @@ export function registerGameKitLocalTools(register, options, schema = z) {
                 project: { target, ...(engineVersion ? { engineVersion } : {}), lock, files },
                 dryRun,
                 force: args.force === true,
-                acceptBreaking: args.accept_breaking === true,
             }, typeof args.workspace_id === 'string' ? args.workspace_id : undefined, extra?.signal);
             if (status >= 400)
                 return toolResult({ ...context, applied: false, error: data.error ?? `HTTP ${status}`, code: data.code ?? 'http_error', details: data.details ?? {}, plan: planView(data.plan) }, true);