fix(resolver): agent response format, input formats, root level (#2925)

* fix(resolvers): agent response format, input formats, root level

* fix response block initial seeding

* fix tests

apps/sim/executor/handlers/human-in-the-loop/human-in-the-loop-handler.ts

@@ -17,6 +17,7 @@ import {
 } from '@/executor/human-in-the-loop/utils'
 import type { BlockHandler, ExecutionContext, PauseMetadata } from '@/executor/types'
 import { collectBlockData } from '@/executor/utils/block-data'
+import { parseObjectStrings } from '@/executor/utils/json'
 import type { SerializedBlock } from '@/serializer/types'
 import { executeTool } from '@/tools'
 
@@ -265,7 +266,7 @@ export class HumanInTheLoopBlockHandler implements BlockHandler {
 
     if (dataMode === 'structured' && inputs.builderData) {
       const convertedData = this.convertBuilderDataToJson(inputs.builderData)
-      return this.parseObjectStrings(convertedData)
+      return parseObjectStrings(convertedData)
     }
 
     return inputs.data || {}
@@ -485,29 +486,6 @@ export class HumanInTheLoopBlockHandler implements BlockHandler {
     )
   }
 
-  private parseObjectStrings(data: any): any {
-    if (typeof data === 'string') {
-      try {
-        const parsed = JSON.parse(data)
-        if (typeof parsed === 'object' && parsed !== null) {
-          return this.parseObjectStrings(parsed)
-        }
-        return parsed
-      } catch {
-        return data
-      }
-    } else if (Array.isArray(data)) {
-      return data.map((item) => this.parseObjectStrings(item))
-    } else if (typeof data === 'object' && data !== null) {
-      const result: any = {}
-      for (const [key, value] of Object.entries(data)) {
-        result[key] = this.parseObjectStrings(value)
-      }
-      return result
-    }
-    return data
-  }
-
   private parseStatus(status?: string): number {
     if (!status) return HTTP.STATUS.OK
     const parsed = Number(status)

apps/sim/executor/handlers/response/response-handler.ts

@@ -1,6 +1,7 @@
 import { createLogger } from '@sim/logger'
 import { BlockType, HTTP, REFERENCE } from '@/executor/constants'
 import type { BlockHandler, ExecutionContext, NormalizedBlockOutput } from '@/executor/types'
+import { parseObjectStrings } from '@/executor/utils/json'
 import type { SerializedBlock } from '@/serializer/types'
 
 const logger = createLogger('ResponseBlockHandler')
@@ -73,7 +74,7 @@ export class ResponseBlockHandler implements BlockHandler {
 
     if (dataMode === 'structured' && inputs.builderData) {
       const convertedData = this.convertBuilderDataToJson(inputs.builderData)
-      return this.parseObjectStrings(convertedData)
+      return parseObjectStrings(convertedData)
     }
 
     return inputs.data || {}
@@ -222,29 +223,6 @@ export class ResponseBlockHandler implements BlockHandler {
     )
   }
 
-  private parseObjectStrings(data: any): any {
-    if (typeof data === 'string') {
-      try {
-        const parsed = JSON.parse(data)
-        if (typeof parsed === 'object' && parsed !== null) {
-          return this.parseObjectStrings(parsed)
-        }
-        return parsed
-      } catch {
-        return data
-      }
-    } else if (Array.isArray(data)) {
-      return data.map((item) => this.parseObjectStrings(item))
-    } else if (typeof data === 'object' && data !== null) {
-      const result: any = {}
-      for (const [key, value] of Object.entries(data)) {
-        result[key] = this.parseObjectStrings(value)
-      }
-      return result
-    }
-    return data
-  }
-
   private parseStatus(status?: string): number {
     if (!status) return HTTP.STATUS.OK
     const parsed = Number(status)

apps/sim/executor/utils/json.ts

@@ -40,3 +40,30 @@ export function isJSONString(value: string): boolean {
   const trimmed = value.trim()
   return trimmed.startsWith('{') || trimmed.startsWith('[')
 }
+
+/**
+ * Recursively parses JSON strings within an object or array.
+ * Useful for normalizing data that may contain stringified JSON at various levels.
+ */
+export function parseObjectStrings(data: unknown): unknown {
+  if (typeof data === 'string') {
+    try {
+      const parsed = JSON.parse(data)
+      if (typeof parsed === 'object' && parsed !== null) {
+        return parseObjectStrings(parsed)
+      }
+      return parsed
+    } catch {
+      return data
+    }
+  } else if (Array.isArray(data)) {
+    return data.map((item) => parseObjectStrings(item))
+  } else if (typeof data === 'object' && data !== null) {
+    const result: Record<string, unknown> = {}
+    for (const [key, value] of Object.entries(data)) {
+      result[key] = parseObjectStrings(value)
+    }
+    return result
+  }
+  return data
+}

apps/sim/executor/variables/resolvers/block.test.ts

@@ -6,6 +6,10 @@ import type { ResolutionContext } from './reference'
 
 vi.mock('@sim/logger', () => loggerMock)
 
+vi.mock('@/lib/workflows/blocks/block-outputs', () => ({
+  getBlockOutputs: vi.fn(() => ({})),
+}))
+
 function createTestWorkflow(
   blocks: Array<{
     id: string
@@ -140,16 +144,21 @@ describe('BlockResolver', () => {
       expect(resolver.resolve('<source.nonexistent>', ctx)).toBeUndefined()
     })
 
-    it.concurrent('should throw error for path not in output schema', () => {
+    it.concurrent('should throw error for path not in output schema', async () => {
+      const { getBlockOutputs } = await import('@/lib/workflows/blocks/block-outputs')
+      const mockGetBlockOutputs = vi.mocked(getBlockOutputs)
+      const customOutputs = {
+        validField: { type: 'string', description: 'A valid field' },
+        nested: {
+          child: { type: 'number', description: 'Nested child' },
+        },
+      }
+      mockGetBlockOutputs.mockReturnValue(customOutputs as any)
+
       const workflow = createTestWorkflow([
         {
           id: 'source',
-          outputs: {
-            validField: { type: 'string', description: 'A valid field' },
-            nested: {
-              child: { type: 'number', description: 'Nested child' },
-            },
-          },
+          outputs: customOutputs,
         },
       ])
       const resolver = new BlockResolver(workflow)
@@ -161,6 +170,8 @@ describe('BlockResolver', () => {
         /"invalidField" doesn't exist on block "source"/
       )
       expect(() => resolver.resolve('<source.invalidField>', ctx)).toThrow(/Available fields:/)
+
+      mockGetBlockOutputs.mockReturnValue({})
     })
 
     it.concurrent('should return undefined for path in schema but missing in data', () => {
@@ -298,45 +309,6 @@ describe('BlockResolver', () => {
     })
   })
 
-  describe('tryParseJSON', () => {
-    it.concurrent('should parse valid JSON object string', () => {
-      const resolver = new BlockResolver(createTestWorkflow())
-      expect(resolver.tryParseJSON('{"key": "value"}')).toEqual({ key: 'value' })
-    })
-
-    it.concurrent('should parse valid JSON array string', () => {
-      const resolver = new BlockResolver(createTestWorkflow())
-      expect(resolver.tryParseJSON('[1, 2, 3]')).toEqual([1, 2, 3])
-    })
-
-    it.concurrent('should return original value for non-string input', () => {
-      const resolver = new BlockResolver(createTestWorkflow())
-      const obj = { key: 'value' }
-      expect(resolver.tryParseJSON(obj)).toBe(obj)
-      expect(resolver.tryParseJSON(123)).toBe(123)
-      expect(resolver.tryParseJSON(null)).toBe(null)
-    })
-
-    it.concurrent('should return original string for non-JSON strings', () => {
-      const resolver = new BlockResolver(createTestWorkflow())
-      expect(resolver.tryParseJSON('plain text')).toBe('plain text')
-      expect(resolver.tryParseJSON('123')).toBe('123')
-      expect(resolver.tryParseJSON('')).toBe('')
-    })
-
-    it.concurrent('should return original string for invalid JSON', () => {
-      const resolver = new BlockResolver(createTestWorkflow())
-      expect(resolver.tryParseJSON('{invalid json}')).toBe('{invalid json}')
-      expect(resolver.tryParseJSON('[1, 2,')).toBe('[1, 2,')
-    })
-
-    it.concurrent('should handle whitespace around JSON', () => {
-      const resolver = new BlockResolver(createTestWorkflow())
-      expect(resolver.tryParseJSON('  {"key": "value"}  ')).toEqual({ key: 'value' })
-      expect(resolver.tryParseJSON('\n[1, 2]\n')).toEqual([1, 2])
-    })
-  })
-
   describe('Response block backwards compatibility', () => {
     it.concurrent('should resolve new format: <responseBlock.data>', () => {
       const workflow = createTestWorkflow([

apps/sim/executor/variables/resolvers/block.ts

@@ -1,3 +1,4 @@
+import { getBlockOutputs } from '@/lib/workflows/blocks/block-outputs'
 import { USER_FILE_ACCESSIBLE_PROPERTIES } from '@/lib/workflows/types'
 import {
   isReference,
@@ -229,9 +230,15 @@ export class BlockResolver implements Resolver {
       }
     }
 
+    const blockType = block?.metadata?.id
+    const params = block?.config?.params as Record<string, unknown> | undefined
+    const subBlocks = params
+      ? Object.fromEntries(Object.entries(params).map(([k, v]) => [k, { value: v }]))
+      : undefined
     const toolId = block?.config?.tool
     const toolConfig = toolId ? getTool(toolId) : undefined
-    const outputSchema = toolConfig?.outputs ?? block?.outputs
+    const outputSchema =
+      toolConfig?.outputs ?? (blockType ? getBlockOutputs(blockType, subBlocks) : block?.outputs)
     const schemaFields = getSchemaFieldNames(outputSchema)
     if (schemaFields.length > 0 && !isPathInOutputSchema(outputSchema, pathParts)) {
       throw new Error(
@@ -336,21 +343,4 @@ export class BlockResolver implements Resolver {
     }
     return String(value)
   }
-
-  tryParseJSON(value: any): any {
-    if (typeof value !== 'string') {
-      return value
-    }
-
-    const trimmed = value.trim()
-    if (trimmed.length > 0 && (trimmed.startsWith('{') || trimmed.startsWith('['))) {
-      try {
-        return JSON.parse(trimmed)
-      } catch {
-        return value
-      }
-    }
-
-    return value
-  }
 }