fix(datadog): tolerate non-string list inputs and keep the shipped mute subblock ids

Both defects were introduced by this branch.

- splitCommaList called .split on its argument, so routing create_downtime's monitorId
  through it turned a legitimate numeric input into a TypeError before the request was
  built. A <Block.output> reference to get_monitor or list_monitors resolves to a number,
  and an LLM tool call can pass a number or an array, so the helper now normalizes all
  three shapes. The previous Number.parseInt path had accepted a number by coercion.
- Adding the unmute operation renamed the mute subblock ids scope/end to muteScope/muteEnd.
  Workflow state is persisted by subblock id, so every existing Mute Monitor block would
  have kept the old keys and silently lost its scope and end time. Restored the shipped ids;
  both are still unique block-wide and no operation reads another operation's value.

Author: waleedlatif1

apps/sim/blocks/blocks/datadog.ts

@@ -53,12 +53,12 @@ export const DatadogBlock: BlockConfig<DatadogResponse> = {
         ],
         datadog_mute_monitor: [
           { text: 'Mute monitor', field: 'muteMonitorId', core: true },
-          { text: ', for scope', field: 'muteScope' },
-          { text: ', until', field: 'muteEnd' },
+          { text: ', for scope', field: 'scope' },
+          { text: ', until', field: 'end' },
         ],
         datadog_unmute_monitor: [
           { text: 'Unmute monitor', field: 'muteMonitorId', core: true },
-          { text: ', for scope', field: 'muteScope' },
+          { text: ', for scope', field: 'scope' },
         ],
         datadog_query_logs: [
           { text: 'Search logs matching', field: 'logQuery', core: true },
@@ -528,7 +528,7 @@ Return ONLY valid JSON - no explanations, no markdown code blocks.`,
       required: { field: 'operation', value: ['datadog_mute_monitor', 'datadog_unmute_monitor'] },
     },
     {
-      id: 'muteScope',
+      id: 'scope',
       title: 'Scope',
       type: 'short-input',
       placeholder: 'host:myhost (leave blank for all scopes)',
@@ -539,7 +539,7 @@ Return ONLY valid JSON - no explanations, no markdown code blocks.`,
       mode: 'advanced',
     },
     {
-      id: 'muteEnd',
+      id: 'end',
       title: 'Mute Until (Unix Timestamp)',
       type: 'short-input',
       placeholder: 'Leave empty to mute until unmuted',
@@ -1995,15 +1995,15 @@ Return ONLY the search query string - no explanations.`,
             return {
               ...baseParams,
               monitorId: params.muteMonitorId,
-              scope: params.muteScope || undefined,
-              end: params.muteEnd ? Number(params.muteEnd) : undefined,
+              scope: params.scope || undefined,
+              end: params.end ? Number(params.end) : undefined,
             }
 
           case 'datadog_unmute_monitor':
             return {
               ...baseParams,
               monitorId: params.muteMonitorId,
-              scope: params.muteScope || undefined,
+              scope: params.scope || undefined,
               allScopes: toSwitchBoolean(params.unmuteAllScopes),
             }
 
@@ -2323,8 +2323,8 @@ Return ONLY the search query string - no explanations.`,
     monitorId: { type: 'string', description: 'Monitor ID' },
     // Logs
     muteMonitorId: { type: 'string', description: 'Monitor ID to mute or unmute' },
-    muteScope: { type: 'string', description: 'Scope to mute or unmute' },
-    muteEnd: { type: 'number', description: 'Unix timestamp when the mute ends' },
+    scope: { type: 'string', description: 'Scope to mute or unmute' },
+    end: { type: 'number', description: 'Unix timestamp when the mute ends' },
     unmuteAllScopes: { type: 'boolean', description: 'Clear mute settings for every scope' },
     logQuery: { type: 'string', description: 'Log search query' },
     logFrom: { type: 'string', description: 'Log start time' },

apps/sim/tools/datadog/datadog.test.ts

@@ -16,7 +16,12 @@ import { submitMetricsTool } from '@/tools/datadog/submit_metrics'
 import { unmuteMonitorTool } from '@/tools/datadog/unmute_monitor'
 import { updateIncidentTool } from '@/tools/datadog/update_incident'
 import { updateSloTool } from '@/tools/datadog/update_slo'
-import { buildSloPayload, datadogErrorMessage, mergeSloUpdatePayload } from '@/tools/datadog/utils'
+import {
+  buildSloPayload,
+  datadogErrorMessage,
+  mergeSloUpdatePayload,
+  splitCommaList,
+} from '@/tools/datadog/utils'
 
 const auth = { apiKey: 'key', applicationKey: 'app-key' } as const
 
@@ -401,6 +406,36 @@ describe('create_downtime monitor targeting', () => {
     const body = callBody(createDowntimeTool, { ...auth, scope: '*', monitorId: '123' } as any)
     expect(body.data.attributes.monitor_identifier).toEqual({ monitor_id: 123 })
   })
+
+  /**
+   * A `<Block.output>` reference to get_monitor resolves to a number, and an LLM tool
+   * call can pass one too, so the parser must not assume a string.
+   */
+  it('accepts a monitor id that arrives as a number', () => {
+    const body = callBody(createDowntimeTool, { ...auth, scope: '*', monitorId: 123 } as any)
+    expect(body.data.attributes.monitor_identifier).toEqual({ monitor_id: 123 })
+  })
+
+  it('accepts monitor tags that arrive as an array', () => {
+    const body = callBody(createDowntimeTool, {
+      ...auth,
+      scope: '*',
+      monitorTags: ['team:backend', 'priority:high'],
+    } as any)
+    expect(body.data.attributes.monitor_identifier).toEqual({
+      monitor_tags: ['team:backend', 'priority:high'],
+    })
+  })
+})
+
+describe('splitCommaList input tolerance', () => {
+  it('handles strings, numbers, and arrays without throwing', () => {
+    expect(splitCommaList('a, b')).toEqual(['a', 'b'])
+    expect(splitCommaList(123)).toEqual(['123'])
+    expect(splitCommaList([1, 2])).toEqual(['1', '2'])
+    expect(splitCommaList(undefined)).toBeUndefined()
+    expect(splitCommaList('')).toBeUndefined()
+  })
 })
 
 describe('registry surface', () => {

apps/sim/tools/datadog/utils.ts

@@ -62,12 +62,17 @@ export async function datadogErrorMessage(response: Response): Promise<string> {
   return messages.length > 0 ? messages.join('; ') : fallback
 }
 
-/** Splits a comma-separated user input into a trimmed, non-empty list. */
-export function splitCommaList(value: string | undefined): string[] | undefined {
-  if (!value) return undefined
-  const items = value
-    .split(',')
-    .map((item) => item.trim())
+/**
+ * Splits a comma-separated user input into a trimmed, non-empty list.
+ *
+ * Accepts `unknown` because a `<Block.output>` reference can resolve to a non-string:
+ * a monitor ID read from `get_monitor` arrives as a number, and an LLM tool call can
+ * pass an array. Calling `.split` on those would throw before the request is built.
+ */
+export function splitCommaList(value: unknown): string[] | undefined {
+  if (value === undefined || value === null || value === '') return undefined
+  const items = (Array.isArray(value) ? value : String(value).split(','))
+    .map((item) => String(item).trim())
     .filter((item) => item.length > 0)
   return items.length > 0 ? items : undefined
 }
@@ -92,7 +97,7 @@ export function parseJsonParam<T>(value: unknown, fieldName: string): T | undefi
  * `Number('abc')` yields `NaN`, which `JSON.stringify` writes as `null` and Datadog
  * rejects with a message that names nothing the user typed, so bad input is rejected here.
  */
-export function parseMonitorIds(value: string | undefined): number[] | undefined {
+export function parseMonitorIds(value: unknown): number[] | undefined {
   const items = splitCommaList(value)
   if (!items) return undefined
   return items.map((id) => {