obs-mcp 0.2.0

OBS Studio control server for AI assistants via MCP and the OBS WebSocket protocol
Documentation
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
//! Generated tool table. Do not edit by hand; run
//! `python3 scripts/gen_tools_table.py` to regenerate.
//!
//! The tool surface mirrors the public OBS WebSocket v5 protocol
//! (https://github.com/obsproject/obs-websocket).

use super::tools::{ParamKind, ToolDef};
use super::tools::p;

/// All registered OBS tools as a static table.
pub fn all_tools() -> Vec<ToolDef> {
    vec![
        ToolDef::new("obs-get-persistent-data", "Read a value from OBS persistent data storage for a realm and slot.", "GetPersistentData")
            .with_params(vec![
                p("realm", ParamKind::Str, "Data realm: 'OBS_WEBSOCKET_DATA_REALM_GLOBAL' or 'OBS_WEBSOCKET_DATA_REALM_PROFILE'.", true),
                p("slotName", ParamKind::Str, "Name of the data slot to retrieve.", true),
            ])
            ,
        ToolDef::new("obs-set-persistent-data", "Store an arbitrary JSON value in OBS persistent data storage.", "SetPersistentData")
            .with_params(vec![
                p("realm", ParamKind::Str, "Data realm to write to.", true),
                p("slotName", ParamKind::Str, "Name of the data slot to write.", true),
                p("slotValue", ParamKind::Obj, "Arbitrary JSON value to store in the slot.", true),
            ])
            ,
        ToolDef::new("obs-get-scene-collection-list", "List the names of all scene collections in OBS.", "GetSceneCollectionList")
            ,
        ToolDef::new("obs-set-current-scene-collection", "Switch OBS to a different scene collection.", "SetCurrentSceneCollection")
            .with_params(vec![
                p("sceneCollectionName", ParamKind::Str, "Name of the scene collection to switch to.", true),
            ])
            ,
        ToolDef::new("obs-create-scene-collection", "Create a new empty scene collection and switch to it.", "CreateSceneCollection")
            .with_params(vec![
                p("sceneCollectionName", ParamKind::Str, "Name for the new scene collection.", true),
            ])
            ,
        ToolDef::new("obs-get-profile-list", "List the names of all configuration profiles in OBS.", "GetProfileList")
            ,
        ToolDef::new("obs-set-current-profile", "Switch OBS to a different configuration profile.", "SetCurrentProfile")
            .with_params(vec![
                p("profileName", ParamKind::Str, "Name of the profile to switch to.", true),
            ])
            ,
        ToolDef::new("obs-create-profile", "Create a new empty configuration profile and switch to it.", "CreateProfile")
            .with_params(vec![
                p("profileName", ParamKind::Str, "Name for the new profile.", true),
            ])
            ,
        ToolDef::new("obs-remove-profile", "Delete a configuration profile from OBS.", "RemoveProfile")
            .with_params(vec![
                p("profileName", ParamKind::Str, "Name of the profile to remove.", true),
            ])
            ,
        ToolDef::new("obs-get-profile-parameter", "Read a single parameter from the current OBS profile.", "GetProfileParameter")
            .with_params(vec![
                p("parameterCategory", ParamKind::Str, "Category of the profile parameter.", true),
                p("parameterName", ParamKind::Str, "Name of the profile parameter.", true),
            ])
            ,
        ToolDef::new("obs-set-profile-parameter", "Write a single parameter in the current OBS profile.", "SetProfileParameter")
            .with_params(vec![
                p("parameterCategory", ParamKind::Str, "Category of the profile parameter.", true),
                p("parameterName", ParamKind::Str, "Name of the profile parameter.", true),
                p("parameterValue", ParamKind::Str, "New value for the parameter.", true),
            ])
            ,
        ToolDef::new("obs-get-video-settings", "Get the base and output canvas resolutions and the fractional FPS value of OBS.", "GetVideoSettings")
            ,
        ToolDef::new("obs-set-video-settings", "Update the video output settings of OBS: resolution and frame rate.", "SetVideoSettings")
            .with_params(vec![
                p("fpsNumerator", ParamKind::Num, "Numerator of the fractional FPS value.", false),
                p("fpsDenominator", ParamKind::Num, "Denominator of the fractional FPS value.", false),
                p("baseWidth", ParamKind::Num, "Width of the base (canvas) resolution in pixels.", false),
                p("baseHeight", ParamKind::Num, "Height of the base (canvas) resolution in pixels.", false),
                p("outputWidth", ParamKind::Num, "Width of the output resolution in pixels.", false),
                p("outputHeight", ParamKind::Num, "Height of the output resolution in pixels.", false),
            ])
            ,
        ToolDef::new("obs-get-stream-service-settings", "Get the stream service settings: the service type (rtmp_common, etc.) and its configuration.", "GetStreamServiceSettings")
            ,
        ToolDef::new("obs-set-stream-service-settings", "Set the stream service settings used for streaming.", "SetStreamServiceSettings")
            .with_params(vec![
                p("streamServiceType", ParamKind::Str, "Type of the stream service, e.g. 'rtmp_common'.", true),
                p("streamServiceSettings", ParamKind::Obj, "Settings object for the stream service (key, server, etc.).", true),
            ])
            ,
        ToolDef::new("obs-get-record-directory", "Get the directory OBS saves recordings to.", "GetRecordDirectory")
            ,
        ToolDef::new("obs-set-record-directory", "Change the directory OBS saves recordings to.", "SetRecordDirectory")
            .with_params(vec![
                p("recordDirectory", ParamKind::Str, "Absolute path of the recording directory.", true),
            ])
            ,
        ToolDef::new("obs-get-filter-kind-list", "List all available source filter kinds (types) in OBS.", "GetSourceFilterKindList")
            ,
        ToolDef::new("obs-get-source-filter-list", "List the filters attached to a source, with their settings and enabled state.", "GetSourceFilterList")
            .with_params(vec![
                p("sourceName", ParamKind::Str, "Name of the source to list filters for.", true),
            ])
            ,
        ToolDef::new("obs-get-filter-default-settings", "Get the default settings for a source filter kind.", "GetSourceFilterDefaultSettings")
            .with_params(vec![
                p("filterKind", ParamKind::Str, "Kind of filter to get default settings for.", true),
            ])
            ,
        ToolDef::new("obs-create-source-filter", "Create a new filter on a source and optionally initialize its settings.", "CreateSourceFilter")
            .with_params(vec![
                p("sourceName", ParamKind::Str, "Name of the source to add the filter to.", true),
                p("filterName", ParamKind::Str, "Name for the new filter.", true),
                p("filterKind", ParamKind::Str, "Kind of filter to create.", true),
                p("filterSettings", ParamKind::Obj, "Settings object to initialize the filter with.", false),
            ])
            ,
        ToolDef::new("obs-remove-source-filter", "Remove a filter from a source.", "RemoveSourceFilter")
            .with_params(vec![
                p("sourceName", ParamKind::Str, "Name of the source the filter belongs to.", true),
                p("filterName", ParamKind::Str, "Name of the filter to remove.", true),
            ])
            ,
        ToolDef::new("obs-set-source-filter-name", "Rename a source filter.", "SetSourceFilterName")
            .with_params(vec![
                p("sourceName", ParamKind::Str, "Name of the source the filter belongs to.", true),
                p("filterName", ParamKind::Str, "Current name of the filter.", true),
                p("newFilterName", ParamKind::Str, "New name for the filter.", true),
            ])
            ,
        ToolDef::new("obs-get-source-filter", "Get the settings, kind and enabled state of one source filter.", "GetSourceFilter")
            .with_params(vec![
                p("sourceName", ParamKind::Str, "Name of the source the filter belongs to.", true),
                p("filterName", ParamKind::Str, "Name of the filter to read.", true),
            ])
            ,
        ToolDef::new("obs-set-source-filter-index", "Move a source filter to a new position in the filter chain.", "SetSourceFilterIndex")
            .with_params(vec![
                p("sourceName", ParamKind::Str, "Name of the source the filter belongs to.", true),
                p("filterName", ParamKind::Str, "Name of the filter to move.", true),
                p("filterIndex", ParamKind::Num, "New index (position) of the filter in the chain.", true),
            ])
            ,
        ToolDef::new("obs-set-source-filter-settings", "Update the settings of a source filter, optionally overlaying existing values.", "SetSourceFilterSettings")
            .with_params(vec![
                p("sourceName", ParamKind::Str, "Name of the source the filter belongs to.", true),
                p("filterName", ParamKind::Str, "Name of the filter to configure.", true),
                p("filterSettings", ParamKind::Obj, "Settings object to apply to the filter.", true),
                p("overlay", ParamKind::Bool, "True to merge over existing settings, false to replace them.", false),
            ])
            ,
        ToolDef::new("obs-set-source-filter-enabled", "Enable or disable a source filter.", "SetSourceFilterEnabled")
            .with_params(vec![
                p("sourceName", ParamKind::Str, "Name of the source the filter belongs to.", true),
                p("filterName", ParamKind::Str, "Name of the filter to enable or disable.", true),
                p("filterEnabled", ParamKind::Bool, "True to enable the filter, false to disable it.", true),
            ])
            ,
        ToolDef::new("obs-get-status", "Report the MCP server status and the OBS connection state: connected, identified, URL, password configured, auto-start configured and triggered, and the OBS and WebSocket versions.", "GetVersion")
            ,
        ToolDef::new("obs-get-version", "Get OBS Studio, obs-websocket and RPC version information.", "GetVersion")
            ,
        ToolDef::new("obs-test-connection", "Test the OBS WebSocket connection by issuing a lightweight version request.", "GetVersion")
            ,
        ToolDef::new("obs-get-stats", "Get statistics about OBS, obs-websocket and the current session (CPU, memory, disk, fps).", "GetStats")
            ,
        ToolDef::new("obs-broadcast-custom-event", "Broadcast a custom event to all OBS WebSocket clients.", "BroadcastCustomEvent")
            .with_params(vec![
                p("eventData", ParamKind::Obj, "Arbitrary JSON payload to emit to all WebSocket receivers.", true),
            ])
            ,
        ToolDef::new("obs-call-vendor-request", "Call a request registered by a vendor plugin in OBS.", "CallVendorRequest")
            .with_params(vec![
                p("vendorName", ParamKind::Str, "Name of the vendor implementing the request.", true),
                p("requestType", ParamKind::Str, "Request type to call.", true),
                p("requestData", ParamKind::Obj, "Arbitrary JSON data for the request.", false),
            ])
            ,
        ToolDef::new("obs-get-hotkey-list", "List the names of all hotkeys registered in OBS.", "GetHotkeyList")
            ,
        ToolDef::new("obs-trigger-hotkey-by-name", "Trigger a hotkey in OBS by its registered name.", "TriggerHotkeyByName")
            .with_params(vec![
                p("hotkeyName", ParamKind::Str, "Name of the hotkey to trigger.", true),
                p("contextName", ParamKind::Str, "Name of the context of the hotkey to trigger.", false),
            ])
            ,
        ToolDef::new("obs-trigger-hotkey-by-key-sequence", "Trigger a hotkey in OBS by simulating a key sequence with modifiers.", "TriggerHotkeyByKeySequence")
            .with_params(vec![
                p("keyId", ParamKind::Str, "OBS internal key identifier (OBS_KEY_*).", false),
                p("keyModifiers", ParamKind::Obj, "Object with boolean shift, control, alt, command modifiers.", false),
            ])
            ,
        ToolDef::new("obs-sleep", "Pause the OBS WebSocket request pipeline for a duration or a frame count.", "Sleep")
            .with_params(vec![
                p("sleepMillis", ParamKind::Num, "Number of milliseconds to sleep.", false),
                p("sleepFrames", ParamKind::Num, "Number of frames to sleep.", false),
            ])
            ,
        ToolDef::new("obs-get-input-list", "List inputs (sources with audio/video) in OBS, optionally filtered by kind.", "GetInputList")
            .with_params(vec![
                p("inputKind", ParamKind::Str, "Kind of inputs to filter by (optional).", false),
            ])
            ,
        ToolDef::new("obs-get-input-kind-list", "List all available input kinds in OBS.", "GetInputKindList")
            .with_params(vec![
                p("unversioned", ParamKind::Bool, "True to return unversioned kind strings.", false),
            ])
            ,
        ToolDef::new("obs-get-special-inputs", "Get the names of the special OBS inputs: desktop audio, mic, and so on.", "GetSpecialInputs")
            ,
        ToolDef::new("obs-create-input", "Create a new input source, add it to a scene, and return the new scene item id.", "CreateInput")
            .with_params(vec![
                p("sceneName", ParamKind::Str, "Name of the scene to add the input to as a scene item.", true),
                p("inputName", ParamKind::Str, "Name for the new input.", true),
                p("inputKind", ParamKind::Str, "Kind of input to create.", true),
                p("inputSettings", ParamKind::Obj, "Settings object to initialize the input with.", false),
                p("sceneItemEnabled", ParamKind::Bool, "Whether the created scene item starts enabled.", false),
            ])
            ,
        ToolDef::new("obs-remove-input", "Remove an input source from OBS.", "RemoveInput")
            .with_params(vec![
                p("inputName", ParamKind::Str, "Name of the input to remove.", true),
            ])
            ,
        ToolDef::new("obs-set-input-name", "Rename an input source.", "SetInputName")
            .with_params(vec![
                p("inputName", ParamKind::Str, "Current name of the input.", true),
                p("newInputName", ParamKind::Str, "New name for the input.", true),
            ])
            ,
        ToolDef::new("obs-get-input-default-settings", "Get the default settings for an input kind.", "GetInputDefaultSettings")
            .with_params(vec![
                p("inputKind", ParamKind::Str, "Kind of input to get default settings for.", true),
            ])
            ,
        ToolDef::new("obs-get-input-settings", "Get the current settings of an input source.", "GetInputSettings")
            .with_params(vec![
                p("inputName", ParamKind::Str, "Name of the input to read.", true),
            ])
            ,
        ToolDef::new("obs-set-input-settings", "Update the settings of an input source, optionally overlaying existing values.", "SetInputSettings")
            .with_params(vec![
                p("inputName", ParamKind::Str, "Name of the input to configure.", true),
                p("inputSettings", ParamKind::Obj, "Settings object to apply.", true),
                p("overlay", ParamKind::Bool, "True to merge over existing settings, false to replace them.", false),
            ])
            ,
        ToolDef::new("obs-get-input-mute", "Check whether an input source is muted.", "GetInputMute")
            .with_params(vec![
                p("inputName", ParamKind::Str, "Name of the input to query.", true),
            ])
            ,
        ToolDef::new("obs-set-input-mute", "Mute or unmute an input source.", "SetInputMute")
            .with_params(vec![
                p("inputName", ParamKind::Str, "Name of the input.", true),
                p("inputMuted", ParamKind::Bool, "True to mute, false to unmute.", true),
            ])
            ,
        ToolDef::new("obs-toggle-input-mute", "Toggle the mute state of an input source and report the new state.", "ToggleInputMute")
            .with_params(vec![
                p("inputName", ParamKind::Str, "Name of the input to toggle.", true),
            ])
            ,
        ToolDef::new("obs-get-input-volume", "Get the volume of an input source in both multiplier and dB.", "GetInputVolume")
            .with_params(vec![
                p("inputName", ParamKind::Str, "Name of the input to query.", true),
            ])
            ,
        ToolDef::new("obs-set-input-volume", "Set the volume of an input source by multiplier or dB. Provide exactly one of the two.", "SetInputVolume")
            .with_params(vec![
                p("inputName", ParamKind::Str, "Name of the input.", true),
                p("inputVolumeMul", ParamKind::Num, "Volume multiplier in the range 0 to 20.", false),
                p("inputVolumeDb", ParamKind::Num, "Volume in dB in the range -100 to 26.", false),
            ])
            ,
        ToolDef::new("obs-get-input-audio-balance", "Get the stereo audio balance of an input source.", "GetInputAudioBalance")
            .with_params(vec![
                p("inputName", ParamKind::Str, "Name of the input to query.", true),
            ])
            ,
        ToolDef::new("obs-set-input-audio-balance", "Set the stereo audio balance of an input source.", "SetInputAudioBalance")
            .with_params(vec![
                p("inputName", ParamKind::Str, "Name of the input.", true),
                p("inputAudioBalance", ParamKind::Num, "Balance value between 0.0 (left) and 1.0 (right).", true),
            ])
            ,
        ToolDef::new("obs-get-input-audio-sync-offset", "Get the audio sync offset of an input source in milliseconds.", "GetInputAudioSyncOffset")
            .with_params(vec![
                p("inputName", ParamKind::Str, "Name of the input to query.", true),
            ])
            ,
        ToolDef::new("obs-set-input-audio-sync-offset", "Set the audio sync offset of an input source in milliseconds.", "SetInputAudioSyncOffset")
            .with_params(vec![
                p("inputName", ParamKind::Str, "Name of the input.", true),
                p("inputAudioSyncOffset", ParamKind::Num, "Sync offset in milliseconds.", true),
            ])
            ,
        ToolDef::new("obs-get-input-audio-monitor-type", "Get the audio monitor type of an input source.", "GetInputAudioMonitorType")
            .with_params(vec![
                p("inputName", ParamKind::Str, "Name of the input to query.", true),
            ])
            ,
        ToolDef::new("obs-set-input-audio-monitor-type", "Set the audio monitor type of an input source.", "SetInputAudioMonitorType")
            .with_params(vec![
                p("inputName", ParamKind::Str, "Name of the input.", true),
                p("monitorType", ParamKind::Str, "Monitor type: OBS_MONITORING_TYPE_NONE, MONITOR_ONLY or BOTH.", true),
            ])
            ,
        ToolDef::new("obs-get-media-input-status", "Get the playback state of a media input: media state, cursor, duration.", "GetMediaInputStatus")
            .with_params(vec![
                p("inputName", ParamKind::Str, "Name of the media input to query.", true),
            ])
            ,
        ToolDef::new("obs-set-media-input-cursor", "Seek a media input to a new cursor position in milliseconds.", "SetMediaInputCursor")
            .with_params(vec![
                p("inputName", ParamKind::Str, "Name of the media input.", true),
                p("mediaCursor", ParamKind::Num, "New playback cursor position in milliseconds.", true),
            ])
            ,
        ToolDef::new("obs-offset-media-input-cursor", "Offset the playback cursor of a media input by a number of milliseconds.", "OffsetMediaInputCursor")
            .with_params(vec![
                p("inputName", ParamKind::Str, "Name of the media input.", true),
                p("mediaCursorOffset", ParamKind::Num, "Cursor offset in milliseconds (can be negative).", true),
            ])
            ,
        ToolDef::new("obs-trigger-media-input-action", "Trigger an action on a media input such as play, pause, stop or restart.", "TriggerMediaInputAction")
            .with_params(vec![
                p("inputName", ParamKind::Str, "Name of the media input.", true),
                p("mediaAction", ParamKind::Enum(&["OBS_MEDIA_STATE_NONE", "OBS_MEDIA_STATE_PLAYING", "OBS_MEDIA_STATE_OPENING", "OBS_MEDIA_STATE_BUFFERING", "OBS_MEDIA_STATE_PAUSED", "OBS_MEDIA_STATE_STOPPED", "OBS_MEDIA_STATE_ENDED", "OBS_MEDIA_STATE_ERROR"]), "Media action to trigger: play, pause, stop, restart, next, previous.", true),
            ])
            ,
        ToolDef::new("obs-get-virtual-cam-status", "Check whether the virtual camera output is active.", "GetVirtualCamStatus")
            ,
        ToolDef::new("obs-toggle-virtual-cam", "Toggle the virtual camera output and report its new state.", "ToggleVirtualCam")
            ,
        ToolDef::new("obs-start-virtual-cam", "Start the virtual camera output.", "StartVirtualCam")
            ,
        ToolDef::new("obs-stop-virtual-cam", "Stop the virtual camera output.", "StopVirtualCam")
            ,
        ToolDef::new("obs-get-replay-buffer-status", "Check whether the replay buffer output is active.", "GetReplayBufferStatus")
            ,
        ToolDef::new("obs-toggle-replay-buffer", "Toggle the replay buffer output and report its new state.", "ToggleReplayBuffer")
            ,
        ToolDef::new("obs-start-replay-buffer", "Start the replay buffer output.", "StartReplayBuffer")
            ,
        ToolDef::new("obs-stop-replay-buffer", "Stop the replay buffer output.", "StopReplayBuffer")
            ,
        ToolDef::new("obs-save-replay-buffer", "Save the current replay buffer contents to disk.", "SaveReplayBuffer")
            ,
        ToolDef::new("obs-get-last-replay-buffer-replay", "Get the filename of the last saved replay buffer replay.", "GetLastReplayBufferReplay")
            ,
        ToolDef::new("obs-get-output-list", "List all outputs in OBS with their active state.", "GetOutputList")
            ,
        ToolDef::new("obs-get-output-status", "Get the active state, reconnecting state and timecode of an output.", "GetOutputStatus")
            .with_params(vec![
                p("outputName", ParamKind::Str, "Name of the output to query.", true),
            ])
            ,
        ToolDef::new("obs-toggle-output", "Toggle the active state of an output.", "ToggleOutput")
            .with_params(vec![
                p("outputName", ParamKind::Str, "Name of the output to toggle.", true),
            ])
            ,
        ToolDef::new("obs-start-output", "Start an output by name.", "StartOutput")
            .with_params(vec![
                p("outputName", ParamKind::Str, "Name of the output to start.", true),
            ])
            ,
        ToolDef::new("obs-stop-output", "Stop an output by name.", "StopOutput")
            .with_params(vec![
                p("outputName", ParamKind::Str, "Name of the output to stop.", true),
            ])
            ,
        ToolDef::new("obs-get-output-settings", "Get the settings of an output.", "GetOutputSettings")
            .with_params(vec![
                p("outputName", ParamKind::Str, "Name of the output to read.", true),
            ])
            ,
        ToolDef::new("obs-set-output-settings", "Update the settings of an output.", "SetOutputSettings")
            .with_params(vec![
                p("outputName", ParamKind::Str, "Name of the output.", true),
                p("outputSettings", ParamKind::Obj, "Settings object to apply to the output.", true),
            ])
            ,
        ToolDef::new("obs-get-record-status", "Get the recording state: active, paused, and the recording timecode.", "GetRecordStatus")
            ,
        ToolDef::new("obs-toggle-record", "Toggle recording and report the new state.", "ToggleRecord")
            ,
        ToolDef::new("obs-start-record", "Start recording.", "StartRecord")
            ,
        ToolDef::new("obs-stop-record", "Stop recording and report the output path of the saved file.", "StopRecord")
            ,
        ToolDef::new("obs-toggle-record-pause", "Toggle the paused state of an active recording.", "ToggleRecordPause")
            ,
        ToolDef::new("obs-pause-record", "Pause an active recording.", "PauseRecord")
            ,
        ToolDef::new("obs-resume-record", "Resume a paused recording.", "ResumeRecord")
            ,
        ToolDef::new("obs-split-record-file", "Split the current recording into a new file.", "SplitRecordFile")
            ,
        ToolDef::new("obs-create-record-chapter", "Create a chapter marker in the current recording at the current time.", "CreateRecordChapter")
            .with_params(vec![
                p("chapterName", ParamKind::Str, "Name for the new recording chapter (optional).", false),
            ])
            ,
        ToolDef::new("obs-get-scene-items", "List the scene items of a scene with their ids and source names.", "GetSceneItemList")
            .with_params(vec![
                p("sceneName", ParamKind::Str, "Name of the scene to list items for.", true),
            ])
            ,
        ToolDef::new("obs-create-scene-item", "Add a source as a scene item to a scene and return the new scene item id.", "CreateSceneItem")
            .with_params(vec![
                p("sceneName", ParamKind::Str, "Name of the scene to add the item to.", true),
                p("sourceName", ParamKind::Str, "Name of the source to add.", true),
                p("enabled", ParamKind::Bool, "Whether the item starts visible (default true).", false),
            ])
            .with_renames(vec![("enabled", "sceneItemEnabled")])
            ,
        ToolDef::new("obs-remove-scene-item", "Remove a scene item from a scene.", "RemoveSceneItem")
            .with_params(vec![
                p("sceneName", ParamKind::Str, "Name of the scene the item is in.", true),
                p("sceneItemId", ParamKind::Num, "Id of the scene item to remove.", true),
            ])
            ,
        ToolDef::new("obs-set-scene-item-enabled", "Show or hide a scene item.", "SetSceneItemEnabled")
            .with_params(vec![
                p("sceneName", ParamKind::Str, "Name of the scene the item is in.", true),
                p("sceneItemId", ParamKind::Num, "Id of the scene item.", true),
                p("enabled", ParamKind::Bool, "True to show the item, false to hide it.", true),
            ])
            .with_renames(vec![("enabled", "sceneItemEnabled")])
            ,
        ToolDef::new("obs-get-scene-item-transform", "Get the transform (position, rotation, scale, crop) of a scene item.", "GetSceneItemTransform")
            .with_params(vec![
                p("sceneName", ParamKind::Str, "Name of the scene the item is in.", true),
                p("sceneItemId", ParamKind::Num, "Id of the scene item.", true),
            ])
            ,
        ToolDef::new("obs-set-scene-item-transform", "Set the transform of a scene item: position, rotation, scale and crop.", "SetSceneItemTransform")
            .with_params(vec![
                p("sceneName", ParamKind::Str, "Name of the scene the item is in.", true),
                p("sceneItemId", ParamKind::Num, "Id of the scene item.", true),
                p("transform", ParamKind::Obj, "Transform object: positionX, positionY, rotation, scaleX, scaleY, cropTop, cropBottom, cropLeft, cropRight, bounds* fields.", true),
            ])
            .with_renames(vec![("transform", "sceneItemTransform")])
            ,
        ToolDef::new("obs-get-scene-item-id", "Find the scene item id of a source inside a scene.", "GetSceneItemId")
            .with_params(vec![
                p("sceneName", ParamKind::Str, "Name of the scene to search in.", true),
                p("sourceName", ParamKind::Str, "Name of the source to find.", true),
            ])
            ,
        ToolDef::new("obs-get-scene-list", "List all scenes in OBS with the current program scene marked.", "GetSceneList")
            ,
        ToolDef::new("obs-get-current-scene", "Get the name of the current program (live) scene.", "GetCurrentProgramScene")
            ,
        ToolDef::new("obs-set-current-scene", "Switch the program scene to a named scene.", "SetCurrentProgramScene")
            .with_params(vec![
                p("sceneName", ParamKind::Str, "Name of the scene to switch to.", true),
            ])
            ,
        ToolDef::new("obs-get-preview-scene", "Get the current preview scene when studio mode is enabled.", "GetCurrentPreviewScene")
            ,
        ToolDef::new("obs-set-preview-scene", "Set the preview scene when studio mode is enabled.", "SetCurrentPreviewScene")
            .with_params(vec![
                p("sceneName", ParamKind::Str, "Name of the scene to show in preview.", true),
            ])
            ,
        ToolDef::new("obs-create-scene", "Create a new empty scene.", "CreateScene")
            .with_params(vec![
                p("sceneName", ParamKind::Str, "Name for the new scene.", true),
            ])
            ,
        ToolDef::new("obs-remove-scene", "Remove a scene from OBS.", "RemoveScene")
            .with_params(vec![
                p("sceneName", ParamKind::Str, "Name of the scene to remove.", true),
            ])
            ,
        ToolDef::new("obs-trigger-studio-transition", "Trigger the transition from preview to program scene in studio mode.", "TriggerStudioModeTransition")
            ,
        ToolDef::new("obs-get-source-active", "Check whether a source is visible in any scene.", "GetSourceActive")
            .with_params(vec![
                p("sourceName", ParamKind::Str, "Name of the source (or its UUID) to query.", false),
                p("sourceUuid", ParamKind::Str, "UUID of the source (alternative to sourceName).", false),
            ])
            ,
        ToolDef::new("obs-get-source-screenshot", "Take a screenshot of a source and return it as a base64-encoded image.", "GetSourceScreenshot")
            .with_params(vec![
                p("sourceName", ParamKind::Str, "Name of the source to capture.", false),
                p("sourceUuid", ParamKind::Str, "UUID of the source (alternative to sourceName).", false),
                p("imageFormat", ParamKind::Str, "Image format: png, jpg, bmp, webp.", true),
                p("imageWidth", ParamKind::Num, "Width to scale the screenshot to.", false),
                p("imageHeight", ParamKind::Num, "Height to scale the screenshot to.", false),
                p("imageCompressionQuality", ParamKind::Num, "Compression quality 0-100, -1 for default.", false),
            ])
            ,
        ToolDef::new("obs-save-source-screenshot", "Take a screenshot of a source and save it to a file on disk.", "SaveSourceScreenshot")
            .with_params(vec![
                p("sourceName", ParamKind::Str, "Name of the source to capture.", false),
                p("sourceUuid", ParamKind::Str, "UUID of the source (alternative to sourceName).", false),
                p("imageFormat", ParamKind::Str, "Image format: png, jpg, bmp, webp.", true),
                p("imageFilePath", ParamKind::Str, "Filesystem path to save the screenshot to.", true),
                p("imageWidth", ParamKind::Num, "Width to scale the screenshot to.", false),
                p("imageHeight", ParamKind::Num, "Height to scale the screenshot to.", false),
                p("imageCompressionQuality", ParamKind::Num, "Compression quality 0-100, -1 for default.", false),
            ])
            ,
        ToolDef::new("obs-get-stream-status", "Get the streaming state: active, reconnecting, and the stream timecode.", "GetStreamStatus")
            ,
        ToolDef::new("obs-start-stream", "Start streaming.", "StartStream")
            ,
        ToolDef::new("obs-stop-stream", "Stop streaming.", "StopStream")
            ,
        ToolDef::new("obs-toggle-stream", "Toggle streaming and report the new state.", "ToggleStream")
            ,
        ToolDef::new("obs-send-stream-caption", "Send a CEA-608 caption over the active stream output.", "SendStreamCaption")
            .with_params(vec![
                p("captionText", ParamKind::Str, "CEA-608 caption text to send over the stream.", true),
            ])
            ,
        ToolDef::new("obs-get-transition-list", "List all scene transitions in OBS with the current transition marked.", "GetSceneTransitionList")
            ,
        ToolDef::new("obs-get-current-transition", "Get the current scene transition: name, kind and settings.", "GetCurrentSceneTransition")
            ,
        ToolDef::new("obs-set-current-transition", "Set the active scene transition by name.", "SetCurrentSceneTransition")
            .with_params(vec![
                p("transitionName", ParamKind::Str, "Name of the transition to make current.", true),
            ])
            ,
        ToolDef::new("obs-get-transition-duration", "Get the duration of the current scene transition in milliseconds (returned by the current transition object).", "GetCurrentSceneTransition")
            ,
        ToolDef::new("obs-set-transition-duration", "Set the duration of the current scene transition in milliseconds.", "SetCurrentSceneTransitionDuration")
            .with_params(vec![
                p("duration", ParamKind::Num, "Transition duration in milliseconds.", true),
            ])
            .with_renames(vec![("duration", "transitionDuration")])
            ,
        ToolDef::new("obs-get-transition-kind", "Get the kind of the current scene transition.", "GetCurrentSceneTransition")
            ,
        ToolDef::new("obs-set-transition-settings", "Update the settings of the current scene transition.", "SetCurrentSceneTransitionSettings")
            .with_params(vec![
                p("transitionSettings", ParamKind::Obj, "Settings object for the current transition.", true),
            ])
            ,
        ToolDef::new("obs-get-transition-settings", "Get the settings of the current scene transition (returned by the current transition object).", "GetCurrentSceneTransition")
            ,
        ToolDef::new("obs-trigger-transition", "Trigger a studio mode transition from preview to program.", "TriggerStudioModeTransition")
            ,
        ToolDef::new("obs-get-studio-mode", "Check whether studio mode is enabled.", "GetStudioModeEnabled")
            ,
        ToolDef::new("obs-set-studio-mode", "Enable or disable studio mode.", "SetStudioModeEnabled")
            .with_params(vec![
                p("studioModeEnabled", ParamKind::Bool, "True to enable studio mode, false to disable.", true),
            ])
            ,
        ToolDef::new("obs-open-input-properties", "Open the properties dialog of an input in the OBS UI.", "OpenInputPropertiesDialog")
            .with_params(vec![
                p("inputName", ParamKind::Str, "Name of the input.", false),
                p("inputUuid", ParamKind::Str, "UUID of the input (alternative to inputName).", false),
            ])
            ,
        ToolDef::new("obs-open-input-filters", "Open the filters dialog of an input in the OBS UI.", "OpenInputFiltersDialog")
            .with_params(vec![
                p("inputName", ParamKind::Str, "Name of the input.", false),
                p("inputUuid", ParamKind::Str, "UUID of the input (alternative to inputName).", false),
            ])
            ,
        ToolDef::new("obs-open-input-interact", "Open the interaction dialog of an input in the OBS UI.", "OpenInputInteractDialog")
            .with_params(vec![
                p("inputName", ParamKind::Str, "Name of the input.", false),
                p("inputUuid", ParamKind::Str, "UUID of the input (alternative to inputName).", false),
            ])
            ,
        ToolDef::new("obs-get-monitor-list", "List the monitors detected by OBS with their geometry.", "GetMonitorList")
            ,
        ToolDef::new("obs-open-video-mix-projector", "Open a video mix projector window in the OBS UI.", "OpenVideoMixProjector")
            .with_params(vec![
                p("videoMixType", ParamKind::Enum(&["OBS_WEBSOCKET_VIDEO_MIX_TYPE_PREVIEW", "OBS_WEBSOCKET_VIDEO_MIX_TYPE_PROGRAM", "OBS_WEBSOCKET_VIDEO_MIX_TYPE_MULTIVIEW"]), "Video mix type: preview, program or multiview.", true),
                p("monitorIndex", ParamKind::Num, "Index of the monitor to open the projector on.", false),
                p("projectorGeometry", ParamKind::Str, "Projector geometry as a string like '0,0,1280,720'.", false),
            ])
            ,
        ToolDef::new("obs-open-source-projector", "Open a source projector window in the OBS UI.", "OpenSourceProjector")
            .with_params(vec![
                p("sourceName", ParamKind::Str, "Name of the source to project.", false),
                p("sourceUuid", ParamKind::Str, "UUID of the source (alternative to sourceName).", false),
                p("monitorIndex", ParamKind::Num, "Index of the monitor to open the projector on.", false),
                p("projectorGeometry", ParamKind::Str, "Projector geometry as a string like '0,0,1280,720'.", false),
            ])
            ,
        ToolDef::new("obs-get-canvas-list", "List all canvases in OBS with their resolution and scene counts.", "GetCanvasList")
            ,
        ToolDef::new("obs-get-group-list", "List all groups in OBS with their scene items.", "GetGroupList")
            ,
        ToolDef::new("obs-get-group-scene-items", "List the scene items of a group.", "GetGroupSceneItemList")
            .with_params(vec![
                p("canvasUuid", ParamKind::Str, "UUID of the canvas (alternative to sceneName/sceneUuid).", false),
                p("sceneName", ParamKind::Str, "Name of the group to list items for.", false),
                p("sceneUuid", ParamKind::Str, "UUID of the group (alternative to sceneName).", false),
            ])
            ,
        ToolDef::new("obs-set-scene-name", "Rename a scene in OBS.", "SetSceneName")
            .with_params(vec![
                p("canvasUuid", ParamKind::Str, "UUID of the canvas (alternative to sceneName/sceneUuid).", false),
                p("sceneName", ParamKind::Str, "Current name of the scene to rename.", false),
                p("sceneUuid", ParamKind::Str, "UUID of the scene (alternative to sceneName).", false),
                p("newSceneName", ParamKind::Str, "New name for the scene.", true),
            ])
            ,
        ToolDef::new("obs-duplicate-scene-item", "Duplicate a scene item, copying its transform, crop and settings.", "DuplicateSceneItem")
            .with_params(vec![
                p("canvasUuid", ParamKind::Str, "UUID of the canvas (alternative to sceneName/sceneUuid).", false),
                p("sceneName", ParamKind::Str, "Name of the scene the item is in.", false),
                p("sceneUuid", ParamKind::Str, "UUID of the scene (alternative to sceneName).", false),
                p("sceneItemId", ParamKind::Num, "Id of the scene item to duplicate.", true),
                p("destinationSceneName", ParamKind::Str, "Name of the scene to copy the item into (defaults to the source scene).", false),
                p("destinationSceneUuid", ParamKind::Str, "UUID of the destination scene (alternative to destinationSceneName).", false),
            ])
            ,
        ToolDef::new("obs-get-scene-item-enabled", "Check whether a scene item is visible (enabled).", "GetSceneItemEnabled")
            .with_params(vec![
                p("canvasUuid", ParamKind::Str, "UUID of the canvas (alternative to sceneName/sceneUuid).", false),
                p("sceneName", ParamKind::Str, "Name of the scene the item is in.", false),
                p("sceneUuid", ParamKind::Str, "UUID of the scene (alternative to sceneName).", false),
                p("sceneItemId", ParamKind::Num, "Id of the scene item.", true),
            ])
            ,
        ToolDef::new("obs-get-scene-item-index", "Get the index position of a scene item in its scene.", "GetSceneItemIndex")
            .with_params(vec![
                p("canvasUuid", ParamKind::Str, "UUID of the canvas (alternative to sceneName/sceneUuid).", false),
                p("sceneName", ParamKind::Str, "Name of the scene the item is in.", false),
                p("sceneUuid", ParamKind::Str, "UUID of the scene (alternative to sceneName).", false),
                p("sceneItemId", ParamKind::Num, "Id of the scene item.", true),
            ])
            ,
        ToolDef::new("obs-set-scene-item-index", "Set the index position of a scene item in its scene.", "SetSceneItemIndex")
            .with_params(vec![
                p("canvasUuid", ParamKind::Str, "UUID of the canvas (alternative to sceneName/sceneUuid).", false),
                p("sceneName", ParamKind::Str, "Name of the scene the item is in.", false),
                p("sceneUuid", ParamKind::Str, "UUID of the scene (alternative to sceneName).", false),
                p("sceneItemId", ParamKind::Num, "Id of the scene item.", true),
                p("sceneItemIndex", ParamKind::Num, "New index position of the item.", true),
            ])
            ,
        ToolDef::new("obs-get-scene-item-locked", "Check whether a scene item is locked.", "GetSceneItemLocked")
            .with_params(vec![
                p("canvasUuid", ParamKind::Str, "UUID of the canvas (alternative to sceneName/sceneUuid).", false),
                p("sceneName", ParamKind::Str, "Name of the scene the item is in.", false),
                p("sceneUuid", ParamKind::Str, "UUID of the scene (alternative to sceneName).", false),
                p("sceneItemId", ParamKind::Num, "Id of the scene item.", true),
            ])
            ,
        ToolDef::new("obs-set-scene-item-locked", "Lock or unlock a scene item.", "SetSceneItemLocked")
            .with_params(vec![
                p("canvasUuid", ParamKind::Str, "UUID of the canvas (alternative to sceneName/sceneUuid).", false),
                p("sceneName", ParamKind::Str, "Name of the scene the item is in.", false),
                p("sceneUuid", ParamKind::Str, "UUID of the scene (alternative to sceneName).", false),
                p("sceneItemId", ParamKind::Num, "Id of the scene item.", true),
                p("sceneItemLocked", ParamKind::Bool, "True to lock the item, false to unlock.", true),
            ])
            ,
        ToolDef::new("obs-get-scene-item-blend-mode", "Get the blend mode of a scene item.", "GetSceneItemBlendMode")
            .with_params(vec![
                p("canvasUuid", ParamKind::Str, "UUID of the canvas (alternative to sceneName/sceneUuid).", false),
                p("sceneName", ParamKind::Str, "Name of the scene the item is in.", false),
                p("sceneUuid", ParamKind::Str, "UUID of the scene (alternative to sceneName).", false),
                p("sceneItemId", ParamKind::Num, "Id of the scene item.", true),
            ])
            ,
        ToolDef::new("obs-set-scene-item-blend-mode", "Set the blend mode of a scene item.", "SetSceneItemBlendMode")
            .with_params(vec![
                p("canvasUuid", ParamKind::Str, "UUID of the canvas (alternative to sceneName/sceneUuid).", false),
                p("sceneName", ParamKind::Str, "Name of the scene the item is in.", false),
                p("sceneUuid", ParamKind::Str, "UUID of the scene (alternative to sceneName).", false),
                p("sceneItemId", ParamKind::Num, "Id of the scene item.", true),
                p("sceneItemBlendMode", ParamKind::Str, "Blend mode, e.g. OBS_BLEND_NORMAL, OBS_BLEND_ADDITIVE, OBS_BLEND_SCREEN.", true),
            ])
            ,
        ToolDef::new("obs-get-scene-item-source", "Get the source (name and id) associated with a scene item.", "GetSceneItemSource")
            .with_params(vec![
                p("canvasUuid", ParamKind::Str, "UUID of the canvas (alternative to sceneName/sceneUuid).", false),
                p("sceneName", ParamKind::Str, "Name of the scene the item is in.", false),
                p("sceneUuid", ParamKind::Str, "UUID of the scene (alternative to sceneName).", false),
                p("sceneItemId", ParamKind::Num, "Id of the scene item.", true),
            ])
            ,
        ToolDef::new("obs-get-scene-item-private-settings", "Get the private (internal) settings of a scene item.", "GetSceneItemPrivateSettings")
            .with_params(vec![
                p("canvasUuid", ParamKind::Str, "UUID of the canvas (alternative to sceneName/sceneUuid).", false),
                p("sceneName", ParamKind::Str, "Name of the scene the item is in.", false),
                p("sceneUuid", ParamKind::Str, "UUID of the scene (alternative to sceneName).", false),
                p("sceneItemId", ParamKind::Num, "Id of the scene item.", true),
            ])
            ,
        ToolDef::new("obs-set-scene-item-private-settings", "Update the private (internal) settings of a scene item; values are overlaid, never wiped.", "SetSceneItemPrivateSettings")
            .with_params(vec![
                p("canvasUuid", ParamKind::Str, "UUID of the canvas (alternative to sceneName/sceneUuid).", false),
                p("sceneName", ParamKind::Str, "Name of the scene the item is in.", false),
                p("sceneUuid", ParamKind::Str, "UUID of the scene (alternative to sceneName).", false),
                p("sceneItemId", ParamKind::Num, "Id of the scene item.", true),
                p("sceneItemSettings", ParamKind::Obj, "Private settings object to overlay onto the item.", true),
            ])
            ,
        ToolDef::new("obs-get-source-private-settings", "Get the private (internal) settings of a source.", "GetSourcePrivateSettings")
            .with_params(vec![
                p("canvasUuid", ParamKind::Str, "UUID of the canvas (alternative to sourceName/sourceUuid).", false),
                p("sourceName", ParamKind::Str, "Name of the source.", false),
                p("sourceUuid", ParamKind::Str, "UUID of the source (alternative to sourceName).", false),
            ])
            ,
        ToolDef::new("obs-set-source-private-settings", "Update the private (internal) settings of a source; values are overlaid, never wiped.", "SetSourcePrivateSettings")
            .with_params(vec![
                p("canvasUuid", ParamKind::Str, "UUID of the canvas (alternative to sourceName/sourceUuid).", false),
                p("sourceName", ParamKind::Str, "Name of the source.", false),
                p("sourceUuid", ParamKind::Str, "UUID of the source (alternative to sourceName).", false),
                p("sourceSettings", ParamKind::Obj, "Private settings object to overlay onto the source.", true),
            ])
            ,
        ToolDef::new("obs-get-input-audio-tracks", "Get the enabled state of all audio tracks of an input.", "GetInputAudioTracks")
            .with_params(vec![
                p("inputName", ParamKind::Str, "Name of the input.", false),
                p("inputUuid", ParamKind::Str, "UUID of the input (alternative to inputName).", false),
            ])
            ,
        ToolDef::new("obs-set-input-audio-tracks", "Set which audio tracks of an input are enabled.", "SetInputAudioTracks")
            .with_params(vec![
                p("inputName", ParamKind::Str, "Name of the input.", false),
                p("inputUuid", ParamKind::Str, "UUID of the input (alternative to inputName).", false),
                p("inputAudioTracks", ParamKind::Obj, "Object mapping track index to enabled state, e.g. { '1': true, '2': false }.", true),
            ])
            ,
        ToolDef::new("obs-get-input-deinterlace-mode", "Get the deinterlace mode of an input.", "GetInputDeinterlaceMode")
            .with_params(vec![
                p("inputName", ParamKind::Str, "Name of the input.", false),
                p("inputUuid", ParamKind::Str, "UUID of the input (alternative to inputName).", false),
            ])
            ,
        ToolDef::new("obs-set-input-deinterlace-mode", "Set the deinterlace mode of an input.", "SetInputDeinterlaceMode")
            .with_params(vec![
                p("inputName", ParamKind::Str, "Name of the input.", false),
                p("inputUuid", ParamKind::Str, "UUID of the input (alternative to inputName).", false),
                p("inputDeinterlaceMode", ParamKind::Str, "Deinterlace mode, e.g. OBS_DEINTERLACE_MODE_DISABLE, BLEND, BOB, DISCARD.", true),
            ])
            ,
        ToolDef::new("obs-get-input-deinterlace-field-order", "Get the deinterlace field order of an input.", "GetInputDeinterlaceFieldOrder")
            .with_params(vec![
                p("inputName", ParamKind::Str, "Name of the input.", false),
                p("inputUuid", ParamKind::Str, "UUID of the input (alternative to inputName).", false),
            ])
            ,
        ToolDef::new("obs-set-input-deinterlace-field-order", "Set the deinterlace field order of an input.", "SetInputDeinterlaceFieldOrder")
            .with_params(vec![
                p("inputName", ParamKind::Str, "Name of the input.", false),
                p("inputUuid", ParamKind::Str, "UUID of the input (alternative to inputName).", false),
                p("inputDeinterlaceFieldOrder", ParamKind::Str, "Field order, e.g. OBS_DEINTERLACE_FIELD_ORDER_TOP, BOTTOM.", true),
            ])
            ,
        ToolDef::new("obs-get-input-properties-list-items", "Get the selectable items of a list property in an input's properties.", "GetInputPropertiesListPropertyItems")
            .with_params(vec![
                p("inputName", ParamKind::Str, "Name of the input.", false),
                p("inputUuid", ParamKind::Str, "UUID of the input (alternative to inputName).", false),
                p("propertyName", ParamKind::Str, "Name of the list property to read.", true),
            ])
            ,
        ToolDef::new("obs-press-input-properties-button", "Press a button in the properties of an input.", "PressInputPropertiesButton")
            .with_params(vec![
                p("inputName", ParamKind::Str, "Name of the input.", false),
                p("inputUuid", ParamKind::Str, "UUID of the input (alternative to inputName).", false),
                p("propertyName", ParamKind::Str, "Name of the button property to press.", true),
            ])
            ,
        ToolDef::new("obs-get-transition-kind-list", "List all available transition kinds in OBS.", "GetTransitionKindList")
            ,
        ToolDef::new("obs-get-current-transition-cursor", "Get the cursor position of the current scene transition while it is running.", "GetCurrentSceneTransitionCursor")
            ,
        ToolDef::new("obs-get-scene-transition-override", "Get the transition overridden for a scene, if any.", "GetSceneSceneTransitionOverride")
            .with_params(vec![
                p("canvasUuid", ParamKind::Str, "UUID of the canvas (alternative to sceneName/sceneUuid).", false),
                p("sceneName", ParamKind::Str, "Name of the scene.", false),
                p("sceneUuid", ParamKind::Str, "UUID of the scene (alternative to sceneName).", false),
            ])
            ,
        ToolDef::new("obs-set-scene-transition-override", "Set or clear the transition overridden for a scene.", "SetSceneSceneTransitionOverride")
            .with_params(vec![
                p("canvasUuid", ParamKind::Str, "UUID of the canvas (alternative to sceneName/sceneUuid).", false),
                p("sceneName", ParamKind::Str, "Name of the scene.", false),
                p("sceneUuid", ParamKind::Str, "UUID of the scene (alternative to sceneName).", false),
                p("transitionName", ParamKind::Str, "Name of the transition to override with (omit to clear the override).", false),
                p("transitionDuration", ParamKind::Num, "Duration of the override transition in milliseconds.", false),
            ])
            ,
        ToolDef::new("obs-set-tbar-position", "Set the position of the TBar (manual transition control).", "SetTBarPosition")
            .with_params(vec![
                p("position", ParamKind::Num, "TBar position between 0.0 and 1.0.", true),
                p("release", ParamKind::Bool, "True to release the TBar after setting the position.", false),
            ])
            ,
    ]
}