Function executeTool

apps/sim/tools/index.ts:905–1360

(
  toolId: string,
  params: Record<string, any>,
  options: ExecuteToolOptions = {}
)

 * All requests go directly - internal routes use regular fetch, external use SSRF-protected fetch
 */
export async function executeTool(
  toolId: string,
  params: Record<string, any>,
  options: ExecuteToolOptions = {}
): Promise<ToolResponse> {
  const { skipPostProcess = false, executionContext, signal } = options
  // Fall back to the workflow execution's abort signal so plan-based execution timeouts
  // and cancellation propagate to tool fetches when the caller passes no explicit signal.
  const effectiveSignal = signal ?? executionContext?.abortSignal
  // Capture start time for precise timing
  const startTime = new Date()
  const startTimeISO = startTime.toISOString()
  const requestId = generateRequestId()

  // Hoisted so the outer catch can attribute a thrown failure to the chosen key.
  let hostedKeyForMetrics: { provider: string; tool: string; key: string } | undefined

  try {
    let tool: ToolConfig | undefined

    // Normalize tool ID to strip resource suffixes (e.g., workflow_executor_<uuid> -> workflow_executor)
    const normalizedToolId = normalizeToolId(toolId)

    const scope = resolveToolScope(params, executionContext)

    const toolKind: 'skill' | 'custom' | 'mcp' | undefined =
      normalizedToolId === 'load_skill' || normalizedToolId === 'load_user_skill'
        ? 'skill'
        : isCustomTool(normalizedToolId)
          ? 'custom'
          : isMcpTool(normalizedToolId)
            ? 'mcp'
            : undefined

    // Runs for ALL tools (not just kinded ones) so the per-tool `deniedTools`
    // denylist is enforced alongside the existing mcp/custom/skill gates.
    if (scope.userId && scope.workspaceId) {
      await assertPermissionsAllowed({
        userId: scope.userId,
        workspaceId: scope.workspaceId,
        toolId: normalizedToolId,
        toolKind,
        ctx: executionContext,
      })
    }

    if (normalizedToolId === 'load_skill' || normalizedToolId === 'load_user_skill') {
      const skillName = params.skill_name
      if (!skillName || !scope.workspaceId) {
        return {
          success: false,
          output: { error: 'Missing skill_name or workspace context' },
          error: 'Missing skill_name or workspace context',
        }
      }
      const content = await resolveSkillContent(skillName, scope.workspaceId)
      if (!content) {
        return {