Skip to main content
Glama

Server Configuration

Describes the environment variables required to run the server.

NameRequiredDescriptionDefault

No arguments

Instructions

Guidance the server publishes about itself, which clients place ahead of the tool catalog so the model reads it before choosing anything.

Live-edit Deadlock's Panorama UI (XML / CSS / JS) while the game runs.

Setup once: setup (installs the toolchain; call again until it reports done), bridge_install, then launch_game. The in-game bridge picks up requests the server writes as files and answers through console.log, so no network console is needed.

Typical loop: status → panel_tree / panel_find to locate panels → ui_source to read the game's original XML/CSS → css_apply / xml_load / js_eval to change things live → screenshot to look → console_log for Panorama errors.

  • js_eval runs real JS in the UI (eval is disabled by the engine, so code is compiled into a script).

  • css_apply sets inline styles on matching live panels (type/#id/.class, ' ' and '>' selectors); persistent sheets are re-applied about once a second.

  • xml_load compiles a layout (plus optional real stylesheet) with CSDK (~2s) and loads it live.

  • Each top-level UI is a separate panel tree with its own bridge: ui='hud' (HUD, also in the hideout), 'dashboard' (menus), 'overlay'. Live tools take ui='auto' (first ready in that order).

  • compile_source makes permanent overrides of game files (packed into the addon VPK; restart needed).

Capabilities

Features and capabilities supported by this server

Protocol revision2025-11-25

CapabilityDetails
tools
{
  "listChanged": false
}
prompts
{
  "listChanged": false
}
resources
{
  "subscribe": false,
  "listChanged": false
}

Tools

Functions exposed to the LLM to take actions

NameDescription
statusA

Report paths, game/bridge state and anything that needs fixing ("warnings"), and ping each in-game bridge.

setupA

Install the toolchain: Source 2 Viewer CLI, CSDK 13 and the compiler's Wine prefix. Downloads run in the background, so call again to see progress; a step it can't do itself says what the user has to do.

console_logC

Recent game console output (from console.log), optionally regex-filtered, e.g. pattern='PanoramaScript|JS Exception|panorama'.

launch_gameA

Launch Deadlock, optionally straight into a local map with the full match HUD.

map: 'new_player_basics' (sandbox / practice range — verified), 'dl_hideout', 'dl_midtown'. ('hero_testing' crashes the game even unmodded.)

Default: run deadlock.exe directly through umu-run with the game's own Proton prefix (no Steam launch prompt, no shader pre-caching; Steam must be running for login). Always adds -console -condebug -dev -novid (-condebug writes console.log, which the bridge replies through). extra_args is split like a shell command line. Mounts the dev addon for this session (if that fails, the game is not launched); it is unmounted automatically when the game exits. via_steam=True uses steam -applaunch (Steam asks the user to confirm custom arguments).

quit_gameA

Close Deadlock (terminates the process).

screenshotA

Capture the game and return it as an image.

By default grabs the Deadlock window itself via X11 (works even when other windows cover it, no focus change). If the window can't be captured (minimised, not found) this is an error, not a picture of the desktop. full_screen=True captures the whole screen instead, other windows included. crop: 'WxH+X+Y' in captured-image pixels (the game window's, e.g. '800x800+0+1100' for the bottom-left HUD), applied before resizing — use it to inspect small HUD details. A crop that fails is an error, not an uncropped image.

ui_filesA

List Panorama files shipped in the game VPK (regex filter), e.g. pattern='hud'.

ui_sourceB

Decompile a shipped Panorama file to source, e.g. 'layout/base_hud' or 'styles/hud.css'.

js_evalA

Run JavaScript inside Deadlock's Panorama UI and return the result (JSON-serialised; panels are described as {panel: {...}}).

A single expression is returned automatically; multi-statement code must return a value. In scope: $ (Panorama API), $panel (target panel; default the bridge panel), $root (top-level panel), $find(id), $query(structuredSelector), $children(p), $describe(p). target: panel id ('#Foo' or 'Foo'), 'root', or 'bridge'. keep_context=True keeps the script's context alive so event handlers / $.Schedule callbacks it registers keep working (otherwise contexts are recycled after ~64 requests).

panel_treeC

Dump the live panel hierarchy (id, type, layout file, size, position, text) under a panel.

panel_findB

Find live panels with a CSS-like selector, e.g. 'Label.HeroName', '#HudRoot > Panel'. ui='all' (default) searches every loaded UI tree.

xml_loadA

Compile Panorama XML (and optional CSS) with CSDK and load it into the live UI (~2s).

mode='append': create a child panel (id replaces any existing child with that id) under target. mode='replace': load the layout into target itself, replacing its contents. Refused for the UI root, the bridge panel (and its ancestors), and any panel whose type isn't plain Panel (loading into a C++ panel crashes the game). xml: a full ... layout or a bare fragment (wrapped automatically). Referenced scripts/styles must exist in the game or the addon. css: real Panorama CSS (pseudo-classes, animations, @define all work) compiled as this layout's stylesheet, included after the layout's own so it wins ties.

layout_live_editA

Live-edit the styling of an existing game layout (e.g. layout='citadel_hud_top_bar').

css: an edited copy of one of the layout's stylesheets. stylesheet: which one, in any form ('hud/foo', 'styles/hud/foo.css', 's2r://panorama/styles/hud/foo.vcss'); default: the layout's include with the layout's own name, else its only include (an error lists the choices). Get the original with ui_source. Declarations you added or changed are applied live as a persistent inline-style sheet named 'live:<path under styles/ without extension>', e.g. 'live:hud/foo' (@define values are substituted; pseudo-classes/animations and removed declarations can't be applied live — use compile_source for those). Undo with css_clear('live:hud/foo').

unsafe_reload=True instead compiles an edited copy of the layout (xml and/or css) and re-loads it into the live panels. This CRASHES the game for layouts whose root is a C++ panel type (most HUD/dashboard layouts, e.g. CitadelHudTopBar); the bridge skips panels it knows are unsafe and lists them under 'skipped'. Only use it for plain Panel-rooted layouts.

layout_live_revertA

Re-load the game's original layout into panels changed by layout_live_edit(unsafe_reload=True). (For CSS edits made the safe way, use css_clear('live:').)

css_applyA

Apply CSS to live panels as inline styles. Replaces earlier CSS with the same sheet name.

persist=True re-applies about once a second so panels the game recreates stay styled. Supports type, #id, .class, descendant and '>' selectors; pseudo-classes and at-rules are skipped (use xml_load's css for those on new panels, or compile_source for permanent game-wide styles).

css_clearA

Remove live CSS: one sheet by name, or all sheets if omitted. Panels styled by several sheets get the remaining sheets' values re-applied right away.

Caveat: once an inline visibility: collapse has been applied, clearing it does NOT make the panel visible again (Panorama keeps the panel's visible flag false). To hide things you may want back, prefer toggling visibility explicitly (set 'visible' again) via js_eval.

panel_deleteB

Delete a live panel by id (e.g. one created with xml_load). The UI root, the bridge panel and its ancestors are refused.

bridge_installA

Build and install the in-game bridges (needs CSDK 13 + Source2Viewer-CLI): one per UI root (HUD, dashboard, overlay). Compiles each host layout override + bridge script into the addon VPK. launch_game mounts the addon for its session (mount=True mounts it now). Restart the game afterwards. Re-run it after a game update or an update of this tool (status says when).

bridge_uninstallA

Remove the bridge files from the addon VPK (other compiled overrides stay).

compile_sourceA

Compile a Panorama source file with CSDK 13 and pack it into the addon VPK as a permanent override (takes effect after a game restart).

path: e.g. 'panorama/layout/citadel_hud_top_bar.xml' or 'panorama/styles/hud.css'. To override a game file, start from ui_source(...) and keep the same path. The bridge host layouts (base_hud, base_dashboard, base_hud_and_db_overlay) can't be overridden: that would remove the bridge from that UI.

list_overridesB

List the compiled files currently packed into the addon VPK (bridge files + compile_source overrides).

remove_overrideA

Remove a compile_source override from the addon VPK (e.g. 'panorama/styles/hud.css'). Takes effect after a game restart.

export_modA

Export compiled overrides as a standalone mod VPK (no bridge files) at /mods//pak01_dir.vpk.

include: regex selecting which addon files to export (default: every non-bridge override; see list_overrides). install=True also copies it into game/citadel/addons/ as the next free pakNN_dir.vpk (re-installing the same name replaces its earlier copy); the game loads it on its next start.

addons_mountA

Add (or remove) the dev addon search path in gameinfo.gi. launch_game mounts it and unmounts it when the game exits; removing it keeps the standard mod folder mounted.

Prompts

Interactive templates invoked by user choice

NameDescription

No prompts

Resources

Contextual data attached and managed by the client

NameDescription

No resources

TDQS

A3.5/5.0

Scored across 24 tools

Disambiguation3/5

Several tools converge on the same job of styling live panels: css_apply (inline sheets), layout_live_edit (persistent inline-style sheets via an edited stylesheet), xml_load's css parameter, and compile_source (permanent overrides), while css_clear and layout_live_revert both undo. The descriptions do explain the differences, and inspection tools (panel_find, panel_tree, js_eval) are distinct, but choosing the right styling path requires reading carefully. bridge_uninstall, remove_override and panel_delete are also easy to mix up at a glance despite targeting different things (bridge files, compiled overrides, panels).

Naming Consistency3/5

Everything is snake_case, but the verb/noun ordering is mixed: verb_noun (launch_game, compile_source, list_overrides, remove_override) alongside noun_verb (bridge_install, css_apply, css_clear, panel_find, layout_live_edit) and bare nouns (status, setup, screenshot, console_log, ui_files). The prefix grouping (panel_*, css_*, bridge_*, *_override) gives some structure, but the set is not a single predictable pattern.

Tool Count4/5

24 tools is heavy, but the domain — UI inspection, live CSS manipulation, compilation, bridge management, and mod packaging — genuinely spans that surface, and nearly every tool has a distinct role. A few (layout_live_revert, css_clear overlaps) could arguably be folded together to trim the set.

Completeness5/5

The lifecycle is well covered end to end: setup and status, launching/quitting, decompiling and inspecting shipped UI, live panel discovery/manipulation, CSS application and clearing, compilation into permanent overrides with listing/removal, and exporting/mounting mods. Given the description indicates input simulation or log tailing beyond a fixed console.log read, there are no obvious dead ends.

Maintenance

ActivityMaintained
ResponsivenessNo recent community issues