DCC tools¶

Design-app bridge: run scripts in Blender (and other apps), convert, generate and live sessions.

15 tools in the dcc category. Badges: read-only tools never change the project; mutating tools are undoable and attributed; open-world tools reach outside the engine and MCP clients ask before running them.

Tool	Summary
`dcc_list`	Which professional design apps are installed on this computer and what the bridge can do with them: Blender (fully supported and tested), plus Maya (mayapy), Houdini (hython) and 3ds Max (3dsmaxbatch) adapters that follow the vendors' documented headless interfaces but are untested.
`dcc_run_script`	Run a Python script headless inside a design app on this computer (Blender bpy by default; Maya via mayapy, Houdini via hython, 3ds Max via 3dsmaxbatch — those untested) and get back its log, structured result and the files it produced.
`dcc_convert`	Convert FBX, OBJ, Collada (.dae), USD/USDZ, 3DS, PLY, STL, Alembic or .blend files to glTF binary (.glb) with Blender — materials and textures are kept and embedded — then import them as assets.
`dcc_export`	Export objects or collections of a Blender file to glTF (.glb) and import them: the way to use a hand-made or downloaded .blend asset library.
`dcc_edit_asset`	Round-trip a mesh asset of the project through Blender: it is loaded, edited by preset `ops` and/or your Python `script`, exported and re-imported as a NEW VERSION (<name>_v2.glb, provenance recorded in its .meta: source asset, ops, version), so the original stays untouched and the change can be compared or reverted.
`dcc_generate`	Create a 3D model by running a procedural modeling recipe or your own Blender script, then import it as an asset (and optionally place it).
`dcc_install_addon`	Install (and enable) the Skywalker Bridge add-on in the user's Blender, so a Blender window the human works in can be driven live: it adds a 'Skywalker' tab to the 3D viewport sidebar (N) with Start Bridge and Send Selection buttons.
`dcc_session_status`	Is a live Blender session available, and what is in it?
`dcc_session_start`	Launch Blender with the Skywalker bridge running, so you can work interactively across many calls (state persists: build a scene step by step with dcc_session_exec, inspect it, then pull the result back with dcc_session_pull_selection).
`dcc_session_stop`	Stop the bridge.
`dcc_session_exec`	Execute Python inside the running Blender session (bpy, bmesh, `B` = skywalker_dcc.blender and `sky` are in scope; variables persist between calls, like a REPL).
`dcc_session_pull_selection`	Export the objects currently selected in the live Blender session (or the named objects) to glTF under dcc/live/<name>.glb, import them as an asset and place them (a new asset is placed at the origin unless you pass `place`; place:false imports only).
`dcc_session_send`	Import a project mesh asset into the live Blender session (it appears selected, and the view frames it) so you or the human can edit it there; bring it back with dcc_session_pull_selection.
`dcc_receive`	Copy a model file a design app just exported (an absolute path, e.g.
`dcc_cancel`	Stop a running design-app job (its id is in dcc_list's `jobs`).

`dcc_list`¶

List design apps read-only

Which professional design apps are installed on this computer and what the bridge can do with them: Blender (fully supported and tested), plus Maya (mayapy), Houdini (hython) and 3ds Max (3dsmaxbatch) adapters that follow the vendors' documented headless interfaces but are untested. Also lists running jobs and the live Blender session (if any) and the procedural recipes of dcc_generate. Detection checks SKY_BLENDER / SKY_MAYAPY / SKY_HOUDINI_HYTHON / SKY_3DSMAX_BATCH, ~/.skywalker/dcc/paths.json, the standard install folders and PATH. Call this first to know what you can use. Example: {}.

Argument	Type	Required	Description	Values
`refresh`	boolean		Rescan the machine instead of using the cached result

Tool callCLIMCP request

dcc_list {}

skywalker call dcc_list '{}' --project my_game

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "dcc_list",
    "arguments": {}
  }
}

`dcc_run_script`¶

Run a design-app script mutating open-world

Run a Python script headless inside a design app on this computer (Blender bpy by default; Maya via mayapy, Houdini via hython, 3ds Max via 3dsmaxbatch — those untested) and get back its log, structured result and the files it produced. The script runs with the environment SKY_PROJECT (project folder), SKY_OUT (output folder: everything new or changed there is reported), SKY_INPUT, and the helper library already imported as sky (sky.out_path('tower.glb'), sky.log(), sky.result(vertices=n), sky.project_path('assets/x.png')). Inside Blender from skywalker_dcc import blender as B, procedural gives import/export/decimate/bevel/UV/bake helpers and ready-made generators (see dcc_generate). Write models to SKY_OUT with B.export_glb(sky.out_path('x.glb')). With import:true produced .glb/.gltf (and .obj/.ply/.stl) are imported as project assets with provenance; FBX/Collada/USD files are converted through Blender first; place puts them in the scene. Units are meters; glTF export converts Blender's Z-up to the engine's Y-up. The script is executable code: the human is asked to approve in the editor. Example: {"script": "import bpy; bpy.ops.mesh.primitive_cube_add(size=2); B.export_glb(sky.out_path('cube.glb'))", "import": true, "place": {"name": "Cube", "position": [0,0,0]}}.

Argument	Type	Required	Description	Values
`script`	string	yes	Python source to run inside the app
`app`	string		Which app (default: Blender, else the first installed)	`blender` `maya` `houdini` `3dsmax`
`input`	string		Scene to open first (.blend for Blender, .ma/.mb Maya, .hip Houdini, .max 3ds Max), also in SKY_INPUT; project-relative or absolute
`args`	string[]		Script arguments (sky.ARGS)
`name`	string		Label for this run; the default output folder is dcc/<name> (default "script")
`out_dir`	string		Project-relative output folder (SKY_OUT), default dcc/<name>
`timeout_s`	integer		Give up after this many seconds (default 300, max 3600)
`import`	boolean		Import produced meshes as assets (default false)
`normalize`	boolean		When importing: scale to fit 1 m (default false = keep real-world size)
`place`	any		Also place the imported model(s) in the scene: true, or {"name": "Tower", "position": [x,y,z], "spacing": 4}. Several models are laid out along x by `spacing`.
`description`	string		Asset description for imported models (helps future searches)
`tags`	string[]		Extra asset tags
`user_prefs`	boolean		Blender: load the user's preferences and add-ons instead of factory settings

Tool callCLIMCP request

dcc_run_script {"script": "import bpy; bpy.ops.mesh.primitive_cube_add(size=2); B.export_glb(sky.out_path('cube.glb'))", "import": true, "place": {"name": "Cube", "position": [0, 0, 0]}}

skywalker call dcc_run_script '{"script": "import bpy; bpy.ops.mesh.primitive_cube_add(size=2); B.export_glb(sky.out_path('\''cube.glb'\''))", "import": true, "place": {"name": "Cube", "position": [0, 0, 0]}}' --project my_game

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "dcc_run_script",
    "arguments": {
      "script": "import bpy; bpy.ops.mesh.primitive_cube_add(size=2); B.export_glb(sky.out_path('cube.glb'))",
      "import": true,
      "place": {
        "name": "Cube",
        "position": [
          0,
          0,
          0
        ]
      }
    }
  }
}

`dcc_convert`¶

Convert models to glTF with Blender mutating open-world

Convert FBX, OBJ, Collada (.dae), USD/USDZ, 3DS, PLY, STL, Alembic or .blend files to glTF binary (.glb) with Blender — materials and textures are kept and embedded — then import them as assets. This unlocks the huge free FBX libraries (Kenney, Quaternius, Mixamo props, Sketchfab downloads...). path is one file or a whole folder (every supported file in it; recursive:true to descend); outputs mirror the folder structure next to the sources (or in out_dir). Use scale for packs authored in other units (0.01 = centimeters to meters if the importer did not already convert), axis_forward/axis_up for odd orientations ('-Z','Y'), recenter ('bottom' puts the origin at the feet), and ops for cleanup while converting (see dcc_edit_asset: decimate, merge_by_distance, shade_smooth...). Real-world size is kept (normalize:false). Typical flow after dcc_run_script or asset_download: {"path": "downloads/kenney_town", "recursive": true}. Needs Blender; asks for approval in the editor.

Argument	Type	Required	Description	Values
`path`	string	yes	File or folder to convert (project-relative or absolute)
`recursive`	boolean		Folder: include sub-folders (default false)
`out_dir`	string		Project-relative output folder (default: next to the sources, or dcc/converted outside the project)
`scale`	number		Uniform scale applied on import (default 1)
`axis_forward`	string		FBX/OBJ forward axis override, e.g. "-Z"
`axis_up`	string		FBX/OBJ up axis override, e.g. "Y"
`recenter`	string		Move the geometry so its origin is at the bottom / middle center	`bottom` `center`
`ops`	object[]		Cleanup operations, e.g. [{"op":"decimate","ratio":0.5}]
`skip_existing`	boolean		Skip files whose .glb is newer than the source (resume a big batch)
`timeout_s`	integer		Give up after this many seconds (default 600, max 3600)
`import`	boolean		Import the converted models as assets (default true)
`normalize`	boolean		When importing: scale to fit 1 m (default false = real-world size)
`place`	any		Also place the imported model(s) in the scene: true, or {"name": "Tower", "position": [x,y,z], "spacing": 4}. Several models are laid out along x by `spacing`.
`tags`	string[]		Asset tags
`description`	string		Asset description

Tool callCLIMCP request

dcc_convert {"path": "downloads/kenney_town_kit", "recursive": true, "recenter": "bottom", "skip_existing": true, "place": {"position": [0, 0, 0], "spacing": 4}}

skywalker call dcc_convert '{"path": "downloads/kenney_town_kit", "recursive": true, "recenter": "bottom", "skip_existing": true, "place": {"position": [0, 0, 0], "spacing": 4}}' --project my_game

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "dcc_convert",
    "arguments": {
      "path": "downloads/kenney_town_kit",
      "recursive": true,
      "recenter": "bottom",
      "skip_existing": true,
      "place": {
        "position": [
          0,
          0,
          0
        ],
        "spacing": 4
      }
    }
  }
}

`dcc_export`¶

Export assets from a .blend file mutating open-world

Export objects or collections of a Blender file to glTF (.glb) and import them: the way to use a hand-made or downloaded .blend asset library. By default every top-level collection that contains meshes becomes one asset (collection-per-asset; loose objects form one more asset named after the file). Select explicitly with collections or objects (children come along). Modifiers are applied, the scene's unit scale is honored (a centimeter-scale scene is exported in meters) and hidden objects are skipped unless include_hidden. origin: keep (default, as placed in the scene), bottom_center / center (re-centered per asset), collection (the collection's instance offset). Example: {"blend": "downloads/dungeon_kit.blend", "origin": "bottom_center", "place": {"spacing": 5}}. Needs Blender.

Argument	Type	Required	Description	Values
`blend`	string	yes	.blend file (project-relative or absolute)
`collections`	string[]		Collections to export, one asset each (default: every top-level collection with meshes)
`objects`	string[]		Object names to export, one asset each (with their children)
`origin`	string		Where each asset's origin ends up (default keep)	`keep` `bottom_center` `center` `collection`
`apply_modifiers`	boolean		Bake modifiers into the exported mesh (default true)
`include_hidden`	boolean		Export hidden objects too (default false)
`real_units`	boolean		Honor the scene's unit scale (default true)
`out_dir`	string		Project-relative output folder (default dcc/<blend name>)
`timeout_s`	integer		Give up after this many seconds (default 300, max 3600)
`import`	boolean		Import the exported models (default true)
`normalize`	boolean		When importing: scale to fit 1 m (default false)
`place`	any		Also place the imported model(s) in the scene: true, or {"name": "Tower", "position": [x,y,z], "spacing": 4}. Several models are laid out along x by `spacing`.
`tags`	string[]		Asset tags
`description`	string		Asset description

Tool callCLIMCP request

dcc_export {"blend": "downloads/dungeon_kit.blend", "origin": "bottom_center", "place": {"spacing": 5}}

skywalker call dcc_export '{"blend": "downloads/dungeon_kit.blend", "origin": "bottom_center", "place": {"spacing": 5}}' --project my_game

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "dcc_export",
    "arguments": {
      "blend": "downloads/dungeon_kit.blend",
      "origin": "bottom_center",
      "place": {
        "spacing": 5
      }
    }
  }
}

`dcc_edit_asset`¶

Edit an asset in Blender (round trip) mutating open-world

Round-trip a mesh asset of the project through Blender: it is loaded, edited by preset ops and/or your Python script, exported and re-imported as a NEW VERSION (_v2.glb, provenance recorded in its .meta: source asset, ops, version), so the original stays untouched and the change can be compared or reverted. Preset ops (run in order): decimate {ratio}, bevel {width,segments,angle}, smart_uv {angle,margin}, merge_by_distance {distance}, triangulate, shade_smooth {angle}, recenter {where: bottom|center}, apply_modifiers, join {name}, bake_ao {samples,distance,target: vertex|texture,size} (ambient occlusion into vertex colors or a texture). Your script runs after the ops with objects (the asset's objects), bpy, B (skywalker_dcc.blender) and sky in scope. mode:'replace' overwrites a .glb in place (a backup goes to .skywalker/dcc-backups) so every scene use updates live; update_references:true re-points scene entities from the old file to the new version. Example: {"asset": "downloads/scan/statue.glb", "ops": [{"op":"decimate","ratio":0.25},{"op":"shade_smooth"}]}. Needs Blender.

Argument	Type	Required	Description	Values
`asset`	string	yes	Mesh asset path or guid
`ops`	object[]		Preset operations, e.g. [{"op":"decimate","ratio":0.3}]
`script`	string		Extra Python run after the ops; `objects` holds the asset's objects
`mode`	string		new_version (default) writes <name>_vN.glb; replace overwrites a .glb in place	`new_version` `replace`
`update_references`	boolean		Re-point scene entities from the old asset to the new version (new_version mode)
`timeout_s`	integer		Give up after this many seconds (default 300, max 3600)
`description`	string		Asset description for the new version

Tool callCLIMCP request

dcc_edit_asset {"asset": "downloads/scan/statue.glb", "ops": [{"op": "decimate", "ratio": 0.25}, {"op": "shade_smooth"}]}

skywalker call dcc_edit_asset '{"asset": "downloads/scan/statue.glb", "ops": [{"op": "decimate", "ratio": 0.25}, {"op": "shade_smooth"}]}' --project my_game

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "dcc_edit_asset",
    "arguments": {
      "asset": "downloads/scan/statue.glb",
      "ops": [
        {
          "op": "decimate",
          "ratio": 0.25
        },
        {
          "op": "shade_smooth"
        }
      ]
    }
  }
}

`dcc_generate`¶

Model procedurally in Blender mutating open-world

Create a 3D model by running a procedural modeling recipe or your own Blender script, then import it as an asset (and optionally place it). Recipes are deterministic (same seed, same model), sized in meters, standing on the ground with the origin at the bottom center, with PBR materials and per-face color variation: building {floors,width,depth,floor_height,windows_per_side,roof: gabled|hip|flat,wall_style: plaster|brick|stone|wood,door,chimney}, tower {radius,height,sides,wall_thickness,battlements,ruin 0-1,door,window_slits,rubble}, wall {length,height,thickness,ruin}, rock {radius,roughness,flatten,detail,moss}, stairs {steps,width,rise,run,landing,style}, arch {width,height,depth,thickness,segments}, fence {length,height,post_spacing,style: picket|rail}, column {radius,height,flutes,base,capital}, barrel {radius,height,staves,hoops}, terrain_chunk {size,resolution,height,roughness,flat_radius}; every recipe also takes seed. Compose a scene piece by calling it several times with different seeds. For anything custom pass script (Blender Python; create objects in bpy.context.scene.collection; procedural.generate(...), B, sky are in scope) — all mesh objects in the scene are exported. ops can post-process (decimate, bevel, shade_smooth, bake_ao...; see dcc_edit_asset). Example: {"recipe": "tower", "params": {"height": 14, "ruin": 0.6, "seed": 3}, "name": "RuinedTower", "place": {"position": [10, 0, 5]}}. Needs Blender.

Argument	Type	Description	Values
`recipe`	string	Procedural recipe	`building` `tower` `wall` `rock` `stairs` `arch` `fence` `column` `barrel` `terrain_chunk`
`params`	object	Recipe parameters (see the list above), e.g.
`script`	string	Custom Blender Python; runs after the recipe (if any); `objects` holds the recipe's object
`name`	string	Asset / entity name (default: the recipe name)
`out_dir`	string	Project-relative output folder (default dcc/generated)
`ops`	object[]	Post-processing, e.g. [{"op":"bevel","width":0.02}]
`timeout_s`	integer	Give up after this many seconds (default 300, max 3600)
`import`	boolean	Import the result as an asset (default true)
`place`	any	Also place the imported model(s) in the scene: true, or {"name": "Tower", "position": [x,y,z], "spacing": 4}. Several models are laid out along x by `spacing`.
`description`	string	Asset description
`tags`	string[]	Asset tags

Tool callCLIMCP request

dcc_generate {"recipe": "tower", "params": {"height": 14, "ruin": 0.6, "seed": 3}, "name": "RuinedTower", "place": {"position": [10, 0, 5]}}

skywalker call dcc_generate '{"recipe": "tower", "params": {"height": 14, "ruin": 0.6, "seed": 3}, "name": "RuinedTower", "place": {"position": [10, 0, 5]}}' --project my_game

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "dcc_generate",
    "arguments": {
      "recipe": "tower",
      "params": {
        "height": 14,
        "ruin": 0.6,
        "seed": 3
      },
      "name": "RuinedTower",
      "place": {
        "position": [
          10,
          0,
          5
        ]
      }
    }
  }
}

`dcc_install_addon`¶

Install the Blender add-on mutating open-world

Install (and enable) the Skywalker Bridge add-on in the user's Blender, so a Blender window the human works in can be driven live: it adds a 'Skywalker' tab to the 3D viewport sidebar (N) with Start Bridge and Send Selection buttons. After the human clicks Start Bridge (or you use dcc_session_start for a windowless session), the dcc_session_* tools work. The add-on is copied into Blender's user scripts folder and enabled in the user's preferences (other preferences are preserved). Safe to run again to update it. Example: {}.

Argument	Type	Description
`enable`	boolean	Also enable it in Blender's preferences (default true)
`scripts_dir`	string	Blender user scripts folder to install into (default: the standard per-OS location of the detected version)
`config_dir`	string	Blender user config folder (BLENDER_USER_CONFIG) used while enabling; advanced / for tests

Tool callCLIMCP request

dcc_install_addon {}

skywalker call dcc_install_addon '{}' --project my_game

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "dcc_install_addon",
    "arguments": {}
  }
}

`dcc_session_status`¶

Live Blender session status read-only

Is a live Blender session available, and what is in it? Reports version, open file, scene, object counts and the current selection, or why not connected and how to connect (dcc_session_start for a windowless session, or dcc_install_addon and the Start Bridge button for a Blender window the human uses). Example: {}.

Takes no arguments.

Tool callCLIMCP request

dcc_session_status {}

skywalker call dcc_session_status '{}' --project my_game

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "dcc_session_status",
    "arguments": {}
  }
}

`dcc_session_start`¶

Start a live Blender session mutating open-world

Launch Blender with the Skywalker bridge running, so you can work interactively across many calls (state persists: build a scene step by step with dcc_session_exec, inspect it, then pull the result back with dcc_session_pull_selection). headless:true (default) runs without a window; headless:false opens Blender's window so the human can watch and edit alongside you. open loads a project mesh asset into the session. Reuses a session that is already running. Example: {"open": "props/statue.glb", "headless": false}.

Argument	Type	Description
`headless`	boolean	No window (default true); false opens Blender's UI
`open`	string	Project mesh asset to import into the session
`timeout_s`	integer	Wait this long for Blender to come up (default 90)

Tool callCLIMCP request

dcc_session_start {"open": "props/statue.glb", "headless": false}

skywalker call dcc_session_start '{"open": "props/statue.glb", "headless": false}' --project my_game

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "dcc_session_start",
    "arguments": {
      "open": "props/statue.glb",
      "headless": false
    }
  }
}

`dcc_session_stop`¶

Stop the live Blender session mutating open-world

Stop the bridge. A windowless session started by dcc_session_start exits; a Blender window stays open (only the bridge stops). Example: {}.

Takes no arguments.

Tool callCLIMCP request

dcc_session_stop {}

skywalker call dcc_session_stop '{}' --project my_game

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "dcc_session_stop",
    "arguments": {}
  }
}

`dcc_session_exec`¶

Run Python in the live Blender session mutating open-world

Execute Python inside the running Blender session (bpy, bmesh, B = skywalker_dcc.blender and sky are in scope; variables persist between calls, like a REPL). Returns stdout/stderr and the value of the last expression (or of a variable named result). In a Blender window the change is one undo step the human can Ctrl+Z. Errors come back with the Python traceback. Keep individual calls short (Blender's UI waits for them). Examples: {"code": "[o.name for o in bpy.context.scene.objects]"}, {"code": "bpy.ops.mesh.primitive_uv_sphere_add(radius=1)"}. The code is executable: the human is asked to approve in the editor.

Argument	Type	Required	Description
`code`	string	yes	Python source
`timeout_s`	integer		Give up waiting after this many seconds (default 120)
`reset`	boolean		Start with a fresh namespace
`undo`	boolean		Push an undo step in a Blender window (default true)

Tool callCLIMCP request

dcc_session_exec {"code": "[o.name for o in bpy.context.scene.objects]"}

skywalker call dcc_session_exec '{"code": "[o.name for o in bpy.context.scene.objects]"}' --project my_game

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "dcc_session_exec",
    "arguments": {
      "code": "[o.name for o in bpy.context.scene.objects]"
    }
  }
}

`dcc_session_pull_selection`¶

Bring Blender's selection into the project mutating open-world

Export the objects currently selected in the live Blender session (or the named objects) to glTF under dcc/live/.glb, import them as an asset and place them (a new asset is placed at the origin unless you pass place; place:false imports only). Calling it again with the same name UPDATES the asset in place: every scene entity that uses it refreshes live (the loop for iterating on a model in Blender while seeing it in the engine). Children of selected objects come along; modifiers are applied. Real-world size is kept. origin: keep | bottom_center | center. Example: {"name": "Lantern", "origin": "bottom_center", "place": {"position": [4,0,2]}}.

Argument	Type	Description	Values
`names`	string[]	Blender object names (default: the selection)
`name`	string	Asset name (default: the active object's name)
`origin`	string	Where the origin ends up (default keep)	`keep` `bottom_center` `center`
`apply_modifiers`	boolean	Bake modifiers (default true)
`timeout_s`	integer	Give up after this many seconds (default 120)
`import`	boolean	Import as an asset (default true)
`normalize`	boolean	Scale to fit 1 m on import (default false)
`place`	any	Also place the imported model(s) in the scene: true, or {"name": "Tower", "position": [x,y,z], "spacing": 4}. Several models are laid out along x by `spacing`.
`description`	string	Asset description
`tags`	string[]	Asset tags

Tool callCLIMCP request

dcc_session_pull_selection {"name": "Lantern", "origin": "bottom_center", "place": {"position": [4, 0, 2]}}

skywalker call dcc_session_pull_selection '{"name": "Lantern", "origin": "bottom_center", "place": {"position": [4, 0, 2]}}' --project my_game

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "dcc_session_pull_selection",
    "arguments": {
      "name": "Lantern",
      "origin": "bottom_center",
      "place": {
        "position": [
          4,
          0,
          2
        ]
      }
    }
  }
}

`dcc_session_send`¶

Send a project asset into Blender mutating open-world

Import a project mesh asset into the live Blender session (it appears selected, and the view frames it) so you or the human can edit it there; bring it back with dcc_session_pull_selection. Any mesh format the bridge can import works (.glb .gltf .obj .fbx .ply .stl...). Example: {"asset": "props/crate.glb"}.

Argument	Type	Required	Description
`asset`	string	yes	Mesh asset path or guid
`scale`	number		Uniform scale on import (default 1)
`timeout_s`	integer		Give up after this many seconds (default 120)

Tool callCLIMCP request

dcc_session_send {"asset": "props/crate.glb"}

skywalker call dcc_session_send '{"asset": "props/crate.glb"}' --project my_game

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "dcc_session_send",
    "arguments": {
      "asset": "props/crate.glb"
    }
  }
}

`dcc_receive`¶

Receive a model exported by a design app mutating

Copy a model file a design app just exported (an absolute path, e.g. from the Blender add-on's Send Selection button) into the project under dcc/live/, import it as an asset and place it. A file with the same name updates the existing asset in place (its entities refresh live) and is not placed again unless place:true. Agents normally use dcc_session_pull_selection instead; this is the entry point for the Blender add-on. Example: {"file": "/tmp/lantern.glb", "name": "Lantern"}.

Argument	Type	Required	Description
`file`	string	yes	Absolute path of a .glb/.gltf/.obj/.ply/.stl file
`name`	string		Asset name (default: the file name)
`place`	any		Also place the imported model(s) in the scene: true, or {"name": "Tower", "position": [x,y,z], "spacing": 4}. Several models are laid out along x by `spacing`.
`normalize`	boolean		Scale to fit 1 m on import (default false)
`description`	string		Asset description

Tool callCLIMCP request

dcc_receive {"file": "/tmp/lantern.glb", "name": "Lantern"}

skywalker call dcc_receive '{"file": "/tmp/lantern.glb", "name": "Lantern"}' --project my_game

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "dcc_receive",
    "arguments": {
      "file": "/tmp/lantern.glb",
      "name": "Lantern"
    }
  }
}

`dcc_cancel`¶

Cancel a design-app job read-only

Stop a running design-app job (its id is in dcc_list's jobs). The app is terminated and the call that started it returns a 'cancelled' error. Example: {"job": 3}.

Argument	Type	Required	Description	Values
`job`	integer	yes	Job id from dcc_list

Tool callCLIMCP request

dcc_cancel {"job": 3}

skywalker call dcc_cancel '{"job": 3}' --project my_game

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "dcc_cancel",
    "arguments": {
      "job": 3
    }
  }
}

DCC tools¶

dcc_list¶

dcc_run_script¶

dcc_convert¶

dcc_export¶

dcc_edit_asset¶

dcc_generate¶

dcc_install_addon¶

dcc_session_status¶

dcc_session_start¶

dcc_session_stop¶

dcc_session_exec¶

dcc_session_pull_selection¶

dcc_session_send¶

dcc_receive¶

dcc_cancel¶

`dcc_list`¶

`dcc_run_script`¶

`dcc_convert`¶

`dcc_export`¶

`dcc_edit_asset`¶

`dcc_generate`¶

`dcc_install_addon`¶

`dcc_session_status`¶

`dcc_session_start`¶

`dcc_session_stop`¶

`dcc_session_exec`¶

`dcc_session_pull_selection`¶

`dcc_session_send`¶

`dcc_receive`¶

`dcc_cancel`¶