chore: import upstream snapshot with attribution

apps/sim/tools/workflow/executor.test.ts

@@ -0,0 +1,390 @@
+import { describe, expect, it } from 'vitest'
+import { workflowExecutorTool } from '@/tools/workflow/executor'
+
+describe('workflowExecutorTool', () => {
+  describe('request.body', () => {
+    const buildBody = workflowExecutorTool.request.body!
+
+    it.concurrent('should pass through object inputMapping unchanged (LLM-provided args)', () => {
+      const params = {
+        workflowId: 'test-workflow-id',
+        inputMapping: { firstName: 'John', lastName: 'Doe', age: 30 },
+      }
+
+      const result = buildBody(params)
+
+      expect(result).toEqual({
+        input: { firstName: 'John', lastName: 'Doe', age: 30 },
+        triggerType: 'workflow',
+        useDraftState: true,
+      })
+    })
+
+    it.concurrent('should use deployed state when isDeployedContext is true', () => {
+      const params = {
+        workflowId: 'test-workflow-id',
+        inputMapping: { name: 'Test' },
+        _context: { isDeployedContext: true },
+      }
+
+      const result = buildBody(params)
+
+      expect(result).toEqual({
+        input: { name: 'Test' },
+        triggerType: 'workflow',
+        useDraftState: false,
+      })
+    })
+
+    it.concurrent('should use draft state when isDeployedContext is false', () => {
+      const params = {
+        workflowId: 'test-workflow-id',
+        inputMapping: { name: 'Test' },
+        _context: { isDeployedContext: false },
+      }
+
+      const result = buildBody(params)
+
+      expect(result).toEqual({
+        input: { name: 'Test' },
+        triggerType: 'workflow',
+        useDraftState: true,
+      })
+    })
+
+    it.concurrent('should declare parentWorkspaceId when the context has a workspace', () => {
+      const params = {
+        workflowId: 'test-workflow-id',
+        inputMapping: { name: 'Test' },
+        _context: { workspaceId: 'workspace-parent' },
+      }
+
+      const result = buildBody(params)
+
+      expect(result).toEqual({
+        input: { name: 'Test' },
+        triggerType: 'workflow',
+        useDraftState: true,
+        parentWorkspaceId: 'workspace-parent',
+      })
+    })
+
+    it.concurrent('should omit parentWorkspaceId when the context has no workspace', () => {
+      const params = {
+        workflowId: 'test-workflow-id',
+        inputMapping: { name: 'Test' },
+        _context: { isDeployedContext: true },
+      }
+
+      const result = buildBody(params)
+
+      expect(result).toEqual({
+        input: { name: 'Test' },
+        triggerType: 'workflow',
+        useDraftState: false,
+      })
+    })
+
+    it.concurrent('should parse JSON string inputMapping (UI-provided via tool-input)', () => {
+      const params = {
+        workflowId: 'test-workflow-id',
+        inputMapping: '{"firstName": "John", "lastName": "Doe"}',
+      }
+
+      const result = buildBody(params)
+
+      expect(result).toEqual({
+        input: { firstName: 'John', lastName: 'Doe' },
+        triggerType: 'workflow',
+        useDraftState: true,
+      })
+    })
+
+    it.concurrent('should handle nested objects in JSON string inputMapping', () => {
+      const params = {
+        workflowId: 'test-workflow-id',
+        inputMapping: '{"user": {"name": "John", "email": "john@example.com"}, "count": 5}',
+      }
+
+      const result = buildBody(params)
+
+      expect(result).toEqual({
+        input: { user: { name: 'John', email: 'john@example.com' }, count: 5 },
+        triggerType: 'workflow',
+        useDraftState: true,
+      })
+    })
+
+    it.concurrent('should handle arrays in JSON string inputMapping', () => {
+      const params = {
+        workflowId: 'test-workflow-id',
+        inputMapping: '{"tags": ["a", "b", "c"], "ids": [1, 2, 3]}',
+      }
+
+      const result = buildBody(params)
+
+      expect(result).toEqual({
+        input: { tags: ['a', 'b', 'c'], ids: [1, 2, 3] },
+        triggerType: 'workflow',
+        useDraftState: true,
+      })
+    })
+
+    it.concurrent('should default to empty object when inputMapping is undefined', () => {
+      const params = {
+        workflowId: 'test-workflow-id',
+        inputMapping: undefined,
+      }
+
+      const result = buildBody(params)
+
+      expect(result).toEqual({
+        input: {},
+        triggerType: 'workflow',
+        useDraftState: true,
+      })
+    })
+
+    it.concurrent('should default to empty object when inputMapping is null', () => {
+      const params = {
+        workflowId: 'test-workflow-id',
+        inputMapping: null as any,
+      }
+
+      const result = buildBody(params)
+
+      expect(result).toEqual({
+        input: {},
+        triggerType: 'workflow',
+        useDraftState: true,
+      })
+    })
+
+    it.concurrent('should fallback to empty object for invalid JSON string', () => {
+      const params = {
+        workflowId: 'test-workflow-id',
+        inputMapping: 'not valid json {',
+      }
+
+      const result = buildBody(params)
+
+      expect(result).toEqual({
+        input: {},
+        triggerType: 'workflow',
+        useDraftState: true,
+      })
+    })
+
+    it.concurrent('should fallback to empty object for empty string', () => {
+      const params = {
+        workflowId: 'test-workflow-id',
+        inputMapping: '',
+      }
+
+      const result = buildBody(params)
+
+      expect(result).toEqual({
+        input: {},
+        triggerType: 'workflow',
+        useDraftState: true,
+      })
+    })
+
+    it.concurrent('should handle empty object inputMapping', () => {
+      const params = {
+        workflowId: 'test-workflow-id',
+        inputMapping: {},
+      }
+
+      const result = buildBody(params)
+
+      expect(result).toEqual({
+        input: {},
+        triggerType: 'workflow',
+        useDraftState: true,
+      })
+    })
+
+    it.concurrent('should handle empty JSON object string', () => {
+      const params = {
+        workflowId: 'test-workflow-id',
+        inputMapping: '{}',
+      }
+
+      const result = buildBody(params)
+
+      expect(result).toEqual({
+        input: {},
+        triggerType: 'workflow',
+        useDraftState: true,
+      })
+    })
+
+    it.concurrent('should preserve special characters in string values', () => {
+      const params = {
+        workflowId: 'test-workflow-id',
+        inputMapping: '{"message": "Hello\\nWorld", "path": "C:\\\\Users"}',
+      }
+
+      const result = buildBody(params)
+
+      expect(result).toEqual({
+        input: { message: 'Hello\nWorld', path: 'C:\\Users' },
+        triggerType: 'workflow',
+        useDraftState: true,
+      })
+    })
+
+    it.concurrent('should handle unicode characters in JSON string', () => {
+      const params = {
+        workflowId: 'test-workflow-id',
+        inputMapping: '{"greeting": "こんにちは", "emoji": "👋"}',
+      }
+
+      const result = buildBody(params)
+
+      expect(result).toEqual({
+        input: { greeting: 'こんにちは', emoji: '👋' },
+        triggerType: 'workflow',
+        useDraftState: true,
+      })
+    })
+
+    it.concurrent('should not modify object with string values that look like JSON', () => {
+      const params = {
+        workflowId: 'test-workflow-id',
+        inputMapping: { data: '{"nested": "json"}' },
+      }
+
+      const result = buildBody(params)
+
+      expect(result).toEqual({
+        input: { data: '{"nested": "json"}' },
+        triggerType: 'workflow',
+        useDraftState: true,
+      })
+    })
+  })
+
+  describe('request.url', () => {
+    it.concurrent('should build correct URL with workflowId', () => {
+      const url = workflowExecutorTool.request.url as (params: any) => string
+
+      expect(url({ workflowId: 'abc-123' })).toBe('/api/workflows/abc-123/execute')
+      expect(url({ workflowId: 'my-workflow' })).toBe('/api/workflows/my-workflow/execute')
+    })
+  })
+
+  describe('transformResponse', () => {
+    const transformResponse = workflowExecutorTool.transformResponse!
+
+    function mockResponse(body: any, status = 200): Response {
+      return {
+        ok: status >= 200 && status < 300,
+        status,
+        json: async () => body,
+      } as unknown as Response
+    }
+
+    it.concurrent('should parse standard format response', async () => {
+      const body = {
+        success: true,
+        executionId: '550e8400-e29b-41d4-a716-446655440000',
+        output: { result: 'hello' },
+        metadata: { duration: 500 },
+      }
+
+      const result = await transformResponse(mockResponse(body))
+
+      expect(result.success).toBe(true)
+      expect(result.output).toEqual({ result: 'hello' })
+      expect(result.duration).toBe(500)
+      expect(result.error).toBeUndefined()
+    })
+
+    it.concurrent('should parse standard format failure', async () => {
+      const body = {
+        success: false,
+        executionId: '550e8400-e29b-41d4-a716-446655440000',
+        output: {},
+        error: 'Something went wrong',
+      }
+
+      const result = await transformResponse(mockResponse(body))
+
+      expect(result.success).toBe(false)
+      expect(result.error).toBe('Something went wrong')
+    })
+
+    it.concurrent('should default success to false when missing', async () => {
+      const body = { output: { data: 'test' } }
+
+      const result = await transformResponse(mockResponse(body))
+
+      expect(result.success).toBe(false)
+      expect(result.output).toEqual({ data: 'test' })
+    })
+
+    it.concurrent('should default output to empty object when missing', async () => {
+      const body = { success: true }
+
+      const result = await transformResponse(mockResponse(body))
+
+      expect(result.success).toBe(true)
+      expect(result.output).toEqual({})
+      expect(result.result).toEqual({})
+    })
+
+    it.concurrent('should extract metadata duration', async () => {
+      const body = {
+        success: true,
+        output: {},
+        metadata: { duration: 1234 },
+      }
+
+      const result = await transformResponse(mockResponse(body))
+
+      expect(result.duration).toBe(1234)
+    })
+
+    it.concurrent('should default duration to 0 when metadata is missing', async () => {
+      const body = { success: true, output: {} }
+
+      const result = await transformResponse(mockResponse(body))
+
+      expect(result.duration).toBe(0)
+    })
+
+    it.concurrent('should extract workflowId and workflowName', async () => {
+      const body = {
+        success: true,
+        output: {},
+        workflowId: 'wf-123',
+        workflowName: 'My Workflow',
+      }
+
+      const result = await transformResponse(mockResponse(body))
+
+      expect(result.childWorkflowId).toBe('wf-123')
+      expect(result.childWorkflowName).toBe('My Workflow')
+    })
+  })
+
+  describe('tool metadata', () => {
+    it.concurrent('should have correct id', () => {
+      expect(workflowExecutorTool.id).toBe('workflow_executor')
+    })
+
+    it.concurrent('should have required workflowId param', () => {
+      expect(workflowExecutorTool.params.workflowId.required).toBe(true)
+    })
+
+    it.concurrent('should have optional inputMapping param', () => {
+      expect(workflowExecutorTool.params.inputMapping.required).toBe(false)
+    })
+
+    it.concurrent('should use POST method', () => {
+      expect(workflowExecutorTool.request.method).toBe('POST')
+    })
+  })
+})

apps/sim/tools/workflow/executor.ts

@@ -0,0 +1,70 @@
+import type { ToolConfig } from '@/tools/types'
+import type { WorkflowExecutorParams, WorkflowExecutorResponse } from '@/tools/workflow/types'
+
+/**
+ * Tool for executing workflows as blocks within other workflows.
+ * This tool is used by the WorkflowBlockHandler to provide the execution capability.
+ */
+export const workflowExecutorTool: ToolConfig<
+  WorkflowExecutorParams,
+  WorkflowExecutorResponse['output']
+> = {
+  id: 'workflow_executor',
+  name: 'Workflow Executor',
+  description:
+    'Execute another workflow as a sub-workflow. Pass inputs as a JSON object with field names matching the child workflow\'s input format. Example: if child expects "name" and "email", pass {"name": "John", "email": "john@example.com"}',
+  version: '1.0.0',
+  params: {
+    workflowId: {
+      type: 'string',
+      required: true,
+      visibility: 'user-only',
+      description: 'The ID of the workflow to execute',
+    },
+    inputMapping: {
+      type: 'object',
+      required: false,
+      visibility: 'user-or-llm',
+      description:
+        'JSON object with keys matching the child workflow\'s input field names. Each key should map to the value you want to pass for that input field. Example: {"fieldName": "value", "otherField": 123}',
+    },
+  },
+  request: {
+    url: (params: WorkflowExecutorParams) => `/api/workflows/${params.workflowId}/execute`,
+    method: 'POST',
+    headers: () => ({ 'Content-Type': 'application/json' }),
+    body: (params: WorkflowExecutorParams) => {
+      let inputData = params.inputMapping || {}
+      if (typeof inputData === 'string') {
+        try {
+          inputData = JSON.parse(inputData)
+        } catch {
+          inputData = {}
+        }
+      }
+      // Use draft state for manual runs (not deployed), deployed state for deployed runs
+      const isDeployedContext = params._context?.isDeployedContext
+      const parentWorkspaceId = params._context?.workspaceId
+      return {
+        input: inputData,
+        triggerType: 'workflow',
+        useDraftState: !isDeployedContext,
+        ...(parentWorkspaceId ? { parentWorkspaceId } : {}),
+      }
+    },
+  },
+  transformResponse: async (response: Response) => {
+    const data = await response.json()
+    const outputData = data?.output ?? {}
+
+    return {
+      success: data?.success ?? false,
+      duration: data?.metadata?.duration ?? 0,
+      childWorkflowId: data?.workflowId ?? '',
+      childWorkflowName: data?.workflowName ?? '',
+      output: outputData, // For OpenAI provider
+      result: outputData, // For backwards compatibility
+      error: data?.error,
+    }
+  },
+}

apps/sim/tools/workflow/index.ts

@@ -0,0 +1 @@
+export { workflowExecutorTool } from '@/tools/workflow/executor'

apps/sim/tools/workflow/types.ts

@@ -0,0 +1,24 @@
+import type { ToolResponse } from '@/tools/types'
+
+export interface WorkflowExecutorParams {
+  workflowId: string
+  /** Can be a JSON string (from tool-input UI) or an object (from LLM args) */
+  inputMapping?: Record<string, any> | string
+  /** Execution context passed by handlers */
+  _context?: {
+    workflowId?: string
+    workspaceId?: string
+    executionId?: string
+    isDeployedContext?: boolean
+  }
+}
+
+export interface WorkflowExecutorResponse extends ToolResponse {
+  output: {
+    success: boolean
+    duration: number
+    childWorkflowId: string
+    childWorkflowName: string
+    [key: string]: any
+  }
+}