fix(dynatrace): make the synthetic enabled filter tri-state

Review catch. `enabled` on List Synthetic Monitors is a three-way filter —
enabled, disabled, or either — and I had it as a switch. The URL builder
deliberately serializes `false` (there is a test pinning that `evaluate=false`
survives), so leaving "Enabled Only" unchecked sent `enabled=false` and
returned only the disabled monitors: exactly backwards.

Made it a dropdown with Any / Enabled only / Disabled only, matching the
monitorType field directly above it, which had the same shape and already used
an empty-id "Any" option. The params mapper sends nothing for "Any".

Checked the other nine switches rather than assuming. None share the bug: for
each of them off genuinely means false, and false is Dynatrace's own default,
so serializing it is correct. A test now pins that list so the trap cannot be
re-introduced by converting one of them, alongside a test covering all three
states of the filter.

Author: waleedlatif1

apps/sim/blocks/blocks/dynatrace.ts

@@ -1086,9 +1086,17 @@ Return ONLY the selector string - no explanations, no surrounding quotes.`,
       condition: { field: 'operation', value: 'dynatrace_list_synthetic_monitors' },
     },
     {
+      // A tri-state filter, not a boolean: leaving it unset must send no
+      // `enabled` param at all. A switch would serialize its off position as
+      // `enabled=false` and silently return only the disabled monitors.
       id: 'monitorEnabled',
-      title: 'Enabled Only',
-      type: 'switch',
+      title: 'Enabled State',
+      type: 'dropdown',
+      options: [
+        { label: 'Any', id: '' },
+        { label: 'Enabled only', id: 'true' },
+        { label: 'Disabled only', id: 'false' },
+      ],
       mode: 'advanced',
       condition: { field: 'operation', value: 'dynatrace_list_synthetic_monitors' },
     },
@@ -1710,7 +1718,8 @@ Return ONLY the selector string - no explanations, no surrounding quotes.`,
             return {
               ...baseParams,
               type: params.monitorType || undefined,
-              enabled: params.monitorEnabled,
+              // '' means "any", so send no filter rather than enabled=false.
+              enabled: params.monitorEnabled ? params.monitorEnabled === 'true' : undefined,
               location: params.monitorLocation || undefined,
               tag: params.monitorTag || undefined,
               managementZone: toNumber(params.monitorManagementZone),

apps/sim/tools/dynatrace/dynatrace.test.ts

@@ -2,6 +2,7 @@
  * @vitest-environment node
  */
 import { describe, expect, it } from 'vitest'
+import { DynatraceBlock } from '@/blocks/blocks/dynatrace'
 import { addTagsTool } from '@/tools/dynatrace/add_tags'
 import { closeProblemTool } from '@/tools/dynatrace/close_problem'
 import { createSettingsObjectTool } from '@/tools/dynatrace/create_settings_object'
@@ -128,6 +129,56 @@ describe('new-surface request shaping', () => {
     )
   })
 
+  it('treats the synthetic enabled filter as tri-state, not a boolean', () => {
+    const params = (DynatraceBlock.tools.config?.params ?? (() => ({}))) as (
+      p: Record<string, unknown>
+    ) => Record<string, unknown>
+    const call = (monitorEnabled: string | undefined) =>
+      params({
+        operation: 'dynatrace_list_synthetic_monitors',
+        environmentUrl: ENV,
+        apiToken: TOKEN,
+        monitorEnabled,
+      })
+
+    // "Any" must send no filter — `enabled=false` would return only the
+    // disabled monitors, which is the opposite of what the user asked for.
+    expect(call('').enabled).toBeUndefined()
+    expect(call(undefined).enabled).toBeUndefined()
+    expect(call('true').enabled).toBe(true)
+    expect(call('false').enabled).toBe(false)
+
+    expect(url(listSyntheticMonitorsTool, { environmentUrl: ENV, apiToken: TOKEN })).toBe(
+      `${ENV}/api/v1/synthetic/monitors`
+    )
+    expect(
+      url(listSyntheticMonitorsTool, { environmentUrl: ENV, apiToken: TOKEN, enabled: true })
+    ).toBe(`${ENV}/api/v1/synthetic/monitors?enabled=true`)
+  })
+
+  it('keeps every remaining switch a real boolean, since off means false for each', () => {
+    // monitorEnabled was the only tri-state filter. For the rest, Dynatrace's
+    // own default is false, so serializing the off position is correct — this
+    // pins that they stay switches rather than drifting into the same trap.
+    const switches = DynatraceBlock.subBlocks
+      .filter((sb) => sb.type === 'switch')
+      .map((sb) => sb.id)
+    expect(switches).not.toContain('monitorEnabled')
+    expect(switches.sort()).toEqual(
+      [
+        'burnRateVisualizationEnabled',
+        'deleteAllWithKey',
+        'evaluate',
+        'failOnPerformanceIssue',
+        'showGlobalSlos',
+        'sloEnabled',
+        'stopOnProblem',
+        'takeScreenshotsOnSuccess',
+        'validateOnly',
+      ].sort()
+    )
+  })
+
   it('repeats the synthetic tag param once per value', () => {
     expect(url(listSyntheticMonitorsTool, { ...base, tag: 'a, b' })).toBe(
       `${ENV}/api/v1/synthetic/monitors?tag=a&tag=b`